Cursor.cs

Go to the documentation of this file.

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See LICENSE in the project root for license information.

using UnityEngine;

namespace HoloToolkit.Unity.InputModule
{
    public abstract class Cursor : MonoBehaviour, ICursor
    {
        public CursorStateEnum CursorState { get { return cursorState; } }
        private CursorStateEnum cursorState = CursorStateEnum.None;

        [SerializeField]
        [Tooltip("Set this in the editor to an object with a component that implements IPointerSource to tell this cursor which pointer to follow. To set the pointer programmatically, set Pointer directly.")]
        protected GameObject LoadPointer;

        public IPointingSource Pointer
        {
            get { return pointer; }
            set
            {
                // This value is used to determine the cursor's default distance.
                // It is cached here to prevent repeated casting in the update loop.
                pointerIsInputSourcePointer = value is InputSourcePointer;
                pointer = value;
            }
        }
        private IPointingSource pointer;

        private bool pointerIsInputSourcePointer = false;

        [Header("Cursor Distance")]
        [Tooltip("The minimum distance the cursor can be with nothing hit")]
        public float MinCursorDistance = 1.0f;

        [Tooltip("The maximum distance the cursor can be with nothing hit")]
        public float DefaultCursorDistance = 2.0f;

        [Tooltip("The distance from the hit surface to place the cursor")]
        public float SurfaceCursorDistance = 0.02f;

        [Header("Motion")]
        [Tooltip("When lerping, use unscaled time. This is useful for games that have a pause mechanism or otherwise adjust the game timescale.")]
        public bool UseUnscaledTime = true;

        public float PositionLerpTime = 0.01f;

        public float ScaleLerpTime = 0.01f;

        public float RotationLerpTime = 0.01f;

        [Range(0, 1)]
        public float LookRotationBlend = 0.5f;

        [Header("Transform References")]
        public Transform PrimaryCursorVisual;

        public Vector3 Position
        {
            get { return transform.position; }
        }

        public Quaternion Rotation
        {
            get { return transform.rotation; }
        }

        public Vector3 LocalScale
        {
            get { return transform.localScale; }
        }

        protected bool IsHandVisible;

        protected bool IsInputSourceDown;

        protected GameObject TargetedObject;
        protected ICursorModifier TargetedCursorModifier;

        private uint visibleHandsCount = 0;

        [SerializeField]
        [Tooltip("Set this to specify if the Cursor should start visible or invisible in the scene.")]
        private bool isVisible = true;

        private Vector3 targetPosition;
        private Vector3 targetScale;
        private Quaternion targetRotation;

        private float originalDefaultCursorDistance;

        public bool IsVisible
        {
            set
            {
                isVisible = value;
                SetVisibility(isVisible);
            }
        }

        #region MonoBehaviour Functions

        protected virtual void Awake()
        {
            originalDefaultCursorDistance = DefaultCursorDistance;

            // Use the setter to update visibility of the cursor at startup based on user preferences
            IsVisible = isVisible;
        }

        protected virtual void Start()
        {
            RegisterManagers();
            TryLoadPointerIfNeeded();
        }

        protected virtual void Update()
        {
            UpdateCursorState();
            UpdateCursorTransform();
        }

        protected virtual void OnEnable()
        {
            if (FocusManager.IsInitialized && Pointer != null)
            {
                OnPointerSpecificFocusChanged(Pointer, null, FocusManager.Instance.GetFocusedObject(Pointer));
            }
            OnCursorStateChange(CursorStateEnum.None);
        }

        protected virtual void OnDisable()
        {
            TargetedObject = null;
            TargetedCursorModifier = null;
            visibleHandsCount = 0;
            IsHandVisible = false;
            OnCursorStateChange(CursorStateEnum.Contextual);
        }

        protected virtual void OnDestroy()
        {
            UnregisterManagers();
        }

        #endregion

        protected virtual void RegisterManagers()
        {
            // This accounts for any input sources that were detected before we register as a global listener below.
            visibleHandsCount = (uint)InputManager.Instance.DetectedInputSources.Count;
            IsHandVisible = visibleHandsCount > 0;

            // Register the cursor as a global listener, so that it can always get input events it cares about
            InputManager.Instance.AddGlobalListener(gameObject);

            // Setup the cursor to be able to respond to input being globally enabled / disabled
            if (InputManager.Instance.IsInputEnabled)
            {
                OnInputEnabled();
            }
            else
            {
                OnInputDisabled();
            }

            InputManager.Instance.InputEnabled += OnInputEnabled;
            InputManager.Instance.InputDisabled += OnInputDisabled;

            FocusManager.Instance.PointerSpecificFocusChanged += OnPointerSpecificFocusChanged;
        }

        protected virtual void UnregisterManagers()
        {
            if (InputManager.IsInitialized)
            {
                InputManager.Instance.InputEnabled -= OnInputEnabled;
                InputManager.Instance.InputDisabled -= OnInputDisabled;
                InputManager.Instance.RemoveGlobalListener(gameObject);
            }

            if (FocusManager.IsInitialized)
            {
                FocusManager.Instance.PointerSpecificFocusChanged -= OnPointerSpecificFocusChanged;
            }
        }

        private void TryLoadPointerIfNeeded()
        {
            if (Pointer != null)
            {
                // Nothing to do. Keep the pointer that must have been set programmatically.
            }
            else if (LoadPointer != null)
            {
                Pointer = LoadPointer.GetComponent<IPointingSource>();

                if (Pointer == null)
                {
                    Debug.LogErrorFormat("Load pointer object \"{0}\" is missing its {1} component.",
                        LoadPointer.name,
                        typeof(IPointingSource).Name
                        );
                }
            }
            else if (FocusManager.IsInitialized)
            {
                // For backward-compatibility, if a pointer wasn't specified, but there's exactly one
                // pointer currently registered with FocusManager, we use it.
                IPointingSource pointingSource;
                if (FocusManager.Instance.TryGetSinglePointer(out pointingSource))
                {
                    Pointer = pointingSource;
                }
            }
            else
            {
                // No options available, so we leave Pointer unset. It will need to be set programmatically later.
            }
        }

        protected virtual void OnPointerSpecificFocusChanged(IPointingSource pointer, GameObject oldFocusedObject, GameObject newFocusedObject)
        {
            if (pointer == Pointer)
            {
                TargetedObject = newFocusedObject;

                CursorModifier newModifier = (newFocusedObject == null)
                    ? null
                    : newFocusedObject.GetComponent<CursorModifier>();

                OnActiveModifier(newModifier);
            }
        }

        protected virtual void OnActiveModifier(CursorModifier modifier)
        {
            TargetedCursorModifier = modifier;
        }

        protected virtual void UpdateCursorTransform()
        {
            FocusDetails focusDetails = FocusManager.Instance.GetFocusDetails(Pointer);
            GameObject newTargetedObject = focusDetails.Object;
            Vector3 lookForward = Vector3.forward;

            // Normalize scale on before update
            targetScale = Vector3.one;

            // If no game object is hit, put the cursor at the default distance
            if (newTargetedObject == null)
            {
                TargetedObject = null;
                TargetedCursorModifier = null;

                if (pointerIsInputSourcePointer)
                {
                    // This value get re-queried every update, in case the app has
                    // changed the pointing extent of the pointer for the current scenario.
                    float distance = FocusManager.Instance.GetPointingExtent(Pointer);
                    if (DefaultCursorDistance != distance)
                    {
                        DefaultCursorDistance = distance;
                    }
                }
                else if (DefaultCursorDistance != originalDefaultCursorDistance)
                {
                    DefaultCursorDistance = originalDefaultCursorDistance;
                }

                targetPosition = RayStep.GetPointByDistance(Pointer.Rays, DefaultCursorDistance);
                lookForward = -RayStep.GetDirectionByDistance(Pointer.Rays, DefaultCursorDistance);
                targetRotation = lookForward.magnitude > 0 ? Quaternion.LookRotation(lookForward, Vector3.up) : transform.rotation;
            }
            else
            {
                // Update currently targeted object
                TargetedObject = newTargetedObject;

                if (TargetedCursorModifier != null)
                {
                    TargetedCursorModifier.GetModifiedTransform(this, out targetPosition, out targetRotation, out targetScale);
                }
                else
                {
                    // If no modifier is on the target, just use the hit result to set cursor position
                    // Get the look forward by using distance between pointer origin and target position
                    // (This may not be strictly accurate for extremely wobbly pointers, but it should produce usable results)
                    float distanceToTarget = Vector3.Distance(Pointer.Rays[0].Origin, focusDetails.Point);
                    lookForward = -RayStep.GetDirectionByDistance(Pointer.Rays, distanceToTarget);
                    targetPosition = focusDetails.Point + (lookForward * SurfaceCursorDistance);
                    Vector3 lookRotation = Vector3.Slerp(focusDetails.Normal, lookForward, LookRotationBlend);
                    targetRotation = Quaternion.LookRotation(lookRotation == Vector3.zero ? lookForward : lookRotation, Vector3.up);
                }
            }

            float deltaTime = UseUnscaledTime
                ? Time.unscaledDeltaTime
                : Time.deltaTime;

            // Use the lerp times to blend the position to the target position
            transform.position = Vector3.Lerp(transform.position, targetPosition, deltaTime / PositionLerpTime);
            transform.localScale = Vector3.Lerp(transform.localScale, targetScale, deltaTime / ScaleLerpTime);
            transform.rotation = Quaternion.Lerp(transform.rotation, targetRotation, deltaTime / RotationLerpTime);
        }

        public virtual void SetVisibility(bool visible)
        {
            if (PrimaryCursorVisual != null)
            {
                PrimaryCursorVisual.gameObject.SetActive(visible);
            }
        }

        public virtual void OnInputDisabled()
        {
            // Reset visible hands on disable
            visibleHandsCount = 0;
            IsHandVisible = false;

            OnCursorStateChange(CursorStateEnum.Contextual);
        }

        public virtual void OnInputEnabled()
        {
            OnCursorStateChange(CursorStateEnum.None);
        }

        public virtual void OnInputUp(InputEventData eventData)
        {
            if (Pointer != null && Pointer.OwnsInput(eventData))
            {
                IsInputSourceDown = false;
            }
        }

        public virtual void OnInputDown(InputEventData eventData)
        {
            if (Pointer != null && Pointer.OwnsInput(eventData))
            {
                IsInputSourceDown = true;
            }
        }

        public virtual void OnInputClicked(InputClickedEventData eventData)
        {
            // Open input socket for other cool stuff...
        }


        public virtual void OnSourceDetected(SourceStateEventData eventData)
        {
            if (Pointer != null && Pointer.OwnsInput(eventData))
            {
                visibleHandsCount++;
                IsHandVisible = true;
            }
        }


        public virtual void OnSourceLost(SourceStateEventData eventData)
        {
            if (Pointer != null && Pointer.OwnsInput(eventData))
            {
                visibleHandsCount--;
                if (visibleHandsCount == 0)
                {
                    IsHandVisible = false;
                    IsInputSourceDown = false;
                }
            }
        }

        private void UpdateCursorState()
        {
            CursorStateEnum newState = CheckCursorState();
            if (cursorState != newState)
            {
                OnCursorStateChange(newState);
            }
        }

        public virtual CursorStateEnum CheckCursorState()
        {
            if (cursorState != CursorStateEnum.Contextual)
            {
                if (IsInputSourceDown)
                {
                    return CursorStateEnum.Select;
                }
                else if (cursorState == CursorStateEnum.Select)
                {
                    return CursorStateEnum.Release;
                }

                if (IsHandVisible)
                {
                    return TargetedObject != null ? CursorStateEnum.InteractHover : CursorStateEnum.Interact;
                }
                return TargetedObject != null ? CursorStateEnum.ObserveHover : CursorStateEnum.Observe;
            }
            return CursorStateEnum.Contextual;
        }

        public virtual void OnCursorStateChange(CursorStateEnum state)
        {
            cursorState = state;
        }
    }
}