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.
504 lines
19 KiB
504 lines
19 KiB
// Panel Menu|Prefabs|0130
|
|
namespace VRTK
|
|
{
|
|
using System.Collections;
|
|
using UnityEngine;
|
|
|
|
/// <summary>
|
|
/// Adds a top-level controller to handle the display of up to four child PanelMenuItemController items which are displayed as a canvas UI panel.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// **Prefab Usage:**
|
|
/// * Place the `VRTK/Prefabs/PanelMenu/PanelMenu` prefab as a child of the `VRTK_InteractableObject` the panel menu is for.
|
|
/// * Optionally remove the panel control menu item child GameObjects if they are not required, e.g. `PanelTopControls`.
|
|
/// * Set the panel menu item controllers on the `VRTK_PanelMenuController` script to determine which panel control menu items are available.
|
|
/// * The available panel control menu items can be activated by pressing the corresponding direction on the touchpad.
|
|
/// </remarks>
|
|
/// <example>
|
|
/// `040_Controls_Panel_Menu` contains three basic interactive object examples of the PanelMenu in use.
|
|
/// </example>
|
|
public class VRTK_PanelMenuController : MonoBehaviour
|
|
{
|
|
public enum TouchpadPressPosition
|
|
{
|
|
None,
|
|
Top,
|
|
Bottom,
|
|
Left,
|
|
Right
|
|
}
|
|
|
|
[Tooltip("The GameObject the panel should rotate towards, which is the Camera (eye) by default.")]
|
|
public GameObject rotateTowards;
|
|
[Tooltip("The scale multiplier, which relates to the scale of parent interactable object.")]
|
|
public float zoomScaleMultiplier = 1f;
|
|
[Tooltip("The top PanelMenuItemController, which is triggered by pressing up on the controller touchpad.")]
|
|
public VRTK_PanelMenuItemController topPanelMenuItemController;
|
|
[Tooltip("The bottom PanelMenuItemController, which is triggered by pressing down on the controller touchpad.")]
|
|
public VRTK_PanelMenuItemController bottomPanelMenuItemController;
|
|
[Tooltip("The left PanelMenuItemController, which is triggered by pressing left on the controller touchpad.")]
|
|
public VRTK_PanelMenuItemController leftPanelMenuItemController;
|
|
[Tooltip("The right PanelMenuItemController, which is triggered by pressing right on the controller touchpad.")]
|
|
public VRTK_PanelMenuItemController rightPanelMenuItemController;
|
|
|
|
// Relates to scale of canvas on panel items.
|
|
protected const float CanvasScaleSize = 0.001f;
|
|
|
|
// Swipe sensitivity / detection.
|
|
protected const float AngleTolerance = 30f;
|
|
protected const float SwipeMinDist = 0.2f;
|
|
protected const float SwipeMinVelocity = 4.0f;
|
|
|
|
protected VRTK_ControllerEvents controllerEvents;
|
|
protected VRTK_PanelMenuItemController currentPanelMenuItemController;
|
|
protected GameObject interactableObject;
|
|
protected GameObject canvasObject;
|
|
protected readonly Vector2 xAxis = new Vector2(1, 0);
|
|
protected readonly Vector2 yAxis = new Vector2(0, 1);
|
|
protected Vector2 touchStartPosition;
|
|
protected Vector2 touchEndPosition;
|
|
protected float touchStartTime;
|
|
protected float currentAngle;
|
|
protected bool isTrackingSwipe = false;
|
|
protected bool isPendingSwipeCheck = false;
|
|
protected bool isGrabbed = false;
|
|
protected bool isShown = false;
|
|
protected Coroutine tweenMenuScaleRoutine;
|
|
|
|
/// <summary>
|
|
/// The ToggleMenu method is used to show or hide the menu.
|
|
/// </summary>
|
|
public virtual void ToggleMenu()
|
|
{
|
|
if (isShown)
|
|
{
|
|
HideMenu(true);
|
|
}
|
|
else
|
|
{
|
|
ShowMenu();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The ShowMenu method is used to show the menu.
|
|
/// </summary>
|
|
public virtual void ShowMenu()
|
|
{
|
|
if (!isShown)
|
|
{
|
|
isShown = true;
|
|
InitTweenMenuScale(isShown);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The HideMenu method is used to hide the menu.
|
|
/// </summary>
|
|
/// <param name="force">If true then the menu is always hidden.</param>
|
|
public virtual void HideMenu(bool force)
|
|
{
|
|
if (isShown && force)
|
|
{
|
|
isShown = false;
|
|
InitTweenMenuScale(isShown);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The HideMenuImmediate method is used to immediately hide the menu.
|
|
/// </summary>
|
|
public virtual void HideMenuImmediate()
|
|
{
|
|
if (currentPanelMenuItemController != null && isShown)
|
|
{
|
|
HandlePanelMenuItemControllerVisibility(currentPanelMenuItemController);
|
|
}
|
|
transform.localScale = Vector3.zero;
|
|
canvasObject.transform.localScale = Vector3.zero;
|
|
isShown = false;
|
|
}
|
|
|
|
protected virtual void Awake()
|
|
{
|
|
Initialize();
|
|
VRTK_SDKManager.AttemptAddBehaviourToToggleOnLoadedSetupChange(this);
|
|
}
|
|
|
|
protected virtual void Start()
|
|
{
|
|
interactableObject = gameObject.transform.parent.gameObject;
|
|
if (interactableObject == null || interactableObject.GetComponent<VRTK_InteractableObject>() == null)
|
|
{
|
|
VRTK_Logger.Warn(VRTK_Logger.GetCommonMessage(VRTK_Logger.CommonMessageKeys.REQUIRED_COMPONENT_MISSING_FROM_GAMEOBJECT, "PanelMenuController", "VRTK_InteractableObject", "a parent"));
|
|
return;
|
|
}
|
|
|
|
interactableObject.GetComponent<VRTK_InteractableObject>().InteractableObjectGrabbed += new InteractableObjectEventHandler(DoInteractableObjectIsGrabbed);
|
|
interactableObject.GetComponent<VRTK_InteractableObject>().InteractableObjectUngrabbed += new InteractableObjectEventHandler(DoInteractableObjectIsUngrabbed);
|
|
|
|
canvasObject = gameObject.transform.GetChild(0).gameObject;
|
|
if (canvasObject == null || canvasObject.GetComponent<Canvas>() == null)
|
|
{
|
|
VRTK_Logger.Warn(VRTK_Logger.GetCommonMessage(VRTK_Logger.CommonMessageKeys.REQUIRED_COMPONENT_MISSING_FROM_GAMEOBJECT, "PanelMenuController", "Canvas", "a child"));
|
|
}
|
|
}
|
|
|
|
protected virtual void OnDestroy()
|
|
{
|
|
VRTK_SDKManager.AttemptRemoveBehaviourToToggleOnLoadedSetupChange(this);
|
|
}
|
|
|
|
protected virtual void Update()
|
|
{
|
|
if (interactableObject != null)
|
|
{
|
|
if (rotateTowards == null)
|
|
{
|
|
rotateTowards = VRTK_DeviceFinder.HeadsetTransform().gameObject;
|
|
if (rotateTowards == null)
|
|
{
|
|
VRTK_Logger.Warn(VRTK_Logger.GetCommonMessage(VRTK_Logger.CommonMessageKeys.COULD_NOT_FIND_OBJECT_FOR_ACTION, "PanelMenuController", "an object", "rotate towards"));
|
|
}
|
|
}
|
|
|
|
if (isShown)
|
|
{
|
|
if (rotateTowards != null)
|
|
{
|
|
transform.rotation = Quaternion.LookRotation((rotateTowards.transform.position - transform.position) * -1, Vector3.up);
|
|
}
|
|
}
|
|
|
|
if (isPendingSwipeCheck)
|
|
{
|
|
CalculateSwipeAction();
|
|
}
|
|
}
|
|
}
|
|
|
|
protected virtual void Initialize()
|
|
{
|
|
if (Application.isPlaying)
|
|
{
|
|
if (!isShown)
|
|
{
|
|
transform.localScale = Vector3.zero;
|
|
}
|
|
}
|
|
|
|
if (controllerEvents == null)
|
|
{
|
|
transform.localPosition = new Vector3(transform.localPosition.x, transform.localPosition.y, transform.localPosition.z);
|
|
controllerEvents = GetComponentInParent<VRTK_ControllerEvents>();
|
|
}
|
|
}
|
|
|
|
protected virtual void BindControllerEvents()
|
|
{
|
|
controllerEvents.TouchpadPressed += new ControllerInteractionEventHandler(DoTouchpadPress);
|
|
controllerEvents.TouchpadTouchStart += new ControllerInteractionEventHandler(DoTouchpadTouched);
|
|
controllerEvents.TouchpadTouchEnd += new ControllerInteractionEventHandler(DoTouchpadUntouched);
|
|
controllerEvents.TouchpadAxisChanged += new ControllerInteractionEventHandler(DoTouchpadAxisChanged);
|
|
controllerEvents.TriggerPressed += new ControllerInteractionEventHandler(DoTriggerPressed);
|
|
}
|
|
|
|
protected virtual void UnbindControllerEvents()
|
|
{
|
|
controllerEvents.TouchpadPressed -= new ControllerInteractionEventHandler(DoTouchpadPress);
|
|
controllerEvents.TouchpadTouchStart -= new ControllerInteractionEventHandler(DoTouchpadTouched);
|
|
controllerEvents.TouchpadTouchEnd -= new ControllerInteractionEventHandler(DoTouchpadUntouched);
|
|
controllerEvents.TouchpadAxisChanged -= new ControllerInteractionEventHandler(DoTouchpadAxisChanged);
|
|
controllerEvents.TriggerPressed -= new ControllerInteractionEventHandler(DoTriggerPressed);
|
|
}
|
|
|
|
protected virtual void HandlePanelMenuItemControllerVisibility(VRTK_PanelMenuItemController targetPanelItemController)
|
|
{
|
|
if (isShown)
|
|
{
|
|
if (currentPanelMenuItemController == targetPanelItemController)
|
|
{
|
|
targetPanelItemController.Hide(interactableObject);
|
|
currentPanelMenuItemController = null;
|
|
HideMenu(true);
|
|
}
|
|
else
|
|
{
|
|
currentPanelMenuItemController.Hide(interactableObject);
|
|
currentPanelMenuItemController = targetPanelItemController;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
currentPanelMenuItemController = targetPanelItemController;
|
|
}
|
|
|
|
if (currentPanelMenuItemController != null)
|
|
{
|
|
currentPanelMenuItemController.Show(interactableObject);
|
|
ShowMenu();
|
|
}
|
|
}
|
|
|
|
protected virtual void InitTweenMenuScale(bool show)
|
|
{
|
|
if (tweenMenuScaleRoutine != null)
|
|
{
|
|
StopCoroutine(tweenMenuScaleRoutine);
|
|
}
|
|
if (enabled)
|
|
{
|
|
tweenMenuScaleRoutine = StartCoroutine(TweenMenuScale(show));
|
|
}
|
|
}
|
|
|
|
protected virtual IEnumerator TweenMenuScale(bool show)
|
|
{
|
|
float targetScale = 0;
|
|
Vector3 direction = -1 * Vector3.one;
|
|
if (show)
|
|
{
|
|
canvasObject.transform.localScale = new Vector3(CanvasScaleSize, CanvasScaleSize, CanvasScaleSize);
|
|
targetScale = zoomScaleMultiplier;
|
|
direction = Vector3.one;
|
|
}
|
|
int i = 0;
|
|
while (i < 250 && ((show && transform.localScale.x < targetScale) || (!show && transform.localScale.x > targetScale)))
|
|
{
|
|
transform.localScale += direction * Time.deltaTime * 4f * zoomScaleMultiplier;
|
|
yield return true;
|
|
i++;
|
|
}
|
|
transform.localScale = direction * targetScale;
|
|
|
|
if (!show)
|
|
{
|
|
canvasObject.transform.localScale = Vector3.zero;
|
|
}
|
|
}
|
|
|
|
protected virtual void DoInteractableObjectIsGrabbed(object sender, InteractableObjectEventArgs e)
|
|
{
|
|
controllerEvents = e.interactingObject.GetComponentInParent<VRTK_ControllerEvents>();
|
|
if (controllerEvents != null)
|
|
{
|
|
BindControllerEvents();
|
|
}
|
|
isGrabbed = true;
|
|
}
|
|
|
|
protected virtual void DoInteractableObjectIsUngrabbed(object sender, InteractableObjectEventArgs e)
|
|
{
|
|
isGrabbed = false;
|
|
if (isShown)
|
|
{
|
|
HideMenuImmediate();
|
|
}
|
|
|
|
if (controllerEvents != null)
|
|
{
|
|
UnbindControllerEvents();
|
|
controllerEvents = null;
|
|
}
|
|
}
|
|
|
|
protected virtual void DoTouchpadPress(object sender, ControllerInteractionEventArgs e)
|
|
{
|
|
if (isGrabbed)
|
|
{
|
|
TouchpadPressPosition pressPosition = CalculateTouchpadPressPosition();
|
|
switch (pressPosition)
|
|
{
|
|
case TouchpadPressPosition.Top:
|
|
if (topPanelMenuItemController != null)
|
|
{
|
|
HandlePanelMenuItemControllerVisibility(topPanelMenuItemController);
|
|
}
|
|
break;
|
|
|
|
case TouchpadPressPosition.Bottom:
|
|
if (bottomPanelMenuItemController != null)
|
|
{
|
|
HandlePanelMenuItemControllerVisibility(bottomPanelMenuItemController);
|
|
}
|
|
break;
|
|
|
|
case TouchpadPressPosition.Left:
|
|
if (leftPanelMenuItemController != null)
|
|
{
|
|
HandlePanelMenuItemControllerVisibility(leftPanelMenuItemController);
|
|
}
|
|
break;
|
|
|
|
case TouchpadPressPosition.Right:
|
|
if (rightPanelMenuItemController != null)
|
|
{
|
|
HandlePanelMenuItemControllerVisibility(rightPanelMenuItemController);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
protected virtual void DoTouchpadTouched(object sender, ControllerInteractionEventArgs e)
|
|
{
|
|
touchStartPosition = new Vector2(e.touchpadAxis.x, e.touchpadAxis.y);
|
|
touchStartTime = Time.time;
|
|
isTrackingSwipe = true;
|
|
}
|
|
|
|
protected virtual void DoTouchpadUntouched(object sender, ControllerInteractionEventArgs e)
|
|
{
|
|
isTrackingSwipe = false;
|
|
isPendingSwipeCheck = true;
|
|
}
|
|
|
|
protected virtual void DoTouchpadAxisChanged(object sender, ControllerInteractionEventArgs e)
|
|
{
|
|
ChangeAngle(CalculateAngle(e));
|
|
|
|
if (isTrackingSwipe)
|
|
{
|
|
touchEndPosition = new Vector2(e.touchpadAxis.x, e.touchpadAxis.y);
|
|
}
|
|
}
|
|
|
|
protected virtual void DoTriggerPressed(object sender, ControllerInteractionEventArgs e)
|
|
{
|
|
if (isGrabbed)
|
|
{
|
|
OnTriggerPressed();
|
|
}
|
|
}
|
|
|
|
protected virtual void ChangeAngle(float angle, object sender = null)
|
|
{
|
|
currentAngle = angle;
|
|
}
|
|
|
|
protected virtual void CalculateSwipeAction()
|
|
{
|
|
isPendingSwipeCheck = false;
|
|
|
|
float deltaTime = Time.time - touchStartTime;
|
|
Vector2 swipeVector = touchEndPosition - touchStartPosition;
|
|
float velocity = swipeVector.magnitude / deltaTime;
|
|
|
|
if ((velocity > SwipeMinVelocity) && (swipeVector.magnitude > SwipeMinDist))
|
|
{
|
|
swipeVector.Normalize();
|
|
float angleOfSwipe = Vector2.Dot(swipeVector, xAxis);
|
|
angleOfSwipe = Mathf.Acos(angleOfSwipe) * Mathf.Rad2Deg;
|
|
|
|
// Left / right
|
|
if (angleOfSwipe < AngleTolerance)
|
|
{
|
|
OnSwipeRight();
|
|
}
|
|
else if ((180.0f - angleOfSwipe) < AngleTolerance)
|
|
{
|
|
OnSwipeLeft();
|
|
}
|
|
else
|
|
{
|
|
// Top / bottom
|
|
angleOfSwipe = Vector2.Dot(swipeVector, yAxis);
|
|
angleOfSwipe = Mathf.Acos(angleOfSwipe) * Mathf.Rad2Deg;
|
|
if (angleOfSwipe < AngleTolerance)
|
|
{
|
|
OnSwipeTop();
|
|
}
|
|
else if ((180.0f - angleOfSwipe) < AngleTolerance)
|
|
{
|
|
OnSwipeBottom();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
protected virtual TouchpadPressPosition CalculateTouchpadPressPosition()
|
|
{
|
|
if (CheckAnglePosition(currentAngle, AngleTolerance, 0))
|
|
{
|
|
return TouchpadPressPosition.Top;
|
|
}
|
|
else if (CheckAnglePosition(currentAngle, AngleTolerance, 180))
|
|
{
|
|
return TouchpadPressPosition.Bottom;
|
|
}
|
|
else if (CheckAnglePosition(currentAngle, AngleTolerance, 270))
|
|
{
|
|
return TouchpadPressPosition.Left;
|
|
}
|
|
else if (CheckAnglePosition(currentAngle, AngleTolerance, 90))
|
|
{
|
|
return TouchpadPressPosition.Right;
|
|
}
|
|
|
|
return TouchpadPressPosition.None;
|
|
}
|
|
|
|
protected virtual void OnSwipeLeft()
|
|
{
|
|
if (currentPanelMenuItemController != null)
|
|
{
|
|
currentPanelMenuItemController.SwipeLeft(interactableObject);
|
|
}
|
|
}
|
|
|
|
protected virtual void OnSwipeRight()
|
|
{
|
|
if (currentPanelMenuItemController != null)
|
|
{
|
|
currentPanelMenuItemController.SwipeRight(interactableObject);
|
|
}
|
|
}
|
|
|
|
protected virtual void OnSwipeTop()
|
|
{
|
|
if (currentPanelMenuItemController != null)
|
|
{
|
|
currentPanelMenuItemController.SwipeTop(interactableObject);
|
|
}
|
|
}
|
|
|
|
protected virtual void OnSwipeBottom()
|
|
{
|
|
if (currentPanelMenuItemController != null)
|
|
{
|
|
currentPanelMenuItemController.SwipeBottom(interactableObject);
|
|
}
|
|
}
|
|
|
|
protected virtual void OnTriggerPressed()
|
|
{
|
|
if (currentPanelMenuItemController != null)
|
|
{
|
|
currentPanelMenuItemController.TriggerPressed(interactableObject);
|
|
}
|
|
}
|
|
|
|
protected virtual float CalculateAngle(ControllerInteractionEventArgs e)
|
|
{
|
|
return e.touchpadAngle;
|
|
}
|
|
|
|
protected virtual float NormAngle(float currentDegree, float maxAngle = 360)
|
|
{
|
|
if (currentDegree < 0) currentDegree = currentDegree + maxAngle;
|
|
return currentDegree % maxAngle;
|
|
}
|
|
|
|
protected virtual bool CheckAnglePosition(float currentDegree, float tolerance, float targetDegree)
|
|
{
|
|
float lowerBound = NormAngle(currentDegree - tolerance);
|
|
float upperBound = NormAngle(currentDegree + tolerance);
|
|
|
|
if (lowerBound > upperBound)
|
|
{
|
|
return targetDegree >= lowerBound || targetDegree <= upperBound;
|
|
}
|
|
return targetDegree >= lowerBound && targetDegree <= upperBound;
|
|
}
|
|
}
|
|
}
|