You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
390 lines
14 KiB
390 lines
14 KiB
using System;
|
|
using System.Collections;
|
|
using UnityEngine;
|
|
using UnityEngine.Serialization;
|
|
using UnityEngine.EventSystems;
|
|
|
|
|
|
namespace com.rfilkov.components
|
|
{
|
|
/// <summary>
|
|
/// InteractionInputModule is the input module that can be used as component of the Unity-UI EventSystem.
|
|
/// </summary>
|
|
public class InteractionInputModule : PointerInputModule, InteractionListenerInterface
|
|
{
|
|
[Tooltip("Index of the player, tracked by the respective InteractionManager. 0 means the 1st player, 1 - the 2nd one, 2 - the 3rd one, etc.")]
|
|
public int playerIndex = 0;
|
|
|
|
[Tooltip("Whether the left hand interaction is allowed by the respective InteractionManager.")]
|
|
public bool leftHandInteraction = true;
|
|
|
|
[Tooltip("Whether the right hand interaction is allowed by the respective InteractionManager.")]
|
|
public bool rightHandInteraction = true;
|
|
|
|
[Tooltip("Whether to process the hand cursor movements (i.e for hovering ui-elements), or not.")]
|
|
public bool processCursorMovement = false;
|
|
|
|
|
|
//private bool m_isLeftHand = false;
|
|
private bool m_leftHandGrip = false;
|
|
private bool m_rightHandGrip = false;
|
|
private Vector3 m_handCursorPos = Vector3.zero;
|
|
private Vector2 m_lastCursorPos = Vector2.zero;
|
|
|
|
private PointerEventData.FramePressState m_framePressState = PointerEventData.FramePressState.NotChanged;
|
|
private readonly MouseState m_MouseState = new MouseState();
|
|
|
|
// interaction manager for the same player
|
|
private InteractionManager intManager;
|
|
|
|
// The single instance of InteractionInputModule
|
|
//private static InteractionInputModule instance;
|
|
|
|
|
|
///// <summary>
|
|
///// Gets the single InteractionInputModule instance.
|
|
///// </summary>
|
|
///// <value>The InteractionInputModule instance.</value>
|
|
//public static InteractionInputModule Instance
|
|
//{
|
|
// get
|
|
// {
|
|
// return instance;
|
|
// }
|
|
//}
|
|
|
|
//protected InteractionInputModule()
|
|
//{
|
|
// instance = this;
|
|
//}
|
|
|
|
|
|
protected override void Awake()
|
|
{
|
|
base.Awake();
|
|
|
|
intManager = InteractionManager.GetInstance(playerIndex, leftHandInteraction, rightHandInteraction);
|
|
}
|
|
|
|
|
|
[SerializeField]
|
|
[FormerlySerializedAs("m_AllowActivationOnMobileDevice")]
|
|
private bool m_ForceModuleActive;
|
|
|
|
|
|
public bool forceModuleActive
|
|
{
|
|
get { return m_ForceModuleActive; }
|
|
set { m_ForceModuleActive = value; }
|
|
}
|
|
|
|
public override bool IsModuleSupported()
|
|
{
|
|
return m_ForceModuleActive || intManager != null;
|
|
}
|
|
|
|
public override bool ShouldActivateModule()
|
|
{
|
|
if (!base.ShouldActivateModule())
|
|
return false;
|
|
|
|
if (intManager == null)
|
|
{
|
|
intManager = InteractionManager.GetInstance(playerIndex, leftHandInteraction, rightHandInteraction);
|
|
}
|
|
|
|
//bool shouldActivate |= (InteractionManager.Instance != null && InteractionManager.Instance.IsInteractionInited());
|
|
bool shouldActivate = m_ForceModuleActive || (m_framePressState != PointerEventData.FramePressState.NotChanged);
|
|
|
|
if (!shouldActivate && processCursorMovement && intManager &&
|
|
(intManager.IsLeftHandPrimary() || intManager.IsRightHandPrimary()))
|
|
{
|
|
bool bIsLeftHand = intManager.IsLeftHandPrimary();
|
|
|
|
// check for cursor pos change
|
|
Vector2 handCursorPos = bIsLeftHand ? intManager.GetLeftHandScreenPos() : intManager.GetRightHandScreenPos();
|
|
|
|
if (handCursorPos != m_lastCursorPos)
|
|
{
|
|
m_lastCursorPos = handCursorPos;
|
|
shouldActivate = true;
|
|
}
|
|
}
|
|
|
|
return shouldActivate;
|
|
}
|
|
|
|
// public override void ActivateModule()
|
|
// {
|
|
// base.ActivateModule();
|
|
//
|
|
// var toSelect = eventSystem.currentSelectedGameObject;
|
|
// if (toSelect == null)
|
|
// toSelect = eventSystem.firstSelectedGameObject;
|
|
//
|
|
// eventSystem.SetSelectedGameObject(toSelect, GetBaseEventData());
|
|
// }
|
|
|
|
// public override void DeactivateModule()
|
|
// {
|
|
// base.DeactivateModule();
|
|
// ClearSelection();
|
|
// }
|
|
|
|
public override void Process()
|
|
{
|
|
if (intManager == null)
|
|
{
|
|
intManager = InteractionManager.GetInstance(playerIndex, leftHandInteraction, rightHandInteraction);
|
|
}
|
|
|
|
CheckGrippedCursorPosition();
|
|
ProcessInteractionEvent();
|
|
}
|
|
|
|
private void CheckGrippedCursorPosition()
|
|
{
|
|
if (intManager)
|
|
{
|
|
bool bIsLeftHand = intManager.IsLeftHandPrimary();
|
|
|
|
// check for gripped hand
|
|
bool bHandGrip = bIsLeftHand ? m_leftHandGrip : m_rightHandGrip;
|
|
|
|
// check for cursor pos change
|
|
Vector2 handCursorPos = bIsLeftHand ? intManager.GetLeftHandScreenPos() : intManager.GetRightHandScreenPos();
|
|
|
|
if (bHandGrip && handCursorPos != (Vector2)m_handCursorPos)
|
|
{
|
|
// emulate new press
|
|
m_framePressState = PointerEventData.FramePressState.Pressed;
|
|
m_handCursorPos = handCursorPos;
|
|
}
|
|
else if (processCursorMovement)
|
|
{
|
|
m_handCursorPos = handCursorPos;
|
|
}
|
|
}
|
|
}
|
|
|
|
protected void ProcessInteractionEvent()
|
|
{
|
|
// Emulate mouse data
|
|
var mouseData = GetMousePointerEventData(0);
|
|
var leftButtonData = mouseData.GetButtonState(PointerEventData.InputButton.Left).eventData;
|
|
|
|
// Process the interaction data
|
|
ProcessHandPressRelease(leftButtonData);
|
|
ProcessMove(leftButtonData.buttonData);
|
|
ProcessDrag(leftButtonData.buttonData);
|
|
}
|
|
|
|
protected override MouseState GetMousePointerEventData(int id)
|
|
{
|
|
// Populate the left button...
|
|
PointerEventData leftData;
|
|
var created = GetPointerData(kMouseLeftId, out leftData, true);
|
|
|
|
leftData.Reset();
|
|
|
|
Vector2 handPos = new Vector2(m_handCursorPos.x * Screen.width, m_handCursorPos.y * Screen.height);
|
|
|
|
if (created)
|
|
{
|
|
leftData.position = handPos;
|
|
}
|
|
|
|
leftData.delta = handPos - leftData.position;
|
|
leftData.position = handPos;
|
|
//leftData.scrollDelta = 0f;
|
|
leftData.button = PointerEventData.InputButton.Left;
|
|
|
|
eventSystem.RaycastAll(leftData, m_RaycastResultCache);
|
|
var raycast = FindFirstRaycast(m_RaycastResultCache);
|
|
leftData.pointerCurrentRaycast = raycast;
|
|
m_RaycastResultCache.Clear();
|
|
|
|
m_MouseState.SetButtonState(PointerEventData.InputButton.Left, m_framePressState, leftData);
|
|
m_framePressState = PointerEventData.FramePressState.NotChanged;
|
|
|
|
return m_MouseState;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Process the current hand press or release event.
|
|
/// </summary>
|
|
protected void ProcessHandPressRelease(MouseButtonEventData data)
|
|
{
|
|
var pointerEvent = data.buttonData;
|
|
var currentOverGo = pointerEvent.pointerCurrentRaycast.gameObject;
|
|
|
|
// PointerDown notification
|
|
if (data.PressedThisFrame())
|
|
{
|
|
pointerEvent.eligibleForClick = true;
|
|
pointerEvent.delta = Vector2.zero;
|
|
pointerEvent.dragging = false;
|
|
pointerEvent.useDragThreshold = true;
|
|
pointerEvent.pressPosition = pointerEvent.position;
|
|
pointerEvent.pointerPressRaycast = pointerEvent.pointerCurrentRaycast;
|
|
|
|
DeselectIfSelectionChanged(currentOverGo, pointerEvent);
|
|
|
|
// search for the control that will receive the press
|
|
// if we can't find a press handler set the press
|
|
// handler to be what would receive a click.
|
|
var newPressed = ExecuteEvents.ExecuteHierarchy(currentOverGo, pointerEvent, ExecuteEvents.pointerDownHandler);
|
|
|
|
// didnt find a press handler... search for a click handler
|
|
if (newPressed == null)
|
|
newPressed = ExecuteEvents.GetEventHandler<IPointerClickHandler>(currentOverGo);
|
|
|
|
//Debug.Log("Pressed: " + newPressed);
|
|
|
|
float time = Time.unscaledTime;
|
|
|
|
if (newPressed == pointerEvent.lastPress)
|
|
{
|
|
var diffTime = time - pointerEvent.clickTime;
|
|
if (diffTime < 0.3f)
|
|
++pointerEvent.clickCount;
|
|
else
|
|
pointerEvent.clickCount = 1;
|
|
|
|
pointerEvent.clickTime = time;
|
|
}
|
|
else
|
|
{
|
|
pointerEvent.clickCount = 1;
|
|
}
|
|
|
|
pointerEvent.pointerPress = newPressed;
|
|
pointerEvent.rawPointerPress = currentOverGo;
|
|
|
|
pointerEvent.clickTime = time;
|
|
|
|
// Save the drag handler as well
|
|
pointerEvent.pointerDrag = ExecuteEvents.GetEventHandler<IDragHandler>(currentOverGo);
|
|
|
|
if (pointerEvent.pointerDrag != null)
|
|
ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.initializePotentialDrag);
|
|
}
|
|
|
|
// PointerUp notification
|
|
if (data.ReleasedThisFrame())
|
|
{
|
|
// Debug.Log("Executing pressup on: " + pointer.pointerPress);
|
|
ExecuteEvents.Execute(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerUpHandler);
|
|
|
|
// see if we mouse up on the same element that we clicked on...
|
|
var pointerUpHandler = ExecuteEvents.GetEventHandler<IPointerClickHandler>(currentOverGo);
|
|
|
|
// PointerClick and Drop events
|
|
if (pointerEvent.pointerPress != null && pointerEvent.pointerPress == pointerUpHandler && pointerEvent.eligibleForClick)
|
|
{
|
|
ExecuteEvents.Execute(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerClickHandler);
|
|
}
|
|
else if (pointerEvent.pointerDrag != null && pointerEvent.dragging)
|
|
{
|
|
ExecuteEvents.ExecuteHierarchy(currentOverGo, pointerEvent, ExecuteEvents.dropHandler);
|
|
}
|
|
|
|
pointerEvent.eligibleForClick = false;
|
|
pointerEvent.pointerPress = null;
|
|
pointerEvent.rawPointerPress = null;
|
|
|
|
if (pointerEvent.pointerDrag != null && pointerEvent.dragging)
|
|
ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.endDragHandler);
|
|
|
|
pointerEvent.dragging = false;
|
|
pointerEvent.pointerDrag = null;
|
|
|
|
// redo pointer enter / exit to refresh state
|
|
// so that if we moused over somethign that ignored it before
|
|
// due to having pressed on something else
|
|
// it now gets it.
|
|
if (currentOverGo != pointerEvent.pointerEnter)
|
|
{
|
|
HandlePointerExitAndEnter(pointerEvent, null);
|
|
HandlePointerExitAndEnter(pointerEvent, currentOverGo);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
public void HandGripDetected(ulong userId, int userIndex, bool isRightHand, bool isHandInteracting, Vector3 handScreenPos)
|
|
{
|
|
if (userIndex != playerIndex || !isHandInteracting)
|
|
return;
|
|
|
|
bool bHandValid = (leftHandInteraction && !isRightHand) || (rightHandInteraction && isRightHand);
|
|
if (!bHandValid)
|
|
return;
|
|
|
|
//Debug.Log("HandGripDetected");
|
|
|
|
m_framePressState = PointerEventData.FramePressState.Pressed;
|
|
//m_isLeftHand = !isRightHand;
|
|
m_handCursorPos = handScreenPos;
|
|
|
|
if (!isRightHand)
|
|
m_leftHandGrip = true;
|
|
else
|
|
m_rightHandGrip = true;
|
|
}
|
|
|
|
public void HandReleaseDetected(ulong userId, int userIndex, bool isRightHand, bool isHandInteracting, Vector3 handScreenPos)
|
|
{
|
|
if (userIndex != playerIndex || !isHandInteracting)
|
|
return;
|
|
|
|
bool bHandValid = (leftHandInteraction && !isRightHand) || (rightHandInteraction && isRightHand);
|
|
if (!bHandValid)
|
|
return;
|
|
|
|
//Debug.Log("HandReleaseDetected");
|
|
|
|
m_framePressState = PointerEventData.FramePressState.Released;
|
|
//m_isLeftHand = !isRightHand;
|
|
m_handCursorPos = handScreenPos;
|
|
|
|
if (!isRightHand)
|
|
m_leftHandGrip = false;
|
|
else
|
|
m_rightHandGrip = false;
|
|
}
|
|
|
|
public bool HandClickDetected(ulong userId, int userIndex, bool isRightHand, Vector3 handScreenPos)
|
|
{
|
|
if (userIndex != playerIndex)
|
|
return false;
|
|
|
|
bool bHandValid = (leftHandInteraction && !isRightHand) || (rightHandInteraction && isRightHand);
|
|
if (!bHandValid)
|
|
return false;
|
|
|
|
//Debug.Log("HandClickDetected");
|
|
|
|
StartCoroutine(EmulateMouseClick(isRightHand, handScreenPos));
|
|
return true;
|
|
}
|
|
|
|
|
|
private IEnumerator EmulateMouseClick(bool isRightHand, Vector3 handScreenPos)
|
|
{
|
|
m_framePressState = PointerEventData.FramePressState.Pressed;
|
|
//m_isLeftHand = !isRightHand;
|
|
m_handCursorPos = handScreenPos;
|
|
|
|
yield return new WaitForSeconds(0.2f);
|
|
|
|
m_framePressState = PointerEventData.FramePressState.Released;
|
|
//m_isLeftHand = !isRightHand;
|
|
m_handCursorPos = handScreenPos;
|
|
|
|
yield return null;
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
|