1052 lines
48 KiB
C#
1052 lines
48 KiB
C#
|
using System;
|
||
|
|
using System.Runtime.InteropServices;
|
||
|
|
using Unity.Collections;
|
||
|
|
using Unity.Collections.LowLevel.Unsafe;
|
||
|
|
using UnityEngine.InputSystem.Controls;
|
||
|
|
using UnityEngine.InputSystem.Layouts;
|
||
|
|
using UnityEngine.InputSystem.LowLevel;
|
||
|
|
using UnityEngine.InputSystem.Utilities;
|
||
|
|
using UnityEngine.Profiling;
|
||
|
|
|
||
|
|
////TODO: property that tells whether a Touchscreen is multi-touch capable
|
||
|
|
|
||
|
|
////TODO: property that tells whether a Touchscreen supports pressure
|
||
|
|
|
||
|
|
////TODO: add support for screen orientation
|
||
|
|
|
||
|
|
////TODO: touch is hardwired to certain memory layouts ATM; either allow flexibility or make sure the layouts cannot be changed
|
||
|
|
|
||
|
|
////TODO: startTimes are baked *external* times; reset touch when coming out of play mode
|
||
|
|
|
||
|
|
////TODO: detect and diagnose touchId=0 events
|
||
|
|
|
||
|
|
////REVIEW: where should we put handset vibration support? should that sit on the touchscreen class? be its own separate device?
|
||
|
|
|
||
|
|
////REVIEW: Given that Touchscreen is no use for polling, should we remove Touchscreen.current?
|
||
|
|
|
||
|
|
////REVIEW: Should Touchscreen reset individual TouchControls to default(TouchState) after a touch has ended? This would allow
|
||
|
|
//// binding to a TouchControl as a whole and the action would correctly cancel if the touch ends
|
||
|
|
|
||
|
|
namespace UnityEngine.InputSystem.LowLevel
|
||
|
|
{
|
||
|
|
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1028:EnumStorageShouldBeInt32", Justification = "byte to correspond to TouchState layout.")]
|
||
|
|
[Flags]
|
||
|
|
internal enum TouchFlags : byte
|
||
|
|
{
|
||
|
|
IndirectTouch = 1 << 0,
|
||
|
|
|
||
|
|
// NOTE: Leaving the first 3 bits for native.
|
||
|
|
|
||
|
|
PrimaryTouch = 1 << 3,
|
||
|
|
TapPress = 1 << 4,
|
||
|
|
TapRelease = 1 << 5,
|
||
|
|
|
||
|
|
// Indicates that the touch that established this primary touch has ended but that when
|
||
|
|
// it did, there were still other touches going on. We end the primary touch when the
|
||
|
|
// last touch leaves the screen.
|
||
|
|
OrphanedPrimaryTouch = 1 << 6,
|
||
|
|
|
||
|
|
// This is only used by EnhancedTouch to mark touch records that have begun in the same
|
||
|
|
// frame as the current touch record.
|
||
|
|
BeganInSameFrame = 1 << 7,
|
||
|
|
}
|
||
|
|
|
||
|
|
////REVIEW: add timestamp directly to touch?
|
||
|
|
/// <summary>
|
||
|
|
/// State layout for a single touch.
|
||
|
|
/// </summary>
|
||
|
|
/// <remarks>
|
||
|
|
/// This is the low-level memory representation of a single touch, i.e the
|
||
|
|
/// way touches are internally transmitted and stored in the system. To update
|
||
|
|
/// touches on a <see cref="Touchscreen"/>, <see cref="StateEvent"/>s containing
|
||
|
|
/// TouchStates are sent to the screen.
|
||
|
|
/// </remarks>
|
||
|
|
/// <seealso cref="TouchControl"/>
|
||
|
|
/// <seealso cref="Touchscreen"/>
|
||
|
|
// IMPORTANT: Must match TouchInputState in native code.
|
||
|
|
[StructLayout(LayoutKind.Explicit, Size = kSizeInBytes)]
|
||
|
|
public struct TouchState : IInputStateTypeInfo
|
||
|
|
{
|
||
|
|
internal const int kSizeInBytes = 56;
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// Memory format tag for TouchState.
|
||
|
|
/// </summary>
|
||
|
|
/// <value>Returns "TOUC".</value>
|
||
|
|
/// <seealso cref="InputStateBlock.format"/>
|
||
|
|
public static FourCC Format => new FourCC('T', 'O', 'U', 'C');
|
||
|
|
|
||
|
|
////REVIEW: this should really be a uint
|
||
|
|
/// <summary>
|
||
|
|
/// Numeric ID of the touch.
|
||
|
|
/// </summary>
|
||
|
|
/// <value>Numeric ID of the touch.</value>
|
||
|
|
/// <remarks>
|
||
|
|
/// While a touch is ongoing, it must have a non-zero ID different from
|
||
|
|
/// all other ongoing touches. Starting with <see cref="TouchPhase.Began"/>
|
||
|
|
/// and ending with <see cref="TouchPhase.Ended"/> or <see cref="TouchPhase.Canceled"/>,
|
||
|
|
/// a touch is identified by its ID, i.e. a TouchState with the same ID
|
||
|
|
/// belongs to the same touch.
|
||
|
|
///
|
||
|
|
/// After a touch has ended or been canceled, an ID can be reused.
|
||
|
|
/// </remarks>
|
||
|
|
/// <seealso cref="TouchControl.touchId"/>
|
||
|
|
[InputControl(displayName = "Touch ID", layout = "Integer", synthetic = true, dontReset = true)]
|
||
|
|
[FieldOffset(0)]
|
||
|
|
public int touchId;
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// Screen-space position of the touch in pixels.
|
||
|
|
/// </summary>
|
||
|
|
/// <value>Screen-space position of the touch.</value>
|
||
|
|
/// <seealso cref="TouchControl.position"/>
|
||
|
|
[InputControl(displayName = "Position", dontReset = true)]
|
||
|
|
[FieldOffset(4)]
|
||
|
|
public Vector2 position;
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// Screen-space motion delta of the touch in pixels.
|
||
|
|
/// </summary>
|
||
|
|
/// <value>Screen-space movement delta.</value>
|
||
|
|
/// <seealso cref="TouchControl.delta"/>
|
||
|
|
[InputControl(displayName = "Delta", layout = "Delta")]
|
||
|
|
[FieldOffset(12)]
|
||
|
|
public Vector2 delta;
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// Pressure-level of the touch against the touchscreen.
|
||
|
|
/// </summary>
|
||
|
|
/// <value>Pressure of touch.</value>
|
||
|
|
/// <remarks>
|
||
|
|
/// The core range for this value is [0..1] with 1 indicating maximum pressure. Note, however,
|
||
|
|
/// that the actual value may go beyond 1 in practice. This is because the system will usually
|
||
|
|
/// define "maximum pressure" to be less than the physical maximum limit the hardware is capable
|
||
|
|
/// of reporting so that to achieve maximum pressure, one does not need to press as hard as
|
||
|
|
/// possible.
|
||
|
|
/// </remarks>
|
||
|
|
/// <seealso cref="TouchControl.pressure"/>
|
||
|
|
[InputControl(displayName = "Pressure", layout = "Axis")]
|
||
|
|
[FieldOffset(20)]
|
||
|
|
public float pressure;
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// Radius of the touch print on the surface.
|
||
|
|
/// </summary>
|
||
|
|
/// <value>Touch extents horizontally and vertically.</value>
|
||
|
|
/// <remarks>
|
||
|
|
/// The touch radius is given in screen-space pixel coordinates along X and Y centered in the middle
|
||
|
|
/// of the touch. Note that not all screens and systems support radius detection on touches so this
|
||
|
|
/// value may be at <c>default</c> for an otherwise perfectly valid touch.
|
||
|
|
/// </remarks>
|
||
|
|
/// <seealso cref="TouchControl.radius"/>
|
||
|
|
[InputControl(displayName = "Radius")]
|
||
|
|
[FieldOffset(24)]
|
||
|
|
public Vector2 radius;
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// <see cref="TouchPhase"/> value of the touch.
|
||
|
|
/// </summary>
|
||
|
|
/// <value>Current <see cref="TouchPhase"/>.</value>
|
||
|
|
/// <seealso cref="phase"/>
|
||
|
|
[InputControl(name = "phase", displayName = "Touch Phase", layout = "TouchPhase", synthetic = true)]
|
||
|
|
[InputControl(name = "press", displayName = "Touch Contact?", layout = "TouchPress", useStateFrom = "phase")]
|
||
|
|
[FieldOffset(32)]
|
||
|
|
public byte phaseId;
|
||
|
|
|
||
|
|
[InputControl(name = "tapCount", displayName = "Tap Count", layout = "Integer")]
|
||
|
|
[FieldOffset(33)]
|
||
|
|
public byte tapCount;
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// The index of the display that was touched.
|
||
|
|
/// </summary>
|
||
|
|
[InputControl(name = "displayIndex", displayName = "Display Index", layout = "Integer")]
|
||
|
|
[FieldOffset(34)]
|
||
|
|
public byte displayIndex;
|
||
|
|
|
||
|
|
[InputControl(name = "indirectTouch", displayName = "Indirect Touch?", layout = "Button", bit = 0, synthetic = true)]
|
||
|
|
[InputControl(name = "tap", displayName = "Tap", layout = "Button", bit = 4)]
|
||
|
|
[FieldOffset(35)]
|
||
|
|
public byte flags;
|
||
|
|
|
||
|
|
// Need four bytes of alignment here for the startTime double. Using that for storing updateStepCounts.
|
||
|
|
// They aren't needed directly by Touchscreen but are used by EnhancedTouch and since we have the four
|
||
|
|
// bytes, may just as well use them instead of wasting them on padding.
|
||
|
|
[FieldOffset(36)]
|
||
|
|
internal uint updateStepCount;
|
||
|
|
|
||
|
|
// NOTE: The following data is NOT sent by native but rather data we add on the managed side to each touch.
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// Time that the touch was started. Relative to <c>Time.realTimeSinceStartup</c>.
|
||
|
|
/// </summary>
|
||
|
|
/// <value>Time that the touch was started.</value>
|
||
|
|
/// <remarks>
|
||
|
|
/// This is set automatically by <see cref="Touchscreen"/> and does not need to be provided
|
||
|
|
/// by events sent to the touchscreen.
|
||
|
|
/// </remarks>
|
||
|
|
/// <seealso cref="InputEvent.time"/>
|
||
|
|
/// <seealso cref="TouchControl.startTime"/>
|
||
|
|
[InputControl(displayName = "Start Time", layout = "Double", synthetic = true)]
|
||
|
|
[FieldOffset(40)]
|
||
|
|
public double startTime; // In *external* time, i.e. currentTimeOffsetToRealtimeSinceStartup baked in.
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// The position where the touch started.
|
||
|
|
/// </summary>
|
||
|
|
/// <value>Screen-space start position of the touch.</value>
|
||
|
|
/// <remarks>
|
||
|
|
/// This is set automatically by <see cref="Touchscreen"/> and does not need to be provided
|
||
|
|
/// by events sent to the touchscreen.
|
||
|
|
/// </remarks>
|
||
|
|
/// <seealso cref="TouchControl.startPosition"/>
|
||
|
|
[InputControl(displayName = "Start Position", synthetic = true)]
|
||
|
|
[FieldOffset(48)]
|
||
|
|
public Vector2 startPosition;
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// Get or set the phase of the touch.
|
||
|
|
/// </summary>
|
||
|
|
/// <value>Phase of the touch.</value>
|
||
|
|
/// <seealso cref="TouchControl.phase"/>
|
||
|
|
public TouchPhase phase
|
||
|
|
{
|
||
|
|
get => (TouchPhase)phaseId;
|
||
|
|
set => phaseId = (byte)value;
|
||
|
|
}
|
||
|
|
|
||
|
|
public bool isNoneEndedOrCanceled => phase == TouchPhase.None || phase == TouchPhase.Ended ||
|
||
|
|
phase == TouchPhase.Canceled;
|
||
|
|
public bool isInProgress => phase == TouchPhase.Began || phase == TouchPhase.Moved ||
|
||
|
|
phase == TouchPhase.Stationary;
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// Whether, after not having any touch contacts, this is part of the first touch contact that started.
|
||
|
|
/// </summary>
|
||
|
|
/// <remarks>
|
||
|
|
/// This flag will be set internally by <see cref="Touchscreen"/>. Generally, it is
|
||
|
|
/// not necessary to set this bit manually when feeding data to Touchscreens.
|
||
|
|
/// </remarks>
|
||
|
|
public bool isPrimaryTouch
|
||
|
|
{
|
||
|
|
get => (flags & (byte)TouchFlags.PrimaryTouch) != 0;
|
||
|
|
set
|
||
|
|
{
|
||
|
|
if (value)
|
||
|
|
flags |= (byte)TouchFlags.PrimaryTouch;
|
||
|
|
else
|
||
|
|
flags &= (byte)~TouchFlags.PrimaryTouch;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
internal bool isOrphanedPrimaryTouch
|
||
|
|
{
|
||
|
|
get => (flags & (byte)TouchFlags.OrphanedPrimaryTouch) != 0;
|
||
|
|
set
|
||
|
|
{
|
||
|
|
if (value)
|
||
|
|
flags |= (byte)TouchFlags.OrphanedPrimaryTouch;
|
||
|
|
else
|
||
|
|
flags &= (byte)~TouchFlags.OrphanedPrimaryTouch;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public bool isIndirectTouch
|
||
|
|
{
|
||
|
|
get => (flags & (byte)TouchFlags.IndirectTouch) != 0;
|
||
|
|
set
|
||
|
|
{
|
||
|
|
if (value)
|
||
|
|
flags |= (byte)TouchFlags.IndirectTouch;
|
||
|
|
else
|
||
|
|
flags &= (byte)~TouchFlags.IndirectTouch;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public bool isTap
|
||
|
|
{
|
||
|
|
get => isTapPress;
|
||
|
|
set => isTapPress = value;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal bool isTapPress
|
||
|
|
{
|
||
|
|
get => (flags & (byte)TouchFlags.TapPress) != 0;
|
||
|
|
set
|
||
|
|
{
|
||
|
|
if (value)
|
||
|
|
flags |= (byte)TouchFlags.TapPress;
|
||
|
|
else
|
||
|
|
flags &= (byte)~TouchFlags.TapPress;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
internal bool isTapRelease
|
||
|
|
{
|
||
|
|
get => (flags & (byte)TouchFlags.TapRelease) != 0;
|
||
|
|
set
|
||
|
|
{
|
||
|
|
if (value)
|
||
|
|
flags |= (byte)TouchFlags.TapRelease;
|
||
|
|
else
|
||
|
|
flags &= (byte)~TouchFlags.TapRelease;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
internal bool beganInSameFrame
|
||
|
|
{
|
||
|
|
get => (flags & (byte)TouchFlags.BeganInSameFrame) != 0;
|
||
|
|
set
|
||
|
|
{
|
||
|
|
if (value)
|
||
|
|
flags |= (byte)TouchFlags.BeganInSameFrame;
|
||
|
|
else
|
||
|
|
flags &= (byte)~TouchFlags.BeganInSameFrame;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <inheritdoc/>
|
||
|
|
public FourCC format => Format;
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// Return a string representation of the state useful for debugging.
|
||
|
|
/// </summary>
|
||
|
|
/// <returns>A string representation of the touch state.</returns>
|
||
|
|
public override string ToString()
|
||
|
|
{
|
||
|
|
return $"{{ id={touchId} phase={phase} pos={position} delta={delta} pressure={pressure} radius={radius} primary={isPrimaryTouch} }}";
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// Default state layout for touch devices.
|
||
|
|
/// </summary>
|
||
|
|
/// <remarks>
|
||
|
|
/// Combines multiple pointers each corresponding to a single contact.
|
||
|
|
///
|
||
|
|
/// Normally, TODO (sending state events)
|
||
|
|
///
|
||
|
|
/// All touches combine to quite a bit of state; ideally send delta events that update
|
||
|
|
/// only specific fingers.
|
||
|
|
///
|
||
|
|
/// This is NOT used by native. Instead, the native runtime always sends individual touches (<see cref="TouchState"/>)
|
||
|
|
/// and leaves state management for a touchscreen as a whole to the managed part of the system.
|
||
|
|
/// </remarks>
|
||
|
|
[StructLayout(LayoutKind.Explicit, Size = MaxTouches * TouchState.kSizeInBytes)]
|
||
|
|
internal unsafe struct TouchscreenState : IInputStateTypeInfo
|
||
|
|
{
|
||
|
|
/// <summary>
|
||
|
|
/// Memory format tag for TouchscreenState.
|
||
|
|
/// </summary>
|
||
|
|
/// <value>Returns "TSCR".</value>
|
||
|
|
/// <seealso cref="InputStateBlock.format"/>
|
||
|
|
public static FourCC Format => new FourCC('T', 'S', 'C', 'R');
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// Maximum number of touches that can be tracked at the same time.
|
||
|
|
/// </summary>
|
||
|
|
/// <value>Maximum number of concurrent touches.</value>
|
||
|
|
public const int MaxTouches = 10;
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// Data for the touch that is deemed the "primary" touch at the moment.
|
||
|
|
/// </summary>
|
||
|
|
/// <remarks>
|
||
|
|
/// This touch duplicates touch data from whichever touch is deemed the primary touch at the moment.
|
||
|
|
/// When going from no fingers down to any finger down, the first finger to touch the screen is
|
||
|
|
/// deemed the "primary touch". It stays the primary touch until released. At that point, if any other
|
||
|
|
/// finger is still down, the next finger in <see cref="touchData"/> is
|
||
|
|
///
|
||
|
|
/// Having this touch be its own separate state and own separate control allows actions to track the
|
||
|
|
/// state of the primary touch even if the touch moves from one finger to another in <see cref="touchData"/>.
|
||
|
|
/// </remarks>
|
||
|
|
[InputControl(name = "primaryTouch", displayName = "Primary Touch", layout = "Touch", synthetic = true)]
|
||
|
|
[InputControl(name = "primaryTouch/tap", usage = "PrimaryAction")]
|
||
|
|
|
||
|
|
// Add controls compatible with what Pointer expects and redirect their
|
||
|
|
// state to the state of touch0 so that this essentially becomes our
|
||
|
|
// pointer control.
|
||
|
|
// NOTE: Some controls from Pointer don't make sense for touch and we "park"
|
||
|
|
// them by assigning them invalid offsets (thus having automatic state
|
||
|
|
// layout put them at the end of our fixed state).
|
||
|
|
[InputControl(name = "position", useStateFrom = "primaryTouch/position")]
|
||
|
|
[InputControl(name = "delta", useStateFrom = "primaryTouch/delta", layout = "Delta")]
|
||
|
|
[InputControl(name = "pressure", useStateFrom = "primaryTouch/pressure")]
|
||
|
|
[InputControl(name = "radius", useStateFrom = "primaryTouch/radius")]
|
||
|
|
[InputControl(name = "press", useStateFrom = "primaryTouch/phase", layout = "TouchPress", synthetic = true, usages = new string[0])]
|
||
|
|
[FieldOffset(0)]
|
||
|
|
public fixed byte primaryTouchData[TouchState.kSizeInBytes];
|
||
|
|
|
||
|
|
internal const int kTouchDataOffset = TouchState.kSizeInBytes;
|
||
|
|
|
||
|
|
[InputControl(layout = "Touch", name = "touch", displayName = "Touch", arraySize = MaxTouches)]
|
||
|
|
[FieldOffset(kTouchDataOffset)]
|
||
|
|
public fixed byte touchData[MaxTouches * TouchState.kSizeInBytes];
|
||
|
|
|
||
|
|
public TouchState* primaryTouch
|
||
|
|
{
|
||
|
|
get
|
||
|
|
{
|
||
|
|
fixed(byte* ptr = primaryTouchData)
|
||
|
|
return (TouchState*)ptr;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public TouchState* touches
|
||
|
|
{
|
||
|
|
get
|
||
|
|
{
|
||
|
|
fixed(byte* ptr = touchData)
|
||
|
|
return (TouchState*)ptr;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public FourCC format => Format;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
namespace UnityEngine.InputSystem
|
||
|
|
{
|
||
|
|
/// <summary>
|
||
|
|
/// Indicates where in its lifecycle a given touch is.
|
||
|
|
/// </summary>
|
||
|
|
public enum TouchPhase
|
||
|
|
{
|
||
|
|
////REVIEW: Why have a separate None instead of just making this equivalent to either Ended or Canceled?
|
||
|
|
/// <summary>
|
||
|
|
/// No activity has been registered on the touch yet.
|
||
|
|
/// </summary>
|
||
|
|
/// <remarks>
|
||
|
|
/// A given touch state will generally not go back to None once there has been input for it. Meaning that
|
||
|
|
/// it generally indicates a default-initialized touch record.
|
||
|
|
/// </remarks>
|
||
|
|
None,
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// A touch has just begun, i.e. a finger has touched the screen.. Only the first touch input in any given touch will have this phase.
|
||
|
|
/// </summary>
|
||
|
|
Began,
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// An ongoing touch has changed position.
|
||
|
|
/// </summary>
|
||
|
|
Moved,
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// An ongoing touch has just ended, i.e. the respective finger has been lifted off of the screen. Only the last touch input in a
|
||
|
|
/// given touch will have this phase.
|
||
|
|
/// </summary>
|
||
|
|
Ended,
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// An ongoing touch has been cancelled, i.e. ended in a way other than through user interaction. This happens, for example, if
|
||
|
|
/// focus is moved away from the application while the touch is ongoing.
|
||
|
|
/// </summary>
|
||
|
|
Canceled,
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// An ongoing touch has not been moved (not received any input) in a frame.
|
||
|
|
/// </summary>
|
||
|
|
/// <remarks>
|
||
|
|
/// This phase is not used by <see cref="Touchscreen"/>. This means that <see cref="TouchControl"/> will not generally
|
||
|
|
/// return this value for <see cref="TouchControl.phase"/>. It is, however, used by <see cref="UnityEngine.InputSystem.EnhancedTouch.Touch"/>.
|
||
|
|
/// </remarks>
|
||
|
|
Stationary,
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// A multi-touch surface.
|
||
|
|
/// </summary>
|
||
|
|
/// <remarks>
|
||
|
|
/// Touchscreen is somewhat different from most other device implementations in that it does not usually
|
||
|
|
/// consume input in the form of a full device snapshot but rather consumes input sent to it in the form
|
||
|
|
/// of events containing a <see cref="TouchState"/> each. This is unusual as <see cref="TouchState"/>
|
||
|
|
/// uses a memory format different from <see cref="TouchState.Format"/>. However, when a <c>Touchscreen</c>
|
||
|
|
/// sees an event containing a <see cref="TouchState"/>, it will handle that event on a special code path.
|
||
|
|
///
|
||
|
|
/// This allows <c>Touchscreen</c> to decide on its own which control in <see cref="touches"/> to store
|
||
|
|
/// a touch at and to perform things such as tap detection (see <see cref="TouchControl.tap"/> and
|
||
|
|
/// <see cref="TouchControl.tapCount"/>) and primary touch handling (see <see cref="primaryTouch"/>).
|
||
|
|
///
|
||
|
|
/// <example>
|
||
|
|
/// <code>
|
||
|
|
/// // Create a touchscreen device.
|
||
|
|
/// var touchscreen = InputSystem.AddDevice<Touchscreen>();
|
||
|
|
///
|
||
|
|
/// // Send a touch to the device.
|
||
|
|
/// InputSystem.QueueStateEvent(touchscreen,
|
||
|
|
/// new TouchState
|
||
|
|
/// {
|
||
|
|
/// phase = TouchPhase.Began,
|
||
|
|
/// // Must have a valid, non-zero touch ID. Touchscreen will not operate
|
||
|
|
/// // correctly if we don't set IDs properly.
|
||
|
|
/// touchId = 1,
|
||
|
|
/// position = new Vector2(123, 234),
|
||
|
|
/// // Delta will be computed by Touchscreen automatically.
|
||
|
|
/// });
|
||
|
|
/// </code>
|
||
|
|
/// </example>
|
||
|
|
///
|
||
|
|
/// Note that this class presents a fairly low-level touch API. When working with touch from script code,
|
||
|
|
/// it is recommended to use the higher-level <see cref="EnhancedTouch.Touch"/> API instead.
|
||
|
|
/// </remarks>
|
||
|
|
[InputControlLayout(stateType = typeof(TouchscreenState), isGenericTypeOfDevice = true)]
|
||
|
|
public class Touchscreen : Pointer, IInputStateCallbackReceiver, IEventMerger, ICustomDeviceReset
|
||
|
|
{
|
||
|
|
/// <summary>
|
||
|
|
/// Synthetic control that has the data for the touch that is deemed the "primary" touch at the moment.
|
||
|
|
/// </summary>
|
||
|
|
/// <value>Control tracking the screen's primary touch.</value>
|
||
|
|
/// <remarks>
|
||
|
|
/// This touch duplicates touch data from whichever touch is deemed the primary touch at the moment.
|
||
|
|
/// When going from no fingers down to any finger down, the first finger to touch the screen is
|
||
|
|
/// deemed the "primary touch". It stays the primary touch until the last finger is released.
|
||
|
|
///
|
||
|
|
/// Note that unlike the touch from which it originates, the primary touch will be kept ongoing for
|
||
|
|
/// as long as there is still a finger on the screen. Put another way, <see cref="TouchControl.phase"/>
|
||
|
|
/// of <c>primaryTouch</c> will only transition to <see cref="TouchPhase.Ended"/> once the last finger
|
||
|
|
/// has been lifted off the screen.
|
||
|
|
/// </remarks>
|
||
|
|
public TouchControl primaryTouch { get; protected set; }
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// Array of all <see cref="TouchControl"/>s on the device.
|
||
|
|
/// </summary>
|
||
|
|
/// <value>All <see cref="TouchControl"/>s on the screen.</value>
|
||
|
|
/// <remarks>
|
||
|
|
/// By default, a touchscreen will allocate 10 touch controls. This can be changed
|
||
|
|
/// by modifying the "Touchscreen" layout itself or by derived layouts. In practice,
|
||
|
|
/// this means that this array will usually have a fixed length of 10 entries but
|
||
|
|
/// it may deviate from that.
|
||
|
|
/// </remarks>
|
||
|
|
public ReadOnlyArray<TouchControl> touches { get; protected set; }
|
||
|
|
|
||
|
|
protected TouchControl[] touchControlArray
|
||
|
|
{
|
||
|
|
get => touches.m_Array;
|
||
|
|
set => touches = new ReadOnlyArray<TouchControl>(value);
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// The touchscreen that was added or updated last or null if there is no
|
||
|
|
/// touchscreen connected to the system.
|
||
|
|
/// </summary>
|
||
|
|
/// <value>Current touch screen.</value>
|
||
|
|
public new static Touchscreen current { get; internal set; }
|
||
|
|
|
||
|
|
/// <inheritdoc />
|
||
|
|
public override void MakeCurrent()
|
||
|
|
{
|
||
|
|
base.MakeCurrent();
|
||
|
|
current = this;
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <inheritdoc />
|
||
|
|
protected override void OnRemoved()
|
||
|
|
{
|
||
|
|
base.OnRemoved();
|
||
|
|
if (current == this)
|
||
|
|
current = null;
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <inheritdoc />
|
||
|
|
protected override void FinishSetup()
|
||
|
|
{
|
||
|
|
base.FinishSetup();
|
||
|
|
|
||
|
|
primaryTouch = GetChildControl<TouchControl>("primaryTouch");
|
||
|
|
displayIndex = primaryTouch.displayIndex;
|
||
|
|
|
||
|
|
// Find out how many touch controls we have.
|
||
|
|
var touchControlCount = 0;
|
||
|
|
foreach (var child in children)
|
||
|
|
if (child is TouchControl)
|
||
|
|
++touchControlCount;
|
||
|
|
|
||
|
|
// Keep primaryTouch out of array.
|
||
|
|
Debug.Assert(touchControlCount >= 1, "Should have found at least primaryTouch control");
|
||
|
|
if (touchControlCount >= 1)
|
||
|
|
--touchControlCount;
|
||
|
|
|
||
|
|
// Gather touch controls into array.
|
||
|
|
var touchArray = new TouchControl[touchControlCount];
|
||
|
|
var touchIndex = 0;
|
||
|
|
foreach (var child in children)
|
||
|
|
{
|
||
|
|
if (child == primaryTouch)
|
||
|
|
continue;
|
||
|
|
|
||
|
|
if (child is TouchControl control)
|
||
|
|
touchArray[touchIndex++] = control;
|
||
|
|
}
|
||
|
|
|
||
|
|
touches = new ReadOnlyArray<TouchControl>(touchArray);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Touch has more involved state handling than most other devices. To not put touch allocation logic
|
||
|
|
// in all the various platform backends (i.e. see a touch with a certain ID coming in from the system
|
||
|
|
// and then having to decide *where* to store that inside of Touchscreen's state), we have backends
|
||
|
|
// send us individual touches ('TOUC') instead of whole Touchscreen snapshots ('TSRC'). Using
|
||
|
|
// IInputStateCallbackReceiver, Touchscreen then dynamically decides where to store the touch.
|
||
|
|
//
|
||
|
|
// Also, Touchscreen has bits of logic to automatically synthesize the state of controls it inherits
|
||
|
|
// from Pointer (such as "<Pointer>/press").
|
||
|
|
//
|
||
|
|
// NOTE: We do *NOT* make a effort here to prevent us from losing short-lived touches. This is different
|
||
|
|
// from the old input system where individual touches were not reused until the next frame. This meant
|
||
|
|
// that additional touches potentially had to be allocated in order to accommodate new touches coming
|
||
|
|
// in from the system.
|
||
|
|
//
|
||
|
|
// The rationale for *NOT* doing this is that:
|
||
|
|
//
|
||
|
|
// a) Actions don't need it. They observe every single state change and thus will not lose data
|
||
|
|
// even if it is short-lived (i.e. changes more than once in the same update).
|
||
|
|
// b) The higher-level Touch (EnhancedTouchSupport) API is provided to
|
||
|
|
// not only handle this scenario but also give a generally more flexible and useful touch API
|
||
|
|
// than writing code directly against Touchscreen.
|
||
|
|
|
||
|
|
protected new unsafe void OnNextUpdate()
|
||
|
|
{
|
||
|
|
Profiler.BeginSample("Touchscreen.OnNextUpdate");
|
||
|
|
|
||
|
|
////TODO: early out and skip crawling through touches if we didn't change state in the last update
|
||
|
|
//// (also obsoletes the need for the if() check below)
|
||
|
|
var statePtr = currentStatePtr;
|
||
|
|
var touchStatePtr = (TouchState*)((byte*)statePtr + stateBlock.byteOffset + TouchscreenState.kTouchDataOffset);
|
||
|
|
for (var i = 0; i < touches.Count; ++i, ++touchStatePtr)
|
||
|
|
{
|
||
|
|
// Reset delta.
|
||
|
|
if (touchStatePtr->delta != default)
|
||
|
|
InputState.Change(touches[i].delta, Vector2.zero);
|
||
|
|
|
||
|
|
// Reset tap count.
|
||
|
|
// NOTE: We are basing this on startTime rather than adding on end time of the last touch. The reason is
|
||
|
|
// that to do so we would have to add another record to keep track of timestamps for each touch. And
|
||
|
|
// since we know the maximum time that a tap can take, we have a reasonable estimate for when a prior
|
||
|
|
// tap must have ended.
|
||
|
|
if (touchStatePtr->tapCount > 0 && InputState.currentTime >= touchStatePtr->startTime + s_TapTime + s_TapDelayTime)
|
||
|
|
InputState.Change(touches[i].tapCount, (byte)0);
|
||
|
|
}
|
||
|
|
|
||
|
|
var primaryTouchState = (TouchState*)((byte*)statePtr + stateBlock.byteOffset);
|
||
|
|
if (primaryTouchState->delta != default)
|
||
|
|
InputState.Change(primaryTouch.delta, Vector2.zero);
|
||
|
|
if (primaryTouchState->tapCount > 0 && InputState.currentTime >= primaryTouchState->startTime + s_TapTime + s_TapDelayTime)
|
||
|
|
InputState.Change(primaryTouch.tapCount, (byte)0);
|
||
|
|
|
||
|
|
Profiler.EndSample();
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// Called whenever a new state event is received.
|
||
|
|
/// </summary>
|
||
|
|
/// <param name="eventPtr"></param>
|
||
|
|
protected new unsafe void OnStateEvent(InputEventPtr eventPtr)
|
||
|
|
{
|
||
|
|
var eventType = eventPtr.type;
|
||
|
|
|
||
|
|
// We don't allow partial updates for TouchStates.
|
||
|
|
if (eventType == DeltaStateEvent.Type)
|
||
|
|
return;
|
||
|
|
|
||
|
|
// If it's not a single touch, just take the event state as is (will have to be TouchscreenState).
|
||
|
|
var stateEventPtr = StateEvent.FromUnchecked(eventPtr);
|
||
|
|
if (stateEventPtr->stateFormat != TouchState.Format)
|
||
|
|
{
|
||
|
|
InputState.Change(this, eventPtr);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
Profiler.BeginSample("TouchAllocate");
|
||
|
|
|
||
|
|
// For performance reasons, we read memory here directly rather than going through
|
||
|
|
// ReadValue() of the individual TouchControl children. This means that Touchscreen,
|
||
|
|
// unlike other devices, is hardwired to a single memory layout only.
|
||
|
|
|
||
|
|
var statePtr = currentStatePtr;
|
||
|
|
var currentTouchState = (TouchState*)((byte*)statePtr + touches[0].stateBlock.byteOffset);
|
||
|
|
var primaryTouchState = (TouchState*)((byte*)statePtr + primaryTouch.stateBlock.byteOffset);
|
||
|
|
var touchControlCount = touches.Count;
|
||
|
|
|
||
|
|
// Native does not send a full TouchState as we define it here. We have added some fields
|
||
|
|
// that we store internally. Make sure we don't read invalid memory here and copy only what
|
||
|
|
// we got.
|
||
|
|
TouchState newTouchState;
|
||
|
|
if (stateEventPtr->stateSizeInBytes == TouchState.kSizeInBytes)
|
||
|
|
{
|
||
|
|
newTouchState = *(TouchState*)stateEventPtr->state;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
newTouchState = default;
|
||
|
|
UnsafeUtility.MemCpy(UnsafeUtility.AddressOf(ref newTouchState), stateEventPtr->state, stateEventPtr->stateSizeInBytes);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Make sure we're not getting thrown off by noise on fields that we don't want to
|
||
|
|
// pick up from input.
|
||
|
|
newTouchState.tapCount = 0;
|
||
|
|
newTouchState.isTapPress = false;
|
||
|
|
newTouchState.isTapRelease = false;
|
||
|
|
newTouchState.updateStepCount = InputUpdate.s_UpdateStepCount;
|
||
|
|
|
||
|
|
////REVIEW: The logic in here makes us inherently susceptible to the ordering of the touch events in the event
|
||
|
|
//// stream. I believe we have platforms (Android?) that send us touch events finger-by-finger (or touch-by-touch?)
|
||
|
|
//// rather than sorted by time. This will probably screw up the logic in here.
|
||
|
|
|
||
|
|
// If it's an ongoing touch, try to find the TouchState we have allocated to the touch
|
||
|
|
// previously.
|
||
|
|
var phase = newTouchState.phase;
|
||
|
|
if (phase != TouchPhase.Began)
|
||
|
|
{
|
||
|
|
var touchId = newTouchState.touchId;
|
||
|
|
for (var i = 0; i < touchControlCount; ++i)
|
||
|
|
{
|
||
|
|
if (currentTouchState[i].touchId == touchId)
|
||
|
|
{
|
||
|
|
// Preserve primary touch state.
|
||
|
|
var isPrimaryTouch = currentTouchState[i].isPrimaryTouch;
|
||
|
|
newTouchState.isPrimaryTouch = isPrimaryTouch;
|
||
|
|
|
||
|
|
// Compute delta if touch doesn't have one.
|
||
|
|
if (newTouchState.delta == default)
|
||
|
|
newTouchState.delta = newTouchState.position - currentTouchState[i].position;
|
||
|
|
|
||
|
|
// Accumulate delta.
|
||
|
|
newTouchState.delta += currentTouchState[i].delta;
|
||
|
|
|
||
|
|
// Keep start time and position.
|
||
|
|
newTouchState.startTime = currentTouchState[i].startTime;
|
||
|
|
newTouchState.startPosition = currentTouchState[i].startPosition;
|
||
|
|
|
||
|
|
// Detect taps.
|
||
|
|
var isTap = newTouchState.isNoneEndedOrCanceled &&
|
||
|
|
(eventPtr.time - newTouchState.startTime) <= s_TapTime &&
|
||
|
|
////REVIEW: this only takes the final delta to start position into account, not the delta over the lifetime of the
|
||
|
|
//// touch; is this robust enough or do we need to make sure that we never move more than the tap radius
|
||
|
|
//// over the entire lifetime of the touch?
|
||
|
|
(newTouchState.position - newTouchState.startPosition).sqrMagnitude <= s_TapRadiusSquared;
|
||
|
|
if (isTap)
|
||
|
|
newTouchState.tapCount = (byte)(currentTouchState[i].tapCount + 1);
|
||
|
|
else
|
||
|
|
newTouchState.tapCount = currentTouchState[i].tapCount; // Preserve tap count; reset in OnCarryStateForward.
|
||
|
|
|
||
|
|
// Update primary touch.
|
||
|
|
if (isPrimaryTouch)
|
||
|
|
{
|
||
|
|
if (newTouchState.isNoneEndedOrCanceled)
|
||
|
|
{
|
||
|
|
////REVIEW: also reset tapCounts here when tap delay time has expired on the touch?
|
||
|
|
|
||
|
|
newTouchState.isPrimaryTouch = false;
|
||
|
|
|
||
|
|
// Primary touch was ended. See if there are still other ongoing touches.
|
||
|
|
var haveOngoingTouch = false;
|
||
|
|
for (var n = 0; n < touchControlCount; ++n)
|
||
|
|
{
|
||
|
|
if (n == i)
|
||
|
|
continue;
|
||
|
|
|
||
|
|
if (currentTouchState[n].isInProgress)
|
||
|
|
{
|
||
|
|
haveOngoingTouch = true;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!haveOngoingTouch)
|
||
|
|
{
|
||
|
|
// No, primary was the only ongoing touch. End it.
|
||
|
|
|
||
|
|
if (isTap)
|
||
|
|
TriggerTap(primaryTouch, ref newTouchState, eventPtr);
|
||
|
|
else
|
||
|
|
InputState.Change(primaryTouch, ref newTouchState, eventPtr: eventPtr);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// Yes, we have other touches going on. Make the primary touch an
|
||
|
|
// orphan and wait until the other touches are released.
|
||
|
|
|
||
|
|
var newPrimaryTouchState = newTouchState;
|
||
|
|
newPrimaryTouchState.phase = TouchPhase.Moved;
|
||
|
|
newPrimaryTouchState.isOrphanedPrimaryTouch = true;
|
||
|
|
InputState.Change(primaryTouch, ref newPrimaryTouchState, eventPtr: eventPtr);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// Primary touch was updated.
|
||
|
|
InputState.Change(primaryTouch, ref newTouchState, eventPtr: eventPtr);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// If it's not the primary touch but the touch has ended, see if we have an
|
||
|
|
// orphaned primary touch. If so, end it now.
|
||
|
|
if (newTouchState.isNoneEndedOrCanceled && primaryTouchState->isOrphanedPrimaryTouch)
|
||
|
|
{
|
||
|
|
var haveOngoingTouch = false;
|
||
|
|
for (var n = 0; n < touchControlCount; ++n)
|
||
|
|
{
|
||
|
|
if (n == i)
|
||
|
|
continue;
|
||
|
|
|
||
|
|
if (currentTouchState[n].isInProgress)
|
||
|
|
{
|
||
|
|
haveOngoingTouch = true;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!haveOngoingTouch)
|
||
|
|
{
|
||
|
|
primaryTouchState->isOrphanedPrimaryTouch = false;
|
||
|
|
InputState.Change(primaryTouch.phase, (byte)TouchPhase.Ended);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (isTap)
|
||
|
|
{
|
||
|
|
// Make tap button go down and up.
|
||
|
|
//
|
||
|
|
// NOTE: We do this here instead of right away up there when we detect the touch so
|
||
|
|
// that the state change notifications go together. First those for the primary
|
||
|
|
// touch, then the ones for the touch record itself.
|
||
|
|
TriggerTap(touches[i], ref newTouchState, eventPtr);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
InputState.Change(touches[i], ref newTouchState, eventPtr: eventPtr);
|
||
|
|
}
|
||
|
|
|
||
|
|
Profiler.EndSample();
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Couldn't find an entry. Either it was a touch that we previously ran out of available
|
||
|
|
// entries for or it's an event sent out of sequence. Ignore the touch to be consistent.
|
||
|
|
|
||
|
|
Profiler.EndSample();
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// It's a new touch. Try to find an unused TouchState.
|
||
|
|
for (var i = 0; i < touchControlCount; ++i, ++currentTouchState)
|
||
|
|
{
|
||
|
|
// NOTE: We're overwriting any ended touch immediately here. This means we immediately overwrite even
|
||
|
|
// if we still have other unused slots. What this gives us is a completely predictable touch #0..#N
|
||
|
|
// sequence (i.e. touch #N is only ever used if there are indeed #N concurrently touches). However,
|
||
|
|
// it does mean that we overwrite state aggressively. If you are not using actions or the higher-level
|
||
|
|
// Touch API, be aware of this!
|
||
|
|
if (currentTouchState->isNoneEndedOrCanceled)
|
||
|
|
{
|
||
|
|
newTouchState.delta = Vector2.zero;
|
||
|
|
newTouchState.startTime = eventPtr.time;
|
||
|
|
newTouchState.startPosition = newTouchState.position;
|
||
|
|
|
||
|
|
// Make sure we're not picking up noise sent from native.
|
||
|
|
newTouchState.isPrimaryTouch = false;
|
||
|
|
newTouchState.isOrphanedPrimaryTouch = false;
|
||
|
|
newTouchState.isTap = false;
|
||
|
|
|
||
|
|
// Tap counts are preserved from prior touches on the same finger.
|
||
|
|
newTouchState.tapCount = currentTouchState->tapCount;
|
||
|
|
|
||
|
|
// Make primary touch, if there's none currently.
|
||
|
|
if (primaryTouchState->isNoneEndedOrCanceled)
|
||
|
|
{
|
||
|
|
newTouchState.isPrimaryTouch = true;
|
||
|
|
InputState.Change(primaryTouch, ref newTouchState, eventPtr: eventPtr);
|
||
|
|
}
|
||
|
|
|
||
|
|
InputState.Change(touches[i], ref newTouchState, eventPtr: eventPtr);
|
||
|
|
|
||
|
|
Profiler.EndSample();
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// We ran out of state and we don't want to stomp an existing ongoing touch.
|
||
|
|
// Drop this touch entirely.
|
||
|
|
// NOTE: Getting here means we're having fewer touch entries than the number of concurrent touches supported
|
||
|
|
// by the backend (or someone is simply sending us nonsense data).
|
||
|
|
|
||
|
|
Profiler.EndSample();
|
||
|
|
}
|
||
|
|
|
||
|
|
void IInputStateCallbackReceiver.OnNextUpdate()
|
||
|
|
{
|
||
|
|
OnNextUpdate();
|
||
|
|
}
|
||
|
|
|
||
|
|
void IInputStateCallbackReceiver.OnStateEvent(InputEventPtr eventPtr)
|
||
|
|
{
|
||
|
|
OnStateEvent(eventPtr);
|
||
|
|
}
|
||
|
|
|
||
|
|
unsafe bool IInputStateCallbackReceiver.GetStateOffsetForEvent(InputControl control, InputEventPtr eventPtr, ref uint offset)
|
||
|
|
{
|
||
|
|
// This code goes back to the trickery we perform in OnStateEvent. We consume events in TouchState format
|
||
|
|
// instead of in TouchscreenState format. This means that the input system does not know how the state in those
|
||
|
|
// events correlates to the controls we have.
|
||
|
|
//
|
||
|
|
// This method is used to give the input system an offset based on which the input system can compute relative
|
||
|
|
// offsets into the state of eventPtr for controls that are part of the control hierarchy rooted at 'control'.
|
||
|
|
|
||
|
|
if (!eventPtr.IsA<StateEvent>())
|
||
|
|
return false;
|
||
|
|
|
||
|
|
var stateEventPtr = StateEvent.FromUnchecked(eventPtr);
|
||
|
|
if (stateEventPtr->stateFormat != TouchState.Format)
|
||
|
|
return false;
|
||
|
|
|
||
|
|
// If we get a null control and a TouchState event, all the system wants to know is what
|
||
|
|
// state offset to use to make sense of the event.
|
||
|
|
if (control == null)
|
||
|
|
{
|
||
|
|
// We can't say which specific touch this would go to (if any at all) without going through
|
||
|
|
// the same logic that we run through in OnStateEvent. For the sake of just being able to read
|
||
|
|
// out data from a touch event, it'd be enough to return the offset of *any* TouchControl here.
|
||
|
|
// But for the sake of being able to compare the data in an event to that in the Touchscreen,
|
||
|
|
// this would not be enough. Thus we make an attempt here at locating a touch record which *should*
|
||
|
|
// be receiving the event if it were to be processed by OnStateEvent.
|
||
|
|
|
||
|
|
var currentTouchState = (TouchState*)((byte*)currentStatePtr + touches[0].stateBlock.byteOffset);
|
||
|
|
var eventTouchState = (TouchState*)stateEventPtr->state;
|
||
|
|
var eventTouchId = eventTouchState->touchId;
|
||
|
|
var eventTouchPhase = eventTouchState->phase;
|
||
|
|
|
||
|
|
var touchControlCount = touches.Count;
|
||
|
|
for (var i = 0; i < touchControlCount; ++i)
|
||
|
|
{
|
||
|
|
var touch = ¤tTouchState[i];
|
||
|
|
if (touch->touchId == eventTouchId || (!touch->isInProgress && eventTouchPhase.IsActive()))
|
||
|
|
{
|
||
|
|
offset = primaryTouch.m_StateBlock.byteOffset + primaryTouch.m_StateBlock.alignedSizeInBytes - m_StateBlock.byteOffset +
|
||
|
|
(uint)(i * UnsafeUtility.SizeOf<TouchState>());
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// The only controls we can read out from a TouchState event are those that are part of TouchControl
|
||
|
|
// (and part of this Touchscreen).
|
||
|
|
var touchControl = control.FindInParentChain<TouchControl>();
|
||
|
|
if (touchControl == null || touchControl.parent != this)
|
||
|
|
return false;
|
||
|
|
|
||
|
|
// We could allow *any* of the TouchControls on the Touchscreen here. We'd simply base the
|
||
|
|
// offset on the TouchControl of the 'control' we get as an argument.
|
||
|
|
//
|
||
|
|
// However, doing that would mean that all the TouchControls would map into the same input event.
|
||
|
|
// So when a piece of code like in InputUser goes and cycles through all controls to determine ones
|
||
|
|
// that have changed in an event, it would find that instead of a single touch position value changing,
|
||
|
|
// all of them would be changing from the same single event.
|
||
|
|
//
|
||
|
|
// For this reason, we lock things down to the primaryTouch control.
|
||
|
|
|
||
|
|
if (touchControl != primaryTouch)
|
||
|
|
return false;
|
||
|
|
|
||
|
|
offset = touchControl.stateBlock.byteOffset - m_StateBlock.byteOffset;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Implement our own custom reset so that we can cancel touches instead of just wiping them
|
||
|
|
// with default state.
|
||
|
|
unsafe void ICustomDeviceReset.Reset()
|
||
|
|
{
|
||
|
|
var statePtr = currentStatePtr;
|
||
|
|
|
||
|
|
//// https://jira.unity3d.com/browse/ISX-930
|
||
|
|
////TODO: Figure out a proper way to distinguish the source / reason for a state change.
|
||
|
|
//// What we're doing here is constructing an event solely for the purpose of Finger.ShouldRecordTouch() not
|
||
|
|
//// ignoring the state change like it does for delta resets.
|
||
|
|
|
||
|
|
using (var buffer = new NativeArray<byte>(StateEvent.GetEventSizeWithPayload<TouchState>(), Allocator.Temp))
|
||
|
|
{
|
||
|
|
var eventPtr = (StateEvent*)buffer.GetUnsafePtr();
|
||
|
|
|
||
|
|
eventPtr->baseEvent = new InputEvent(StateEvent.Type, buffer.Length, deviceId);
|
||
|
|
|
||
|
|
var primaryTouchState = (TouchState*)((byte*)statePtr + primaryTouch.stateBlock.byteOffset);
|
||
|
|
if (primaryTouchState->phase.IsActive())
|
||
|
|
{
|
||
|
|
UnsafeUtility.MemCpy(eventPtr->state, primaryTouchState, UnsafeUtility.SizeOf<TouchState>());
|
||
|
|
((TouchState*)eventPtr->state)->phase = TouchPhase.Canceled;
|
||
|
|
InputState.Change(primaryTouch.phase, TouchPhase.Canceled, eventPtr: new InputEventPtr((InputEvent*)eventPtr));
|
||
|
|
}
|
||
|
|
|
||
|
|
var touchStates = (TouchState*)((byte*)statePtr + touches[0].stateBlock.byteOffset);
|
||
|
|
var touchCount = touches.Count;
|
||
|
|
for (var i = 0; i < touchCount; ++i)
|
||
|
|
{
|
||
|
|
if (touchStates[i].phase.IsActive())
|
||
|
|
{
|
||
|
|
UnsafeUtility.MemCpy(eventPtr->state, &touchStates[i], UnsafeUtility.SizeOf<TouchState>());
|
||
|
|
((TouchState*)eventPtr->state)->phase = TouchPhase.Canceled;
|
||
|
|
InputState.Change(touches[i].phase, TouchPhase.Canceled, eventPtr: new InputEventPtr((InputEvent*)eventPtr));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
internal static unsafe bool MergeForward(InputEventPtr currentEventPtr, InputEventPtr nextEventPtr)
|
||
|
|
{
|
||
|
|
if (currentEventPtr.type != StateEvent.Type || nextEventPtr.type != StateEvent.Type)
|
||
|
|
return false;
|
||
|
|
|
||
|
|
var currentEvent = StateEvent.FromUnchecked(currentEventPtr);
|
||
|
|
var nextEvent = StateEvent.FromUnchecked(nextEventPtr);
|
||
|
|
|
||
|
|
if (currentEvent->stateFormat != TouchState.Format || nextEvent->stateFormat != TouchState.Format)
|
||
|
|
return false;
|
||
|
|
|
||
|
|
var currentState = (TouchState*)currentEvent->state;
|
||
|
|
var nextState = (TouchState*)nextEvent->state;
|
||
|
|
|
||
|
|
if (currentState->touchId != nextState->touchId || currentState->phaseId != nextState->phaseId || currentState->flags != nextState->flags)
|
||
|
|
return false;
|
||
|
|
|
||
|
|
nextState->delta += currentState->delta;
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool IEventMerger.MergeForward(InputEventPtr currentEventPtr, InputEventPtr nextEventPtr)
|
||
|
|
{
|
||
|
|
return MergeForward(currentEventPtr, nextEventPtr);
|
||
|
|
}
|
||
|
|
|
||
|
|
// We can only detect taps on touch *release*. At which point it acts like a button that triggers and releases
|
||
|
|
// in one operation.
|
||
|
|
private static void TriggerTap(TouchControl control, ref TouchState state, InputEventPtr eventPtr)
|
||
|
|
{
|
||
|
|
////REVIEW: we're updating the entire TouchControl here; we could update just the tap state using a delta event; problem
|
||
|
|
//// is that the tap *down* still needs a full update on the state
|
||
|
|
|
||
|
|
// We don't increase tapCount here as we may be sending the tap from the same state to both the TouchControl
|
||
|
|
// that got tapped and to primaryTouch.
|
||
|
|
|
||
|
|
// Press.
|
||
|
|
state.isTapPress = true;
|
||
|
|
state.isTapRelease = false;
|
||
|
|
InputState.Change(control, ref state, eventPtr: eventPtr);
|
||
|
|
|
||
|
|
// Release.
|
||
|
|
state.isTapPress = false;
|
||
|
|
state.isTapRelease = true;
|
||
|
|
InputState.Change(control, ref state, eventPtr: eventPtr);
|
||
|
|
state.isTapRelease = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal static float s_TapTime;
|
||
|
|
internal static float s_TapDelayTime;
|
||
|
|
internal static float s_TapRadiusSquared;
|
||
|
|
}
|
||
|
|
}
|