using System;
|
using System.Collections.Generic;
|
using System.Linq;
|
using Core.Utilities;
|
using UnityEngine;
|
using UnityEngine.EventSystems;
|
using Debug = System.Diagnostics.Debug;
|
using UnityInput = UnityEngine.Input;
|
|
namespace Core.Input
|
{
|
/// <summary>
|
/// Class to manage tap/drag/pinch gestures and other controls
|
/// </summary>
|
public class InputController : Singleton<InputController>
|
{
|
/// <summary>
|
/// How quickly flick velocity is accumulated with movements
|
/// </summary>
|
const float k_FlickAccumulationFactor = 0.8f;
|
|
/// <summary>
|
/// How far fingers must move before starting a drag
|
/// </summary>
|
public float dragThresholdTouch = 5;
|
|
/// <summary>
|
/// How far mouse must move before starting a drag
|
/// </summary>
|
public float dragThresholdMouse;
|
|
/// <summary>
|
/// How long before a touch can no longer be considered a tap
|
/// </summary>
|
public float tapTime = 0.2f;
|
|
/// <summary>
|
/// How long before a touch is considered a hold
|
/// </summary>
|
public float holdTime = 0.8f;
|
|
/// <summary>
|
/// Sensitivity of mouse-wheel based zoom
|
/// </summary>
|
public float mouseWheelSensitivity = 1.0f;
|
|
/// <summary>
|
/// How many mouse buttons to track
|
/// </summary>
|
public int trackMouseButtons = 2;
|
|
/// <summary>
|
/// Flick movement threshold
|
/// </summary>
|
public float flickThreshold = 2f;
|
|
/// <summary>
|
/// All the touches we're tracking
|
/// </summary>
|
List<TouchInfo> m_Touches;
|
|
/// <summary>
|
/// Mouse button info
|
/// </summary>
|
List<MouseButtonInfo> m_MouseInfo;
|
|
/// <summary>
|
/// Gets the number of active touches
|
/// </summary>
|
public int activeTouchCount
|
{
|
get { return m_Touches.Count; }
|
}
|
|
/// <summary>
|
/// Tracks if any of the mouse buttons were pressed this frame
|
/// </summary>
|
public bool mouseButtonPressedThisFrame { get; private set; }
|
|
/// <summary>
|
/// Tracks if the mouse moved this frame
|
/// </summary>
|
public bool mouseMovedOnThisFrame { get; private set; }
|
|
/// <summary>
|
/// Tracks if a touch began this frame
|
/// </summary>
|
public bool touchPressedThisFrame { get; private set; }
|
|
/// <summary>
|
/// Current mouse pointer info
|
/// </summary>
|
public PointerInfo basicMouseInfo { get; private set; }
|
|
/// <summary>
|
/// Event called when a pointer press is detected
|
/// </summary>
|
public event Action<PointerActionInfo> pressed;
|
|
/// <summary>
|
/// Event called when a pointer is released
|
/// </summary>
|
public event Action<PointerActionInfo> released;
|
|
/// <summary>
|
/// Event called when a pointer is tapped
|
/// </summary>
|
public event Action<PointerActionInfo> tapped;
|
|
/// <summary>
|
/// Event called when a drag starts
|
/// </summary>
|
public event Action<PointerActionInfo> startedDrag;
|
|
/// <summary>
|
/// Event called when a pointer is dragged
|
/// </summary>
|
public event Action<PointerActionInfo> dragged;
|
|
/// <summary>
|
/// Event called when a pointer starts a hold
|
/// </summary>
|
public event Action<PointerActionInfo> startedHold;
|
|
/// <summary>
|
/// Event called when the user scrolls the mouse wheel
|
/// </summary>
|
public event Action<WheelInfo> spunWheel;
|
|
/// <summary>
|
/// Event called when the user performs a pinch gesture
|
/// </summary>
|
public event Action<PinchInfo> pinched;
|
|
/// <summary>
|
/// Event called whenever the mouse is moved
|
/// </summary>
|
public event Action<PointerInfo> mouseMoved;
|
|
protected override void Awake()
|
{
|
base.Awake();
|
m_Touches = new List<TouchInfo>();
|
|
// Mouse specific initialization
|
if (UnityInput.mousePresent)
|
{
|
m_MouseInfo = new List<MouseButtonInfo>();
|
basicMouseInfo = new MouseCursorInfo { currentPosition = UnityInput.mousePosition };
|
|
for (int i = 0; i < trackMouseButtons; ++i)
|
{
|
m_MouseInfo.Add(new MouseButtonInfo
|
{
|
currentPosition = UnityInput.mousePosition,
|
mouseButtonId = i
|
});
|
}
|
}
|
|
UnityInput.simulateMouseWithTouches = false;
|
}
|
|
/// <summary>
|
/// Update all input
|
/// </summary>
|
void Update()
|
{
|
if (basicMouseInfo != null)
|
{
|
// Mouse was detected as present
|
UpdateMouse();
|
}
|
// Handle touches
|
UpdateTouches();
|
}
|
|
/// <summary>
|
/// Perform logic to update mouse/pointing device
|
/// </summary>
|
void UpdateMouse()
|
{
|
basicMouseInfo.previousPosition = basicMouseInfo.currentPosition;
|
basicMouseInfo.currentPosition = UnityInput.mousePosition;
|
basicMouseInfo.delta = basicMouseInfo.currentPosition - basicMouseInfo.previousPosition;
|
mouseMovedOnThisFrame = basicMouseInfo.delta.sqrMagnitude >= Mathf.Epsilon;
|
mouseButtonPressedThisFrame = false;
|
|
// Move event
|
if (basicMouseInfo.delta.sqrMagnitude > Mathf.Epsilon)
|
{
|
if (mouseMoved != null)
|
{
|
mouseMoved(basicMouseInfo);
|
}
|
}
|
// Button events
|
for (int i = 0; i < trackMouseButtons; ++i)
|
{
|
MouseButtonInfo mouseButton = m_MouseInfo[i];
|
mouseButton.delta = basicMouseInfo.delta;
|
mouseButton.previousPosition = basicMouseInfo.previousPosition;
|
mouseButton.currentPosition = basicMouseInfo.currentPosition;
|
if (UnityInput.GetMouseButton(i))
|
{
|
if (!mouseButton.isDown)
|
{
|
// First press
|
mouseButtonPressedThisFrame = true;
|
mouseButton.isDown = true;
|
mouseButton.startPosition = UnityInput.mousePosition;
|
mouseButton.startTime = Time.realtimeSinceStartup;
|
mouseButton.startedOverUI = EventSystem.current.IsPointerOverGameObject(-mouseButton.mouseButtonId - 1);
|
|
// Reset some stuff
|
mouseButton.totalMovement = 0;
|
mouseButton.isDrag = false;
|
mouseButton.wasHold = false;
|
mouseButton.isHold = false;
|
mouseButton.flickVelocity = Vector2.zero;
|
|
if (pressed != null)
|
{
|
pressed(mouseButton);
|
}
|
}
|
else
|
{
|
float moveDist = mouseButton.delta.magnitude;
|
// Dragging?
|
mouseButton.totalMovement += moveDist;
|
if (mouseButton.totalMovement > dragThresholdMouse)
|
{
|
bool wasDrag = mouseButton.isDrag;
|
|
mouseButton.isDrag = true;
|
if (mouseButton.isHold)
|
{
|
mouseButton.wasHold = mouseButton.isHold;
|
mouseButton.isHold = false;
|
}
|
|
// Did it just start now?
|
if (!wasDrag)
|
{
|
if (startedDrag != null)
|
{
|
startedDrag(mouseButton);
|
}
|
}
|
if (dragged != null)
|
{
|
dragged(mouseButton);
|
}
|
|
// Flick?
|
if (moveDist > flickThreshold)
|
{
|
mouseButton.flickVelocity =
|
(mouseButton.flickVelocity * (1 - k_FlickAccumulationFactor)) +
|
(mouseButton.delta * k_FlickAccumulationFactor);
|
}
|
else
|
{
|
mouseButton.flickVelocity = Vector2.zero;
|
}
|
}
|
else
|
{
|
// Stationary?
|
if (!mouseButton.isHold &&
|
!mouseButton.isDrag &&
|
Time.realtimeSinceStartup - mouseButton.startTime >= holdTime)
|
{
|
mouseButton.isHold = true;
|
if (startedHold != null)
|
{
|
startedHold(mouseButton);
|
}
|
}
|
}
|
}
|
}
|
else // Mouse button not up
|
{
|
if (mouseButton.isDown) // Released
|
{
|
mouseButton.isDown = false;
|
// Quick enough (with no drift) to be a tap?
|
if (!mouseButton.isDrag &&
|
Time.realtimeSinceStartup - mouseButton.startTime < tapTime)
|
{
|
if (tapped != null)
|
{
|
tapped(mouseButton);
|
}
|
}
|
if (released != null)
|
{
|
released(mouseButton);
|
}
|
}
|
}
|
}
|
|
// Mouse wheel
|
if (Mathf.Abs(UnityInput.GetAxis("Mouse ScrollWheel")) > Mathf.Epsilon)
|
{
|
if (spunWheel != null)
|
{
|
spunWheel(new WheelInfo
|
{
|
zoomAmount = UnityInput.GetAxis("Mouse ScrollWheel") * mouseWheelSensitivity
|
});
|
}
|
}
|
}
|
|
/// <summary>
|
/// Update all touches
|
/// </summary>
|
void UpdateTouches()
|
{
|
touchPressedThisFrame = false;
|
//for (int i = 0; i < UnityInput.touchCount; ++i)
|
if (UnityInput.touchCount > 0)
|
{
|
Touch touch = UnityInput.GetTouch(0);
|
|
// Find existing touch, or create new one
|
TouchInfo existingTouch = m_Touches.FirstOrDefault(t => t.touchId == touch.fingerId);
|
|
if (existingTouch == null)
|
{
|
existingTouch = new TouchInfo
|
{
|
touchId = touch.fingerId,
|
startPosition = touch.position,
|
currentPosition = touch.position,
|
previousPosition = touch.position,
|
startTime = Time.realtimeSinceStartup,
|
startedOverUI = EventSystem.current.IsPointerOverGameObject(touch.fingerId)
|
};
|
|
m_Touches.Add(existingTouch);
|
|
// Sanity check
|
Debug.Assert(touch.phase == TouchPhase.Began);
|
}
|
switch (touch.phase)
|
{
|
case TouchPhase.Began:
|
touchPressedThisFrame = true;
|
if (pressed != null)
|
{
|
pressed(existingTouch);
|
}
|
break;
|
|
case TouchPhase.Moved:
|
bool wasDrag = existingTouch.isDrag;
|
UpdateMovingFinger(touch, existingTouch);
|
|
// Is this a drag?
|
existingTouch.isDrag = existingTouch.totalMovement >= dragThresholdTouch;
|
|
if (existingTouch.isDrag)
|
{
|
if (existingTouch.isHold)
|
{
|
existingTouch.wasHold = existingTouch.isHold;
|
existingTouch.isHold = false;
|
}
|
// Did it just start now?
|
if (!wasDrag)
|
{
|
if (startedDrag != null)
|
{
|
startedDrag(existingTouch);
|
}
|
}
|
if (dragged != null)
|
{
|
dragged(existingTouch);
|
}
|
|
if (existingTouch.delta.sqrMagnitude > flickThreshold * flickThreshold)
|
{
|
existingTouch.flickVelocity =
|
(existingTouch.flickVelocity * (1 - k_FlickAccumulationFactor)) +
|
(existingTouch.delta * k_FlickAccumulationFactor);
|
}
|
else
|
{
|
existingTouch.flickVelocity = Vector2.zero;
|
}
|
}
|
else
|
{
|
UpdateHoldingFinger(existingTouch);
|
}
|
break;
|
|
case TouchPhase.Canceled:
|
case TouchPhase.Ended:
|
// Could have moved a bit
|
UpdateMovingFinger(touch, existingTouch);
|
// Quick enough (with no drift) to be a tap?
|
if (!existingTouch.isDrag &&
|
Time.realtimeSinceStartup - existingTouch.startTime < tapTime)
|
{
|
if (tapped != null)
|
{
|
tapped(existingTouch);
|
}
|
}
|
if (released != null)
|
{
|
released(existingTouch);
|
}
|
|
// Remove from track list
|
m_Touches.Remove(existingTouch);
|
break;
|
|
case TouchPhase.Stationary:
|
UpdateMovingFinger(touch, existingTouch);
|
UpdateHoldingFinger(existingTouch);
|
existingTouch.flickVelocity = Vector2.zero;
|
break;
|
}
|
}
|
|
if (activeTouchCount >= 2 && (m_Touches[0].isDrag ||
|
m_Touches[1].isDrag))
|
{
|
if (pinched != null)
|
{
|
pinched(new PinchInfo
|
{
|
touch1 = m_Touches[0],
|
touch2 = m_Touches[1]
|
});
|
}
|
}
|
}
|
|
/// <summary>
|
/// Update a TouchInfo that might be holding
|
/// </summary>
|
/// <param name="existingTouch"></param>
|
void UpdateHoldingFinger(PointerActionInfo existingTouch)
|
{
|
if (!existingTouch.isHold &&
|
!existingTouch.isDrag &&
|
Time.realtimeSinceStartup - existingTouch.startTime >= holdTime)
|
{
|
existingTouch.isHold = true;
|
if (startedHold != null)
|
{
|
startedHold(existingTouch);
|
}
|
}
|
}
|
|
/// <summary>
|
/// Update a TouchInfo with movement
|
/// </summary>
|
/// <param name="touch">The Unity touch object</param>
|
/// <param name="existingTouch">The object that's tracking Unity's touch</param>
|
void UpdateMovingFinger(Touch touch, PointerActionInfo existingTouch)
|
{
|
float dragDist = touch.deltaPosition.magnitude;
|
|
existingTouch.previousPosition = existingTouch.currentPosition;
|
existingTouch.currentPosition = touch.position;
|
existingTouch.delta = touch.deltaPosition;
|
existingTouch.totalMovement += dragDist;
|
}
|
}
|
}
|
