//======= Copyright (c) Valve Corporation, All rights reserved. ===============
//
// Purpose: The hands used by the player in the vr interaction system
//
//=============================================================================

using UnityEngine;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;

namespace Valve.VR.InteractionSystem
{
    //-------------------------------------------------------------------------
    // Links with an appropriate SteamVR controller and facilitates
    // interactions with objects in the virtual world.
    //-------------------------------------------------------------------------
    public class Hand : MonoBehaviour
    {
        public enum HandType
        {
            Left,
            Right,
            Any
        };

        // The flags used to determine how an object is attached to the hand.
        [Flags]
        public enum AttachmentFlags
        {
            SnapOnAttach = 1 << 0, // The object should snap to the position of the specified attachment point on the hand.
            DetachOthers = 1 << 1, // Other objects attached to this hand will be detached.
            DetachFromOtherHand = 1 << 2, // This object will be detached from the other hand.
            ParentToHand = 1 << 3, // The object will be parented to the hand.
        };

        public const AttachmentFlags defaultAttachmentFlags = AttachmentFlags.ParentToHand |
                                                              AttachmentFlags.DetachOthers |
                                                              AttachmentFlags.DetachFromOtherHand |
                                                              AttachmentFlags.SnapOnAttach;

        public Hand otherHand;
        public HandType startingHandType;

        public Transform hoverSphereTransform;
        public float hoverSphereRadius = 0.05f;
        public LayerMask hoverLayerMask = -1;
        public float hoverUpdateInterval = 0.1f;

        public Camera noSteamVRFallbackCamera;
        public float noSteamVRFallbackMaxDistanceNoItem = 10.0f;
        public float noSteamVRFallbackMaxDistanceWithItem = 0.5f;
        private float noSteamVRFallbackInteractorDistance = -1.0f;

        public SteamVR_Controller.Device controller;

        public GameObject controllerPrefab;
        private GameObject controllerObject = null;

        public bool showDebugText = false;
        public bool spewDebugText = false;

        public struct AttachedObject
        {
            public GameObject attachedObject;
            public GameObject originalParent;
            public bool isParentedToHand;
        }

        private List<AttachedObject> attachedObjects = new List<AttachedObject>();

        public ReadOnlyCollection<AttachedObject> AttachedObjects
        {
            get { return attachedObjects.AsReadOnly(); }
        }

        public bool hoverLocked { get; private set; }

        private Interactable _hoveringInteractable;

        private TextMesh debugText;
        private int prevOverlappingColliders = 0;

        private const int ColliderArraySize = 16;
        private Collider[] overlappingColliders;

        private Player playerInstance;

        private GameObject applicationLostFocusObject;

        SteamVR_Events.Action inputFocusAction;

        private SteamVR_Controller.Device c { get { return SteamVR_Controller.Input((int)ControllerTracked.index); } } // games we played wuz here
        [HideInInspector]
        public Valve.VR.EVRButtonId trigger = Valve.VR.EVRButtonId.k_EButton_SteamVR_Trigger; // Trigger
        [HideInInspector]
        private Valve.VR.EVRButtonId grip = Valve.VR.EVRButtonId.k_EButton_Grip; // Grip
        private SteamVR_TrackedObject ControllerTracked;

        //-------------------------------------------------
        // The Interactable object this Hand is currently hovering over
        //-------------------------------------------------
        public Interactable hoveringInteractable
        {
            get { return _hoveringInteractable; }
            set
            {
                if ( _hoveringInteractable != value )
                {
                    if ( _hoveringInteractable != null )
                    {
                        HandDebugLog( "HoverEnd " + _hoveringInteractable.gameObject );
                        _hoveringInteractable.SendMessage( "OnHandHoverEnd", this, SendMessageOptions.DontRequireReceiver );

                        //Note: The _hoveringInteractable can change after sending the OnHandHoverEnd message so we need to check it again before broadcasting this message
                        if ( _hoveringInteractable != null )
                        {
                            this.BroadcastMessage( "OnParentHandHoverEnd", _hoveringInteractable, SendMessageOptions.DontRequireReceiver ); // let objects attached to the hand know that a hover has ended
                        }
                    }

                    _hoveringInteractable = value;

                    if ( _hoveringInteractable != null )
                    {
                        HandDebugLog( "HoverBegin " + _hoveringInteractable.gameObject );
                        _hoveringInteractable.SendMessage( "OnHandHoverBegin", this, SendMessageOptions.DontRequireReceiver );

                        //Note: The _hoveringInteractable can change after sending the OnHandHoverBegin message so we need to check it again before broadcasting this message
                        if ( _hoveringInteractable != null )
                        {
                            this.BroadcastMessage( "OnParentHandHoverBegin", _hoveringInteractable, SendMessageOptions.DontRequireReceiver ); // let objects attached to the hand know that a hover has begun
                        }
                    }
                }
            }
        }


        //-------------------------------------------------
        // Active GameObject attached to this Hand
        //-------------------------------------------------
        public GameObject currentAttachedObject
        {
            get
            {
                CleanUpAttachedObjectStack();

                if ( attachedObjects.Count > 0 )
                {
                    return attachedObjects[attachedObjects.Count - 1].attachedObject;
                }

                return null;
            }
        }


        //-------------------------------------------------
        public Transform GetAttachmentTransform( string attachmentPoint = "" )
        {
            Transform attachmentTransform = null;

            if ( !string.IsNullOrEmpty( attachmentPoint ) )
            {
                attachmentTransform = transform.Find( attachmentPoint );
            }

            if ( !attachmentTransform )
            {
                attachmentTransform = this.transform;
            }

            return attachmentTransform;
        }


        //-------------------------------------------------
        // Guess the type of this Hand
        //
        // If startingHandType is Hand.Left or Hand.Right, returns startingHandType.
        // If otherHand is non-null and both Hands are linked to controllers, returns
        // Hand.Left if this Hand is leftmost relative to the HMD, otherwise Hand.Right.
        // Otherwise, returns Hand.Any
        //-------------------------------------------------
        public HandType GuessCurrentHandType()
        {
            if ( startingHandType == HandType.Left || startingHandType == HandType.Right )
            {
                return startingHandType;
            }

            if ( startingHandType == HandType.Any && otherHand != null && otherHand.controller == null )
            {
                return HandType.Right;
            }

            if ( controller == null || otherHand == null || otherHand.controller == null )
            {
                return startingHandType;
            }

            if ( controller.index == SteamVR_Controller.GetDeviceIndex( SteamVR_Controller.DeviceRelation.Leftmost ) )
            {
                return HandType.Left;
            }

            return HandType.Right;
        }


        //-------------------------------------------------
        // Attach a GameObject to this GameObject
        //
        // objectToAttach - The GameObject to attach
        // flags - The flags to use for attaching the object
        // attachmentPoint - Name of the GameObject in the hierarchy of this Hand which should act as the attachment point for this GameObject
        //-------------------------------------------------
        public void AttachObject( GameObject objectToAttach, AttachmentFlags flags = defaultAttachmentFlags, string attachmentPoint = "" )
        {
            if ( flags == 0 )
            {
                flags = defaultAttachmentFlags;
            }

            //Make sure top object on stack is non-null
            CleanUpAttachedObjectStack();

            //Detach the object if it is already attached so that it can get re-attached at the top of the stack
            DetachObject( objectToAttach );

            //Detach from the other hand if requested
            if ( ( ( flags & AttachmentFlags.DetachFromOtherHand ) == AttachmentFlags.DetachFromOtherHand ) && otherHand )
            {
                otherHand.DetachObject( objectToAttach );
            }

            if ( ( flags & AttachmentFlags.DetachOthers ) == AttachmentFlags.DetachOthers )
            {
                //Detach all the objects from the stack
                while ( attachedObjects.Count > 0 )
                {
                    DetachObject( attachedObjects[0].attachedObject );
                }
            }

            if ( currentAttachedObject )
            {
                currentAttachedObject.SendMessage( "OnHandFocusLost", this, SendMessageOptions.DontRequireReceiver );
            }

            AttachedObject attachedObject = new AttachedObject();
            attachedObject.attachedObject = objectToAttach;
            attachedObject.originalParent = objectToAttach.transform.parent != null ? objectToAttach.transform.parent.gameObject : null;
            if ( ( flags & AttachmentFlags.ParentToHand ) == AttachmentFlags.ParentToHand )
            {
                //Parent the object to the hand
                objectToAttach.transform.parent = GetAttachmentTransform( attachmentPoint );
                attachedObject.isParentedToHand = true;
            }
            else
            {
                attachedObject.isParentedToHand = false;
            }
            attachedObjects.Add( attachedObject );

            if ( ( flags & AttachmentFlags.SnapOnAttach ) == AttachmentFlags.SnapOnAttach )
            {
                objectToAttach.transform.localPosition = Vector3.zero;
                objectToAttach.transform.localRotation = Quaternion.identity;
            }

            HandDebugLog( "AttachObject " + objectToAttach );
            objectToAttach.SendMessage( "OnAttachedToHand", this, SendMessageOptions.DontRequireReceiver );

            UpdateHovering();
        }


        //-------------------------------------------------
        // Detach this GameObject from the attached object stack of this Hand
        //
        // objectToDetach - The GameObject to detach from this Hand
        //-------------------------------------------------
        public void DetachObject( GameObject objectToDetach, bool restoreOriginalParent = true )
        {
            int index = attachedObjects.FindIndex( l => l.attachedObject == objectToDetach );
            if ( index != -1 )
            {
                HandDebugLog( "DetachObject " + objectToDetach );

                GameObject prevTopObject = currentAttachedObject;

                Transform parentTransform = null;
                if ( attachedObjects[index].isParentedToHand )
                {
                    if ( restoreOriginalParent && ( attachedObjects[index].originalParent != null ) )
                    {
                        parentTransform = attachedObjects[index].originalParent.transform;
                    }
                    attachedObjects[index].attachedObject.transform.parent = parentTransform;
                }

                attachedObjects[index].attachedObject.SetActive( true );
                attachedObjects[index].attachedObject.SendMessage( "OnDetachedFromHand", this, SendMessageOptions.DontRequireReceiver );
                attachedObjects.RemoveAt( index );

                GameObject newTopObject = currentAttachedObject;

                //Give focus to the top most object on the stack if it changed
                if ( newTopObject != null && newTopObject != prevTopObject )
                {
                    newTopObject.SetActive( true );
                    newTopObject.SendMessage( "OnHandFocusAcquired", this, SendMessageOptions.DontRequireReceiver );
                }
            }

            CleanUpAttachedObjectStack();
        }


        //-------------------------------------------------
        // Get the world velocity of the VR Hand.
        // Note: controller velocity value only updates on controller events (Button but and down) so good for throwing
        //-------------------------------------------------
        public Vector3 GetTrackedObjectVelocity()
        {
            if ( controller != null )
            {
                return transform.parent.TransformVector( controller.velocity );
            }

            return Vector3.zero;
        }


        //-------------------------------------------------
        // Get the world angular velocity of the VR Hand.
        // Note: controller velocity value only updates on controller events (Button but and down) so good for throwing
        //-------------------------------------------------
        public Vector3 GetTrackedObjectAngularVelocity()
        {
            if ( controller != null )
            {
                return transform.parent.TransformVector( controller.angularVelocity );
            }

            return Vector3.zero;
        }


        //-------------------------------------------------
        private void CleanUpAttachedObjectStack()
        {
            attachedObjects.RemoveAll( l => l.attachedObject == null );
        }


        //-------------------------------------------------
        void Awake()
        {
            ControllerTracked = GetComponent<SteamVR_TrackedObject>(); //gamesweplayed wuz here
            inputFocusAction = SteamVR_Events.InputFocusAction( OnInputFocus );

            if ( hoverSphereTransform == null )
            {
                hoverSphereTransform = this.transform;
            }

            applicationLostFocusObject = new GameObject( "_application_lost_focus" );
            applicationLostFocusObject.transform.parent = transform;
            applicationLostFocusObject.SetActive( false );
        }


        //-------------------------------------------------
        IEnumerator Start()
        {
            // save off player instance
            playerInstance = Player.instance;
            if ( !playerInstance )
            {
                Debug.LogError( "No player instance found in Hand Start()" );
            }

            // allocate array for colliders
            overlappingColliders = new Collider[ColliderArraySize];

            // We are a "no SteamVR fallback hand" if we have this camera set
            // we'll use the right mouse to look around and left mouse to interact
            // - don't need to find the device
            if ( noSteamVRFallbackCamera )
            {
                yield break;
            }

            //Debug.Log( "Hand - initializing connection routine" );

            // Acquire the correct device index for the hand we want to be
            // Also for the other hand if we get there first
            while ( true )
            {
                // Don't need to run this every frame
                yield return new WaitForSeconds( 1.0f );

                // We have a controller now, break out of the loop!
                if ( controller != null )
                    break;

                //Debug.Log( "Hand - checking controllers..." );

                // Initialize both hands simultaneously
                if ( startingHandType == HandType.Left || startingHandType == HandType.Right )
                {
                    // Left/right relationship.
                    // Wait until we have a clear unique left-right relationship to initialize.
                    int leftIndex = SteamVR_Controller.GetDeviceIndex( SteamVR_Controller.DeviceRelation.Leftmost );
                    int rightIndex = SteamVR_Controller.GetDeviceIndex( SteamVR_Controller.DeviceRelation.Rightmost );
                    if ( leftIndex == -1 || rightIndex == -1 || leftIndex == rightIndex )
                    {
                        //Debug.Log( string.Format( "...Left/right hand relationship not yet established: leftIndex={0}, rightIndex={1}", leftIndex, rightIndex ) );
                        continue;
                    }

                    int myIndex = ( startingHandType == HandType.Right ) ? rightIndex : leftIndex;
                    int otherIndex = ( startingHandType == HandType.Right ) ? leftIndex : rightIndex;

                    InitController( myIndex );
                    if ( otherHand )
                    {
                        otherHand.InitController( otherIndex );
                    }
                }
                else
                {
                    // No left/right relationship. Just wait for a connection

                    var vr = SteamVR.instance;
                    for ( int i = 0; i < Valve.VR.OpenVR.k_unMaxTrackedDeviceCount; i++ )
                    {
                        if ( vr.hmd.GetTrackedDeviceClass( (uint)i ) != Valve.VR.ETrackedDeviceClass.Controller )
                        {
                            //Debug.Log( string.Format( "Hand - device {0} is not a controller", i ) );
                            continue;
                        }

                        var device = SteamVR_Controller.Input( i );
                        if ( !device.valid )
                        {
                            //Debug.Log( string.Format( "Hand - device {0} is not valid", i ) );
                            continue;
                        }

                        if ( ( otherHand != null ) && ( otherHand.controller != null ) )
                        {
                            // Other hand is using this index, so we cannot use it.
                            if ( i == (int)otherHand.controller.index )
                            {
                                //Debug.Log( string.Format( "Hand - device {0} is owned by the other hand", i ) );
                                continue;
                            }
                        }

                        InitController( i );
                    }
                }
            }
        }


        //-------------------------------------------------
        private void UpdateHovering()
        {
            if ( ( noSteamVRFallbackCamera == null ) && ( controller == null ) )
            {
                return;
            }

            if ( hoverLocked )
                return;

            if ( applicationLostFocusObject.activeSelf )
                return;

            float closestDistance = float.MaxValue;
            Interactable closestInteractable = null;

            // Pick the closest hovering
            float flHoverRadiusScale = playerInstance.transform.lossyScale.x;
            float flScaledSphereRadius = hoverSphereRadius * flHoverRadiusScale;

            // if we're close to the floor, increase the radius to make things easier to pick up
            float handDiff = Mathf.Abs( transform.position.y - playerInstance.trackingOriginTransform.position.y );
            float boxMult = Util.RemapNumberClamped( handDiff, 0.0f, 0.5f * flHoverRadiusScale, 5.0f, 1.0f ) * flHoverRadiusScale;

            // null out old vals
            for ( int i = 0; i < overlappingColliders.Length; ++i )
            {
                overlappingColliders[i] = null;
            }

            Physics.OverlapBoxNonAlloc(
                hoverSphereTransform.position - new Vector3( 0, flScaledSphereRadius * boxMult - flScaledSphereRadius, 0 ),
                new Vector3( flScaledSphereRadius, flScaledSphereRadius * boxMult * 2.0f, flScaledSphereRadius ),
                overlappingColliders,
                Quaternion.identity,
                hoverLayerMask.value
            );

            // DebugVar
            int iActualColliderCount = 0;

            foreach ( Collider collider in overlappingColliders )
            {
                if ( collider == null )
                    continue;

                Interactable contacting = collider.GetComponentInParent<Interactable>();

                // Yeah, it's null, skip
                if ( contacting == null )
                    continue;

                // Ignore this collider for hovering
                IgnoreHovering ignore = collider.GetComponent<IgnoreHovering>();
                if ( ignore != null )
                {
                    if ( ignore.onlyIgnoreHand == null || ignore.onlyIgnoreHand == this )
                    {
                        continue;
                    }
                }

                // Can't hover over the object if it's attached
                if ( attachedObjects.FindIndex( l => l.attachedObject == contacting.gameObject ) != -1 )
                    continue;

                // Occupied by another hand, so we can't touch it
                if ( otherHand && otherHand.hoveringInteractable == contacting )
                    continue;

                // Best candidate so far...
                float distance = Vector3.Distance( contacting.transform.position, hoverSphereTransform.position );
                if ( distance < closestDistance )
                {
                    closestDistance = distance;
                    closestInteractable = contacting;
                }
                iActualColliderCount++;
            }

            // Hover on this one
            hoveringInteractable = closestInteractable;

            if ( iActualColliderCount > 0 && iActualColliderCount != prevOverlappingColliders )
            {
                prevOverlappingColliders = iActualColliderCount;
                HandDebugLog( "Found " + iActualColliderCount + " overlapping colliders." );
            }
        }


        //-------------------------------------------------
        private void UpdateNoSteamVRFallback()
        {
            if ( noSteamVRFallbackCamera )
            {
                Ray ray = noSteamVRFallbackCamera.ScreenPointToRay( Input.mousePosition );

                if ( attachedObjects.Count > 0 )
                {
                    // Holding down the mouse:
                    // move around a fixed distance from the camera
                    transform.position = ray.origin + noSteamVRFallbackInteractorDistance * ray.direction;
                }
                else
                {
                    // Not holding down the mouse:
                    // cast out a ray to see what we should mouse over

                    // Don't want to hit the hand and anything underneath it
                    // So move it back behind the camera when we do the raycast
                    Vector3 oldPosition = transform.position;
                    transform.position = noSteamVRFallbackCamera.transform.forward * ( -1000.0f );

                    RaycastHit raycastHit;
                    if ( Physics.Raycast( ray, out raycastHit, noSteamVRFallbackMaxDistanceNoItem ) )
                    {
                        transform.position = raycastHit.point;

                        // Remember this distance in case we click and drag the mouse
                        noSteamVRFallbackInteractorDistance = Mathf.Min( noSteamVRFallbackMaxDistanceNoItem, raycastHit.distance );
                    }
                    else if ( noSteamVRFallbackInteractorDistance > 0.0f )
                    {
                        // Move it around at the distance we last had a hit
                        transform.position = ray.origin + Mathf.Min( noSteamVRFallbackMaxDistanceNoItem, noSteamVRFallbackInteractorDistance ) * ray.direction;
                    }
                    else
                    {
                        // Didn't hit, just leave it where it was
                        transform.position = oldPosition;
                    }
                }
            }
        }


        //-------------------------------------------------
        private void UpdateDebugText()
        {
            if ( showDebugText )
            {
                if ( debugText == null )
                {
                    debugText = new GameObject( "_debug_text" ).AddComponent<TextMesh>();
                    debugText.fontSize = 120;
                    debugText.characterSize = 0.001f;
                    debugText.transform.parent = transform;

                    debugText.transform.localRotation = Quaternion.Euler( 90.0f, 0.0f, 0.0f );
                }

                if ( GuessCurrentHandType() == HandType.Right )
                {
                    debugText.transform.localPosition = new Vector3( -0.05f, 0.0f, 0.0f );
                    debugText.alignment = TextAlignment.Right;
                    debugText.anchor = TextAnchor.UpperRight;
                }
                else
                {
                    debugText.transform.localPosition = new Vector3( 0.05f, 0.0f, 0.0f );
                    debugText.alignment = TextAlignment.Left;
                    debugText.anchor = TextAnchor.UpperLeft;
                }

                debugText.text = string.Format(
                    "Hovering: {0}\n" +
                    "Hover Lock: {1}\n" +
                    "Attached: {2}\n" +
                    "Total Attached: {3}\n" +
                    "Type: {4}\n",
                    ( hoveringInteractable ? hoveringInteractable.gameObject.name : "null" ),
                    hoverLocked,
                    ( currentAttachedObject ? currentAttachedObject.name : "null" ),
                    attachedObjects.Count,
                    GuessCurrentHandType().ToString() );
            }
            else
            {
                if ( debugText != null )
                {
                    Destroy( debugText.gameObject );
                }
            }
        }


        //-------------------------------------------------
        void OnEnable()
        {
            inputFocusAction.enabled = true;

            // Stagger updates between hands
            float hoverUpdateBegin = ( ( otherHand != null ) && ( otherHand.GetInstanceID() < GetInstanceID() ) ) ? ( 0.5f * hoverUpdateInterval ) : ( 0.0f );
            InvokeRepeating( "UpdateHovering", hoverUpdateBegin, hoverUpdateInterval );
            InvokeRepeating( "UpdateDebugText", hoverUpdateBegin, hoverUpdateInterval );
        }


        //-------------------------------------------------
        void OnDisable()
        {
            inputFocusAction.enabled = false;

            CancelInvoke();
        }


        //-------------------------------------------------
        void Update()
        {
            UpdateNoSteamVRFallback();

            GameObject attached = currentAttachedObject;
            if ( attached )
            {
                attached.SendMessage( "HandAttachedUpdate", this, SendMessageOptions.DontRequireReceiver );
            }

            if ( hoveringInteractable )
            {
                hoveringInteractable.SendMessage( "HandHoverUpdate", this, SendMessageOptions.DontRequireReceiver );
            }
        }


        //-------------------------------------------------
        void LateUpdate()
        {
            //Re-attach the controller if nothing else is attached to the hand
            if ( controllerObject != null && attachedObjects.Count == 0 )
            {
                AttachObject( controllerObject );
            }
        }


        //-------------------------------------------------
        private void OnInputFocus( bool hasFocus )
        {
            if ( hasFocus )
            {
                DetachObject( applicationLostFocusObject, true );
                applicationLostFocusObject.SetActive( false );
                UpdateHandPoses();
                UpdateHovering();
                BroadcastMessage( "OnParentHandInputFocusAcquired", SendMessageOptions.DontRequireReceiver );
            }
            else
            {
                applicationLostFocusObject.SetActive( true );
                AttachObject( applicationLostFocusObject, AttachmentFlags.ParentToHand );
                BroadcastMessage( "OnParentHandInputFocusLost", SendMessageOptions.DontRequireReceiver );
            }
        }


        //-------------------------------------------------
        void FixedUpdate()
        {
            UpdateHandPoses();
        }


        //-------------------------------------------------
        void OnDrawGizmos()
        {
            Gizmos.color = new Color( 0.5f, 1.0f, 0.5f, 0.9f );
            Transform sphereTransform = hoverSphereTransform ? hoverSphereTransform : this.transform;
            Gizmos.DrawWireSphere( sphereTransform.position, hoverSphereRadius );
        }


        //-------------------------------------------------
        private void HandDebugLog( string msg )
        {
            if ( spewDebugText )
            {
                Debug.Log( "Hand (" + this.name + "): " + msg );
            }
        }


        //-------------------------------------------------
        private void UpdateHandPoses()
        {
            if ( controller != null )
            {
                SteamVR vr = SteamVR.instance;
                if ( vr != null )
                {
                    var pose = new Valve.VR.TrackedDevicePose_t();
                    var gamePose = new Valve.VR.TrackedDevicePose_t();
                    var err = vr.compositor.GetLastPoseForTrackedDeviceIndex( controller.index, ref pose, ref gamePose );
                    if ( err == Valve.VR.EVRCompositorError.None )
                    {
                        var t = new SteamVR_Utils.RigidTransform( gamePose.mDeviceToAbsoluteTracking );
                        transform.localPosition = t.pos;
                        transform.localRotation = t.rot;
                    }
                }
            }
        }


        //-------------------------------------------------
        // Continue to hover over this object indefinitely, whether or not the Hand moves out of its interaction trigger volume.
        //
        // interactable - The Interactable to hover over indefinitely.
        //-------------------------------------------------
        public void HoverLock( Interactable interactable )
        {
            HandDebugLog( "HoverLock " + interactable );
            hoverLocked = true;
            hoveringInteractable = interactable;
        }


        //-------------------------------------------------
        // Stop hovering over this object indefinitely.
        //
        // interactable - The hover-locked Interactable to stop hovering over indefinitely.
        //-------------------------------------------------
        public void HoverUnlock( Interactable interactable )
        {
            HandDebugLog( "HoverUnlock " + interactable );
            if ( hoveringInteractable == interactable )
            {
                hoverLocked = false;
            }
        }

        //-------------------------------------------------
        // Was the standard interaction button just pressed? In VR, this is a trigger press. In 2D fallback, this is a mouse left-click.
        //-------------------------------------------------
        public bool GetStandardInteractionButtonDown()
        {
            if ( noSteamVRFallbackCamera )
            {
                return Input.GetMouseButtonDown( 0 );
            }
            else if ( controller != null )
            {
                return controller.GetHairTriggerDown();
            }

            return false;
        }

        public bool GetOculusGripButtonDown() // gamesweplayed wus here
        {
            if (noSteamVRFallbackCamera)
            {
                return Input.GetMouseButtonDown(0);
            }
            else if (controller != null)
            {
                return c.GetPressDown(grip);
            }

            return false;
        }
        //-------------------------------------------------
        // Was the standard interaction button just released? In VR, this is a trigger press. In 2D fallback, this is a mouse left-click.
        //-------------------------------------------------
        public bool GetStandardInteractionButtonUp()
        {
            if ( noSteamVRFallbackCamera )
            {
                return Input.GetMouseButtonUp( 0 );
            }
            else if ( controller != null )
            {
                return controller.GetHairTriggerUp();
            }

            return false;
        }

        public bool GetOculusGripButtonUp() // gamesweplayed wus here
        {
            if (noSteamVRFallbackCamera)
            {
                return Input.GetMouseButtonDown(0);
            }
            else if (controller != null)
            {
                return c.GetPressUp(grip);
            }

            return false;
        }
        //-------------------------------------------------
        // Is the standard interaction button being pressed? In VR, this is a trigger press. In 2D fallback, this is a mouse left-click.
        //-------------------------------------------------
        public bool GetStandardInteractionButton()
        {
            if ( noSteamVRFallbackCamera )
            {
                return Input.GetMouseButton( 0 );
            }
            else if ( controller != null )
            {
                return controller.GetHairTrigger();
            }

            return false;
        }

        public bool GetOculusGripButton() // gamesweplayed wus here
        {
            if (noSteamVRFallbackCamera)
            {
                return Input.GetMouseButtonDown(0);
            }
            else if (controller != null)
            {
                return c.GetPress(grip);
            }

            return false;
        }
        //-------------------------------------------------
        private void InitController( int index )
        {
            if ( controller == null )
            {
                controller = SteamVR_Controller.Input( index );

                HandDebugLog( "Hand " + name + " connected with device index " + controller.index );

                controllerObject = GameObject.Instantiate( controllerPrefab );
                controllerObject.SetActive( true );
                controllerObject.name = controllerPrefab.name + "_" + this.name;
                AttachObject( controllerObject );
                controller.TriggerHapticPulse( 800 );

                // If the player's scale has been changed the object to attach will be the wrong size.
                // To fix this we change the object's scale back to its original, pre-attach scale.
                controllerObject.transform.localScale = controllerPrefab.transform.localScale;

                this.BroadcastMessage( "OnHandInitialized", index, SendMessageOptions.DontRequireReceiver ); // let child objects know we've initialized
            }
        }
    }

#if UNITY_EDITOR
    //-------------------------------------------------------------------------
    [UnityEditor.CustomEditor( typeof( Hand ) )]
    public class HandEditor : UnityEditor.Editor
    {
        //-------------------------------------------------
        // Custom Inspector GUI allows us to click from within the UI
        //-------------------------------------------------
        public override void OnInspectorGUI()
        {
            DrawDefaultInspector();

            Hand hand = (Hand)target;

            if ( hand.otherHand )
            {
                if ( hand.otherHand.otherHand != hand )
                {
                    UnityEditor.EditorGUILayout.HelpBox( "The otherHand of this Hand's otherHand is not this Hand.", UnityEditor.MessageType.Warning );
                }

                if ( hand.startingHandType == Hand.HandType.Left && hand.otherHand.startingHandType != Hand.HandType.Right )
                {
                    UnityEditor.EditorGUILayout.HelpBox( "This is a left Hand but otherHand is not a right Hand.", UnityEditor.MessageType.Warning );
                }

                if ( hand.startingHandType == Hand.HandType.Right && hand.otherHand.startingHandType != Hand.HandType.Left )
                {
                    UnityEditor.EditorGUILayout.HelpBox( "This is a right Hand but otherHand is not a left Hand.", UnityEditor.MessageType.Warning );
                }

                if ( hand.startingHandType == Hand.HandType.Any && hand.otherHand.startingHandType != Hand.HandType.Any )
                {
                    UnityEditor.EditorGUILayout.HelpBox( "This is an any-handed Hand but otherHand is not an any-handed Hand.", UnityEditor.MessageType.Warning );
                }
            }
        }
    }
#endif
}