using System;
using System.Collections.Generic;
using Unity.Collections.LowLevel.Unsafe;
using UnityEngine.InputSystem.LowLevel;
using UnityEngine.InputSystem.Controls;
using UnityEngine.InputSystem.Utilities;
////TODO: recorded times are baked *external* times; reset touch when coming out of play mode
////REVIEW: record velocity on touches? or add method to very easily get the data?
////REVIEW: do we need to keep old touches around on activeTouches like the old UnityEngine touch API?
namespace UnityEngine.InputSystem.EnhancedTouch
{
/// <summary>
/// A high-level representation of a touch which automatically keeps track of a touch
/// over time.
/// </summary>
/// <remarks>
/// This API obsoletes the need for manually keeping tracking of touch IDs (<see cref="TouchControl.touchId"/>)
/// and touch phases (<see cref="TouchControl.phase"/>) in order to tell one touch apart from another.
///
/// Also, this class protects against losing touches. If a touch is shorter-lived than a single input update,
/// <see cref="Touchscreen"/> may overwrite it with a new touch coming in in the same update whereas this class
/// will retain all changes that happened on the touchscreen in any particular update.
///
/// The API makes a distinction between "fingers" and "touches". A touch refers to one contact state change event, that is, a
/// finger beginning to touch the screen (<see cref="TouchPhase.Began"/>), moving on the screen (<see cref="TouchPhase.Moved"/>),
/// or being lifted off the screen (<see cref="TouchPhase.Ended"/> or <see cref="TouchPhase.Canceled"/>).
/// A finger, on the other hand, always refers to the Nth contact on the screen.
///
/// A Touch instance is a struct which only contains a reference to the actual data which is stored in unmanaged
/// memory.
/// </remarks>
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1724:TypeNamesShouldNotMatchNamespaces")]
public struct Touch : IEquatable<Touch>
{
// The way this works is that at the core, it simply attaches one InputStateHistory per "<Touchscreen>/touch*"
// control and then presents a public API that crawls over the recorded touch history in various ways.
/// <summary>
/// Whether this touch record holds valid data.
/// </summary>
/// <value>If true, the data contained in the touch is valid.</value>
/// <remarks>
/// Touch data is stored in unmanaged memory as a circular input buffer. This means that when
/// the buffer runs out of capacity, older touch entries will get reused. When this happens,
/// existing <c>Touch</c> instances referring to the record become invalid.
///
/// This property can be used to determine whether the record held on to by the <c>Touch</c>
/// instance is still valid.
///
/// This property will be <c>false</c> for default-initialized <c>Touch</c> instances.
///
/// Note that accessing most of the other properties on this struct when the touch is
/// invalid will trigger <c>InvalidOperationException</c>.
/// </remarks>
public bool valid => m_TouchRecord.valid;
/// <summary>
/// The finger used for the touch contact. Null only for default-initialized
/// instances of the struct.
/// </summary>
/// <value>Finger used for the touch contact.</value>
/// <seealso cref="activeFingers"/>
public Finger finger => m_Finger;
/// <summary>
/// Current phase of the touch.
/// </summary>
/// <value>Current phase of the touch.</value>
/// <remarks>
/// Every touch goes through a predefined cycle that starts with <see cref="TouchPhase.Began"/>,
/// then potentially <see cref="TouchPhase.Moved"/> and/or <see cref="TouchPhase.Stationary"/>,
/// and finally concludes with either <see cref="TouchPhase.Ended"/> or <see cref="TouchPhase.Canceled"/>.
///
/// This property indicates where in the cycle the touch is.
/// </remarks>
/// <seealso cref="isInProgress"/>
/// <seealso cref="TouchControl.phase"/>
public TouchPhase phase => state.phase;
/// <summary>
/// Whether the touch has begun this frame, i.e. whether <see cref="phase"/> is <see cref="TouchPhase.Began"/>.
/// </summary>
/// <seealso cref="phase"/>
/// <seealso cref="ended"/>
/// <seealso cref="inProgress"/>
public bool began => phase == TouchPhase.Began;
/// <summary>
/// Whether the touch is currently in progress, i.e. whether <see cref="phase"/> is either
/// <see cref="TouchPhase.Moved"/>, <see cref="TouchPhase.Stationary"/>, or <see cref="TouchPhase.Began"/>.
/// </summary>
/// <seealso cref="phase"/>
/// <seealso cref="began"/>
/// <seealso cref="ended"/>
public bool inProgress => phase == TouchPhase.Moved || phase == TouchPhase.Stationary || phase == TouchPhase.Began;
/// <summary>
/// Whether the touch has ended this frame, i.e. whether <see cref="phase"/> is either
/// <see cref="TouchPhase.Ended"/> or <see cref="TouchPhase.Canceled"/>.
/// </summary>
/// <seealso cref="phase"/>
/// <seealso cref="began"/>
/// <seealso cref="isInProgress"/>
public bool ended => phase == TouchPhase.Ended || phase == TouchPhase.Canceled;
/// <summary>
/// Unique ID of the touch as (usually) assigned by the platform.
/// </summary>
/// <value>Unique, non-zero ID of the touch.</value>
/// <remarks>
/// Each touch contact that is made with the screen receives its own unique ID which is
/// normally assigned by the underlying platform.
///
/// Note a platform may reuse touch IDs after their respective touches have finished.
/// This means that the guarantee of uniqueness is only made with respect to <see cref="activeTouches"/>.
///
/// In particular, all touches in <see cref="history"/> will have the same ID whereas
/// touches in the a finger's <see cref="Finger.touchHistory"/> may end up having the same
/// touch ID even though constituting different physical touch contacts.
/// </remarks>
/// <seealso cref="TouchControl.touchId"/>
public int touchId => state.touchId;
/// <summary>
/// Normalized pressure of the touch against the touch surface.
/// </summary>
/// <value>Pressure level of the touch.</value>
/// <remarks>
/// Not all touchscreens are pressure-sensitive. If unsupported, this property will
/// always return 0.
///
/// In general, touch pressure is supported on mobile platforms only.
///
/// Note that it is possible for the value to go above 1 even though it is considered normalized. The reason is
/// that calibration on the system can put the maximum pressure point below the physically supported maximum value.
/// </remarks>
/// <seealso cref="TouchControl.pressure"/>
public float pressure => state.pressure;
/// <summary>
/// Screen-space radius of the touch.
/// </summary>
/// <value>Horizontal and vertical extents of the touch contact.</value>
/// <remarks>
/// If supported by the underlying device, this reports the size of the touch contact based on its
/// <see cref="screenPosition"/> center point. If not supported, this will be <c>default(Vector2)</c>.
/// </remarks>
/// <seealso cref="TouchControl.radius"/>
public Vector2 radius => state.radius;
/// <summary>
/// Time in seconds on the same timeline as <c>Time.realTimeSinceStartup</c> when the touch began.
/// </summary>
/// <value>Start time of the touch.</value>
/// <remarks>
/// This is the value of <see cref="InputEvent.time"/> when the touch started with
/// <see cref="phase"/> <see cref="TouchPhase.Began"/>.
/// </remarks>
/// <seealso cref="TouchControl.startTime"/>
public double startTime => state.startTime;
/// <summary>
/// Time in seconds on the same timeline as <c>Time.realTimeSinceStartup</c> when the touch record was
/// reported.
/// </summary>
/// <value>Time the touch record was reported.</value>
/// <remarks>
/// This is the value <see cref="InputEvent.time"/> of the event that signaled the current state
/// change for the touch.
/// </remarks>
public double time => m_TouchRecord.time;
/// <summary>
/// The touchscreen on which the touch occurred.
/// </summary>
/// <value>Touchscreen associated with the touch.</value>
public Touchscreen screen => finger.screen;
/// <summary>
/// Screen-space position of the touch.
/// </summary>
/// <value>Screen-space position of the touch.</value>
/// <seealso cref="TouchControl.position"/>
public Vector2 screenPosition => state.position;
/// <summary>
/// Screen-space position where the touch started.
/// </summary>
/// <value>Start position of the touch.</value>
/// <seealso cref="TouchControl.startPosition"/>
public Vector2 startScreenPosition => state.startPosition;
/// <summary>
/// Screen-space motion delta of the touch.
/// </summary>
/// <value>Screen-space motion delta of the touch.</value>
/// <remarks>
/// Note that deltas have behaviors attached to them different from most other
/// controls. See <see cref="Pointer.delta"/> for details.
/// </remarks>
/// <seealso cref="TouchControl.delta"/>
public Vector2 delta => state.delta;
/// <summary>
/// Number of times that the touch has been tapped in succession.
/// </summary>
/// <value>Indicates how many taps have been performed one after the other.</value>
/// <remarks>
/// Successive taps have to come within <see cref="InputSettings.multiTapDelayTime"/> for them
/// to increase the tap count. I.e. if a new tap finishes within that time after <see cref="startTime"/>
/// of the previous touch, the tap count is increased by one. If more than <see cref="InputSettings.multiTapDelayTime"/>
/// passes after a tap with no successive tap, the tap count is reset to zero.
/// </remarks>
/// <seealso cref="TouchControl.tapCount"/>
public int tapCount => state.tapCount;
/// <summary>
/// Whether the touch has performed a tap.
/// </summary>
/// <value>Indicates whether the touch has tapped the screen.</value>
/// <remarks>
/// A tap is defined as a touch that begins and ends within <see cref="InputSettings.defaultTapTime"/> and
/// stays within <see cref="InputSettings.tapRadius"/> of its <see cref="startScreenPosition"/>. If this
/// is the case for a touch, this button is set to 1 at the time the touch goes to <see cref="phase"/>
/// <see cref="TouchPhase.Ended"/>.
///
/// Resets to 0 only when another touch is started on the control or when the control is reset.
/// </remarks>
/// <seealso cref="tapCount"/>
/// <seealso cref="InputSettings.defaultTapTime"/>
/// <seealso cref="TouchControl.tap"/>
public bool isTap => state.isTap;
/// <summary>
/// Whether the touch is currently in progress, i.e. has a <see cref="phase"/> of
/// <see cref="TouchPhase.Began"/>, <see cref="TouchPhase.Moved"/>, or <see cref="TouchPhase.Stationary"/>.
/// </summary>
/// <value>Whether the touch is currently ongoing.</value>
public bool isInProgress
{
get
{
switch (phase)
{
case TouchPhase.Began:
case TouchPhase.Moved:
case TouchPhase.Stationary:
return true;
}
return false;
}
}
internal uint updateStepCount => state.updateStepCount;
internal uint uniqueId => extraData.uniqueId;
private unsafe ref TouchState state => ref *(TouchState*)m_TouchRecord.GetUnsafeMemoryPtr();
private unsafe ref ExtraDataPerTouchState extraData =>
ref *(ExtraDataPerTouchState*)m_TouchRecord.GetUnsafeExtraMemoryPtr();
/// <summary>
/// History for this specific touch.
/// </summary>
/// <remarks>
/// Unlike <see cref="Finger.touchHistory"/>, this gives the history of this touch only.
/// </remarks>
public TouchHistory history
{
get
{
if (!valid)
throw new InvalidOperationException("Touch is invalid");
return finger.GetTouchHistory(this);
}
}
/// <summary>
/// All touches that are either on-going as of the current frame or have ended in the current frame.
/// </summary>
/// <remarks>
/// A touch that begins in a frame will always have its phase set to <see cref="TouchPhase.Began"/> even
/// if there was also movement (or even an end/cancellation) for the touch in the same frame.
///
/// A touch that begins and ends in the same frame will have its <see cref="TouchPhase.Began"/> surface
/// in that frame and then another entry with <see cref="TouchPhase.Ended"/> surface in the
/// <em>next</em> frame. This logic implies that there can be more active touches than concurrent touches
/// supported by the hardware/platform.
///
/// A touch that begins and moves in the same frame will have its <see cref="TouchPhase.Began"/> surface
/// in that frame and then another entry with <see cref="TouchPhase.Moved"/> and the screen motion
/// surface in the <em>next</em> frame <em>except</em> if the touch also ended in the frame (in which
/// case <see cref="phase"/> will be <see cref="TouchPhase.Ended"/> instead of <see cref="TouchPhase.Moved"/>).
///
/// Note that the touches reported by this API do <em>not</em> necessarily have to match the contents of
/// <see href="https://docs.unity3d.com/ScriptReference/Input-touches.html">UnityEngine.Input.touches</see>.
/// The reason for this is that the <c>UnityEngine.Input</c> API and the Input System API flush their input
/// queues at different points in time and may thus have a different view on available input. In particular,
/// the Input System event queue is flushed <em>later</em> in the frame than inputs for <c>UnityEngine.Input</c>
/// and may thus have newer inputs available. On Android, for example, touch input is gathered from a separate
/// UI thread and fed into the input system via a "background" event queue that can gather input asynchronously.
/// Due to this setup, touch events that will reach <c>UnityEngine.Input</c> only in the next frame may have
/// already reached the Input System.
///
/// <example>
/// <code>
/// void Awake()
/// {
/// // Enable EnhancedTouch.
/// EnhancedTouchSupport.Enable();
/// }
///
/// void Update()
/// {
/// foreach (var touch in Touch.activeTouches)
/// if (touch.began)
/// Debug.Log($"Touch {touch} started this frame");
/// else if (touch.ended)
/// Debug.Log($"Touch {touch} ended this frame");
/// }
/// </code>
/// </example>
/// </remarks>
/// <exception cref="InvalidOperationException"><c>EnhancedTouch</c> has not been enabled via <see cref="EnhancedTouchSupport.Enable"/>.</exception>
/// <seealso cref="activeFingers"/>
public static ReadOnlyArray<Touch> activeTouches
{
get
{
EnhancedTouchSupport.CheckEnabled();
// We lazily construct the array of active touches.
s_GlobalState.playerState.UpdateActiveTouches();
return new ReadOnlyArray<Touch>(s_GlobalState.playerState.activeTouches, 0, s_GlobalState.playerState.activeTouchCount);
}
}
/// <summary>
/// An array of all possible concurrent touch contacts, i.e. all concurrent touch contacts regardless of whether
/// they are currently active or not.
/// </summary>
/// <remarks>
/// For querying only active fingers, use <see cref="activeFingers"/>.
///
/// The length of this array will always correspond to the maximum number of concurrent touches supported by the system.
/// Note that the actual number of physically supported concurrent touches as determined by the current hardware and
/// operating system may be lower than this number.
/// </remarks>
/// <exception cref="InvalidOperationException"><c>EnhancedTouch</c> has not been enabled via <see cref="EnhancedTouchSupport.Enable"/>.</exception>
/// <seealso cref="activeTouches"/>
/// <seealso cref="activeFingers"/>
public static ReadOnlyArray<Finger> fingers
{
get
{
EnhancedTouchSupport.CheckEnabled();
return new ReadOnlyArray<Finger>(s_GlobalState.playerState.fingers, 0, s_GlobalState.playerState.totalFingerCount);
}
}
/// <summary>
/// Set of currently active fingers, i.e. touch contacts that currently have an active touch (as defined by <see cref="activeTouches"/>).
/// </summary>
/// <exception cref="InvalidOperationException"><c>EnhancedTouch</c> has not been enabled via <see cref="EnhancedTouchSupport.Enable"/>.</exception>
/// <seealso cref="activeTouches"/>
/// <seealso cref="fingers"/>
public static ReadOnlyArray<Finger> activeFingers
{
get
{
EnhancedTouchSupport.CheckEnabled();
// We lazily construct the array of active fingers.
s_GlobalState.playerState.UpdateActiveFingers();
return new ReadOnlyArray<Finger>(s_GlobalState.playerState.activeFingers, 0, s_GlobalState.playerState.activeFingerCount);
}
}
/// <summary>
/// Return the set of <see cref="Touchscreen"/>s on which touch input is monitored.
/// </summary>
/// <exception cref="InvalidOperationException"><c>EnhancedTouch</c> has not been enabled via <see cref="EnhancedTouchSupport.Enable"/>.</exception>
public static IEnumerable<Touchscreen> screens
{
get
{
EnhancedTouchSupport.CheckEnabled();
return s_GlobalState.touchscreens;
}
}
/// <summary>
/// Event that is invoked when a finger touches a <see cref="Touchscreen"/>.
/// </summary>
/// <exception cref="InvalidOperationException"><c>EnhancedTouch</c> has not been enabled via <see cref="EnhancedTouchSupport.Enable"/>.</exception>
/// <seealso cref="onFingerUp"/>
/// <seealso cref="onFingerMove"/>
public static event Action<Finger> onFingerDown
{
add
{
EnhancedTouchSupport.CheckEnabled();
if (value == null)
throw new ArgumentNullException(nameof(value));
s_GlobalState.onFingerDown.AddCallback(value);
}
remove
{
EnhancedTouchSupport.CheckEnabled();
if (value == null)
throw new ArgumentNullException(nameof(value));
s_GlobalState.onFingerDown.RemoveCallback(value);
}
}
/// <summary>
/// Event that is invoked when a finger stops touching a <see cref="Touchscreen"/>.
/// </summary>
/// <exception cref="InvalidOperationException"><c>EnhancedTouch</c> has not been enabled via <see cref="EnhancedTouchSupport.Enable"/>.</exception>
/// <seealso cref="onFingerDown"/>
/// <seealso cref="onFingerMove"/>
public static event Action<Finger> onFingerUp
{
add
{
EnhancedTouchSupport.CheckEnabled();
if (value == null)
throw new ArgumentNullException(nameof(value));
s_GlobalState.onFingerUp.AddCallback(value);
}
remove
{
EnhancedTouchSupport.CheckEnabled();
if (value == null)
throw new ArgumentNullException(nameof(value));
s_GlobalState.onFingerUp.RemoveCallback(value);
}
}
/// <summary>
/// Event that is invoked when a finger that is in contact with a <see cref="Touchscreen"/> moves
/// on the screen.
/// </summary>
/// <exception cref="InvalidOperationException"><c>EnhancedTouch</c> has not been enabled via <see cref="EnhancedTouchSupport.Enable"/>.</exception>
/// <seealso cref="onFingerUp"/>
/// <seealso cref="onFingerDown"/>
public static event Action<Finger> onFingerMove
{
add
{
EnhancedTouchSupport.CheckEnabled();
if (value == null)
throw new ArgumentNullException(nameof(value));
s_GlobalState.onFingerMove.AddCallback(value);
}
remove
{
EnhancedTouchSupport.CheckEnabled();
if (value == null)
throw new ArgumentNullException(nameof(value));
s_GlobalState.onFingerMove.RemoveCallback(value);
}
}
/*
public static Action<Finger> onFingerTap
{
get { throw new NotImplementedException(); }
set { throw new NotImplementedException(); }
}
*/
/// <summary>
/// The amount of history kept for each single touch.
/// </summary>
/// <remarks>
/// By default, this is zero meaning that no history information is kept for
/// touches. Setting this to <c>Int32.maxValue</c> will cause all history from
/// the beginning to the end of a touch being kept.
/// </remarks>
public static int maxHistoryLengthPerFinger
{
get => s_GlobalState.historyLengthPerFinger;
////TODO
/*set { throw new NotImplementedException(); }*/
}
internal Touch(Finger finger, InputStateHistory<TouchState>.Record touchRecord)
{
m_Finger = finger;
m_TouchRecord = touchRecord;
}
public override string ToString()
{
if (!valid)
return "<None>";
return $"{{id={touchId} finger={finger.index} phase={phase} position={screenPosition} delta={delta} time={time}}}";
}
public bool Equals(Touch other)
{
return Equals(m_Finger, other.m_Finger) && m_TouchRecord.Equals(other.m_TouchRecord);
}
public override bool Equals(object obj)
{
return obj is Touch other && Equals(other);
}
public override int GetHashCode()
{
unchecked
{
return ((m_Finger != null ? m_Finger.GetHashCode() : 0) * 397) ^ m_TouchRecord.GetHashCode();
}
}
internal static void AddTouchscreen(Touchscreen screen)
{
Debug.Assert(!s_GlobalState.touchscreens.ContainsReference(screen), "Already added touchscreen");
s_GlobalState.touchscreens.AppendWithCapacity(screen, capacityIncrement: 5);
// Add finger tracking to states.
s_GlobalState.playerState.AddFingers(screen);
#if UNITY_EDITOR
s_GlobalState.editorState.AddFingers(screen);
#endif
}
internal static void RemoveTouchscreen(Touchscreen screen)
{
Debug.Assert(s_GlobalState.touchscreens.ContainsReference(screen), "Did not add touchscreen");
// Remove from list.
var index = s_GlobalState.touchscreens.IndexOfReference(screen);
s_GlobalState.touchscreens.RemoveAtWithCapacity(index);
// Remove fingers from states.
s_GlobalState.playerState.RemoveFingers(screen);
#if UNITY_EDITOR
s_GlobalState.editorState.RemoveFingers(screen);
#endif
}
////TODO: only have this hooked when we actually need it
internal static void BeginUpdate()
{
#if UNITY_EDITOR
if ((InputState.currentUpdateType == InputUpdateType.Editor && s_GlobalState.playerState.updateMask != InputUpdateType.Editor) ||
(InputState.currentUpdateType != InputUpdateType.Editor && s_GlobalState.playerState.updateMask == InputUpdateType.Editor))
{
// Either swap in editor state and retain currently active player state in s_EditorState
// or swap player state back in.
MemoryHelpers.Swap(ref s_GlobalState.playerState, ref s_GlobalState.editorState);
}
#endif
// If we have any touches in activeTouches that are ended or canceled,
// we need to clear them in the next frame.
if (s_GlobalState.playerState.haveActiveTouchesNeedingRefreshNextUpdate)
s_GlobalState.playerState.haveBuiltActiveTouches = false;
}
private readonly Finger m_Finger;
internal InputStateHistory<TouchState>.Record m_TouchRecord;
/// <summary>
/// Holds global (static) touch state.
/// </summary>
internal struct GlobalState
{
internal InlinedArray<Touchscreen> touchscreens;
internal int historyLengthPerFinger;
internal CallbackArray<Action<Finger>> onFingerDown;
internal CallbackArray<Action<Finger>> onFingerMove;
internal CallbackArray<Action<Finger>> onFingerUp;
internal FingerAndTouchState playerState;
#if UNITY_EDITOR
internal FingerAndTouchState editorState;
#endif
}
private static GlobalState CreateGlobalState()
{ // Convenient method since parameterized construction is default
return new GlobalState { historyLengthPerFinger = 64 };
}
internal static GlobalState s_GlobalState = CreateGlobalState();
internal static ISavedState SaveAndResetState()
{
// Save current state
var savedState = new SavedStructState<GlobalState>(
ref s_GlobalState,
(ref GlobalState state) => s_GlobalState = state,
() => { /* currently nothing to dispose */ });
// Reset global state
s_GlobalState = CreateGlobalState();
return savedState;
}
// In scenarios where we have to support multiple different types of input updates (e.g. in editor or in
// player when both dynamic and fixed input updates are enabled), we need more than one copy of touch state.
// We encapsulate the state in this struct so that we can easily swap it.
//
// NOTE: Finger instances are per state. This means that you will actually see different Finger instances for
// the same finger in two different update types.
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA1001:TypesThatOwnDisposableFieldsShouldBeDisposable",
Justification = "Managed internally")]
internal struct FingerAndTouchState
{
public InputUpdateType updateMask;
public Finger[] fingers;
public Finger[] activeFingers;
public Touch[] activeTouches;
public int activeFingerCount;
public int activeTouchCount;
public int totalFingerCount;
public uint lastId;
public bool haveBuiltActiveTouches;
public bool haveActiveTouchesNeedingRefreshNextUpdate;
// `activeTouches` adds yet another view of input state that is different from "normal" recorded
// state history. In this view, touches become stationary in the next update and deltas reset
// between updates. We solve this by storing state separately for active touches. We *only* do
// so when `activeTouches` is actually queried meaning that `activeTouches` has no overhead if
// not used.
public InputStateHistory<TouchState> activeTouchState;
public void AddFingers(Touchscreen screen)
{
var touchCount = screen.touches.Count;
ArrayHelpers.EnsureCapacity(ref fingers, totalFingerCount, touchCount);
for (var i = 0; i < touchCount; ++i)
{
var finger = new Finger(screen, i, updateMask);
ArrayHelpers.AppendWithCapacity(ref fingers, ref totalFingerCount, finger);
}
}
public void RemoveFingers(Touchscreen screen)
{
var touchCount = screen.touches.Count;
for (var i = 0; i < fingers.Length; ++i)
{
if (fingers[i].screen != screen)
continue;
// Release unmanaged memory.
for (var n = 0; n < touchCount; ++n)
fingers[i + n].m_StateHistory.Dispose();
////REVIEW: leave Fingers in place and reuse the instances?
ArrayHelpers.EraseSliceWithCapacity(ref fingers, ref totalFingerCount, i, touchCount);
break;
}
// Force rebuilding of active touches.
haveBuiltActiveTouches = false;
}
public void Destroy()
{
for (var i = 0; i < totalFingerCount; ++i)
fingers[i].m_StateHistory.Dispose();
activeTouchState?.Dispose();
activeTouchState = null;
}
public void UpdateActiveFingers()
{
////TODO: do this only once per update per activeFingers getter
activeFingerCount = 0;
for (var i = 0; i < totalFingerCount; ++i)
{
var finger = fingers[i];
var lastTouch = finger.currentTouch;
if (lastTouch.valid)
ArrayHelpers.AppendWithCapacity(ref activeFingers, ref activeFingerCount, finger);
}
}
public unsafe void UpdateActiveTouches()
{
if (haveBuiltActiveTouches)
return;
// Clear activeTouches state.
if (activeTouchState == null)
{
activeTouchState = new InputStateHistory<TouchState>
{
extraMemoryPerRecord = UnsafeUtility.SizeOf<ExtraDataPerTouchState>()
};
}
else
{
activeTouchState.Clear();
activeTouchState.m_ControlCount = 0;
activeTouchState.m_Controls.Clear();
}
activeTouchCount = 0;
haveActiveTouchesNeedingRefreshNextUpdate = false;
var currentUpdateStepCount = InputUpdate.s_UpdateStepCount;
////OPTIMIZE: Handle touchscreens that have no activity more efficiently
////FIXME: This is sensitive to history size; we probably need to ensure that the Begans and Endeds/Canceleds of touches are always available to us
//// (instead of rebuild activeTouches from scratch each time, may be more useful to update it)
// Go through fingers and for each one, get the touches that were active this update.
for (var i = 0; i < totalFingerCount; ++i)
{
ref var finger = ref fingers[i];
// NOTE: Many of the operations here are inlined in order to not perform the same
// checks/computations repeatedly.
var history = finger.m_StateHistory;
var touchRecordCount = history.Count;
if (touchRecordCount == 0)
continue;
// We're walking newest-first through the touch history but want the resulting list of
// active touches to be oldest first (so that a record for an ended touch comes before
// a record of a new touch started on the same finger). To achieve that, we insert
// new touch entries for any finger always at the same index (i.e. we prepend rather
// than append).
var insertAt = activeTouchCount;
// Go back in time through the touch records on the finger and collect any touch
// active in the current frame. Note that this may yield *multiple* touches for the
// finger as there may be touches that have ended in the frame while in the same
// frame, a new touch was started.
var currentTouchId = 0;
var currentTouchState = default(TouchState*);
var touchRecordIndex = history.UserIndexToRecordIndex(touchRecordCount - 1); // Start with last record.
var touchRecordHeader = history.GetRecordUnchecked(touchRecordIndex);
var touchRecordSize = history.bytesPerRecord;
var extraMemoryOffset = touchRecordSize - history.extraMemoryPerRecord;
for (var n = 0; n < touchRecordCount; ++n)
{
if (n != 0)
{
--touchRecordIndex;
if (touchRecordIndex < 0)
{
// We're wrapping around so buffer must be full. Go to last record in buffer.
//touchRecordIndex = history.historyDepth - history.m_HeadIndex - 1;
touchRecordIndex = history.historyDepth - 1;
touchRecordHeader = history.GetRecordUnchecked(touchRecordIndex);
}
else
{
touchRecordHeader = (InputStateHistory.RecordHeader*)((byte*)touchRecordHeader - touchRecordSize);
}
}
// Skip if part of an ongoing touch we've already recorded.
var touchState = (TouchState*)touchRecordHeader->statePtrWithoutControlIndex; // History is tied to a single TouchControl.
var wasUpdatedThisFrame = touchState->updateStepCount == currentUpdateStepCount;
if (touchState->touchId == currentTouchId && !touchState->phase.IsEndedOrCanceled())
{
// If this is the Began record for the touch and that one happened in
// the current frame, we force the touch phase to Began.
if (wasUpdatedThisFrame && touchState->phase == TouchPhase.Began)
{
Debug.Assert(currentTouchState != null, "Must have current touch record at this point");
currentTouchState->phase = TouchPhase.Began;
currentTouchState->position = touchState->position;
currentTouchState->delta = default;
haveActiveTouchesNeedingRefreshNextUpdate = true;
}
// Need to continue here as there may still be Ended touches that need to
// be taken into account (as in, there may actually be multiple active touches
// for the same finger due to how the polling API works).
continue;
}
// If the touch is older than the current frame and it's a touch that has
// ended, we don't need to look further back into the history as anything
// coming before that will be equally outdated.
if (touchState->phase.IsEndedOrCanceled())
{
// An exception are touches that both began *and* ended in the previous frame.
// For these, we surface the Began in the previous update and the Ended in the
// current frame.
if (!(touchState->beganInSameFrame && touchState->updateStepCount == currentUpdateStepCount - 1) &&
!wasUpdatedThisFrame)
break;
}
// Make a copy of the touch so that we can modify data like deltas and phase.
// NOTE: Again, not using AddRecord() for speed.
// NOTE: Unlike `history`, `activeTouchState` stores control indices as each active touch
// will correspond to a different TouchControl.
var touchExtraState = (ExtraDataPerTouchState*)((byte*)touchRecordHeader + extraMemoryOffset);
var newRecordHeader = activeTouchState.AllocateRecord(out var newRecordIndex);
var newRecordState = (TouchState*)newRecordHeader->statePtrWithControlIndex;
var newRecordExtraState = (ExtraDataPerTouchState*)((byte*)newRecordHeader + activeTouchState.bytesPerRecord - UnsafeUtility.SizeOf<ExtraDataPerTouchState>());
newRecordHeader->time = touchRecordHeader->time;
newRecordHeader->controlIndex = ArrayHelpers.AppendWithCapacity(ref activeTouchState.m_Controls,
ref activeTouchState.m_ControlCount, finger.m_StateHistory.controls[0]);
UnsafeUtility.MemCpy(newRecordState, touchState, UnsafeUtility.SizeOf<TouchState>());
UnsafeUtility.MemCpy(newRecordExtraState, touchExtraState, UnsafeUtility.SizeOf<ExtraDataPerTouchState>());
// If the touch hasn't moved this frame, mark it stationary.
// EXCEPT: If we are looked at a Moved touch that also began in the same frame and that
// frame is the one immediately preceding us. In that case, we want to surface the Moved
// as if it happened this frame.
var phase = touchState->phase;
if ((phase == TouchPhase.Moved || phase == TouchPhase.Began) &&
!wasUpdatedThisFrame && !(phase == TouchPhase.Moved && touchState->beganInSameFrame && touchState->updateStepCount == currentUpdateStepCount - 1))
{
newRecordState->phase = TouchPhase.Stationary;
newRecordState->delta = default;
}
// If the touch wasn't updated this frame, zero out its delta.
else if (!wasUpdatedThisFrame && !touchState->beganInSameFrame)
{
newRecordState->delta = default;
}
else
{
// We want accumulated deltas only on activeTouches.
newRecordState->delta = newRecordExtraState->accumulatedDelta;
}
var newRecord = new InputStateHistory<TouchState>.Record(activeTouchState, newRecordIndex, newRecordHeader);
var newTouch = new Touch(finger, newRecord);
ArrayHelpers.InsertAtWithCapacity(ref activeTouches, ref activeTouchCount, insertAt, newTouch);
currentTouchId = touchState->touchId;
currentTouchState = newRecordState;
// For anything but stationary touches on the activeTouches list, we need a subsequent
// update in the next frame.
if (newTouch.phase != TouchPhase.Stationary)
haveActiveTouchesNeedingRefreshNextUpdate = true;
}
}
haveBuiltActiveTouches = true;
}
}
internal struct ExtraDataPerTouchState
{
public Vector2 accumulatedDelta;
public uint uniqueId; // Unique ID for touch *record* (i.e. multiple TouchStates having the same touchId will still each have a unique ID).
////TODO
//public uint tapCount;
}
}
}