Thesis-Hector-VR/Hector_v2/Library/PackageCache/com.unity.xr.legacyinputhelpers@2.1.6/Runtime/ArmModels/ArmModel.cs

// Copyright 2016 Google Inc. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Modified by Unity from original:
// https://github.com/googlevr/gvr-unity-sdk/blob/master/Assets/GoogleVR/Scripts/Controller/ArmModel/GvrArmModel.cs

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

#if ENABLE_VR || ENABLE_AR
using UnityEngine.SpatialTracking;
using UnityEngine.Experimental.XR.Interaction;

namespace UnityEngine.XR.LegacyInputHelpers
{
    public class ArmModel : BasePoseProvider
    {

        /// <summary> Gets the Pose value from the calculated arm model. as the model returns both position and rotation in all cases, we set both flags on return if successful.</summary>
        public override PoseDataFlags GetPoseFromProvider(out Pose output)
        {
            if (OnControllerInputUpdated())
            {
                output = finalPose;
                return PoseDataFlags.Position | PoseDataFlags.Rotation;
            }
            output = Pose.identity;
            return PoseDataFlags.NoData;
        }

        Pose m_FinalPose;
        /// <summary>
        /// the pose which represents the final tracking result of the arm model
        /// </summary>        
        public Pose finalPose
        {
            get { return m_FinalPose; }
            set { m_FinalPose = value; }
        }


        [SerializeField]
        XRNode m_PoseSource = XRNode.LeftHand;
        /// <summary>
        /// the pose to use as the input 3DOF position
        /// </summary>        
        public XRNode poseSource
        {
            get { return m_PoseSource; }
            set { m_PoseSource = value; }
        }

        [SerializeField]
        XRNode m_HeadPoseSource = XRNode.CenterEye;
        /// <summary>
        /// The game object which represents the "head" position of the user
        /// </summary>       
        public XRNode headGameObject
        {
            get { return m_HeadPoseSource; }
            set { m_HeadPoseSource = value; }
        }

        /// Standard implementation for a mathematical model to make the virtual controller approximate the
        /// physical location of the Daydream controller.

        [SerializeField]
        Vector3 m_ElbowRestPosition = DEFAULT_ELBOW_REST_POSITION;
        /// <summary>
        /// Position of the elbow joint relative to the head before the arm model is applied.
        /// </summary>
        public Vector3 elbowRestPosition
        {
            get { return m_ElbowRestPosition; }
            set { m_ElbowRestPosition = value; }
        }

        [SerializeField]
        Vector3 m_WristRestPosition = DEFAULT_WRIST_REST_POSITION;
        /// <summary>
        /// Position of the wrist joint relative to the elbow before the arm model is applied.
        /// </summary>
        public Vector3 wristRestPosition
        {
            get { return m_WristRestPosition; }
            set { m_WristRestPosition = value; }
        }

        [SerializeField]
        Vector3 m_ControllerRestPosition = DEFAULT_CONTROLLER_REST_POSITION;
        /// <summary>
        /// Position of the controller joint relative to the wrist before the arm model is applied.
        /// </summary>
        public Vector3 controllerRestPosition
        {
            get { return m_ControllerRestPosition; }
            set { m_ControllerRestPosition = value; }
        }

        [SerializeField]
        Vector3 m_ArmExtensionOffset = DEFAULT_ARM_EXTENSION_OFFSET;
        /// <summary>
        /// Offset applied to the elbow position as the controller is rotated upwards.
        /// </summary>
        public Vector3 armExtensionOffset
        {
            get { return m_ArmExtensionOffset; }
            set { m_ArmExtensionOffset = value; }
        }

        [Range(0.0f, 1.0f)]
        [SerializeField]
        float m_ElbowBendRatio = DEFAULT_ELBOW_BEND_RATIO;
        /// <summary>
        /// Ratio of the controller's rotation to apply to the rotation of the elbow.
        /// The remaining rotation is applied to the wrist's rotation.
        /// </summary>
        public float elbowBendRatio
        {
            get { return m_ElbowBendRatio; }
            set { m_ElbowBendRatio = value; }
        }
        
        [SerializeField]
        bool m_IsLockedToNeck = true;
        /// <summary>
        /// If true, the root of the pose is locked to the local position of the player's neck.
        /// </summary>
        public bool isLockedToNeck
        {
            get { return m_IsLockedToNeck; }
            set { m_IsLockedToNeck = value; }
        }

        /// Represent the neck's position relative to the user's head.
        /// If isLockedToNeck is true, this will be the InputTracking position of the Head node modified
        /// by an inverse neck model to approximate the neck position.
        /// Otherwise, it is always zero.
        public Vector3 neckPosition
        {
            get
            {
                return m_NeckPosition;
            }
        }

        /// Represent the shoulder's position relative to the user's head.
        /// This is not actually used as part of the arm model calculations, and exists for debugging.
        public Vector3 shoulderPosition
        {
            get
            {
                Vector3 retVal = m_NeckPosition + m_TorsoRotation * Vector3.Scale(SHOULDER_POSITION, m_HandedMultiplier);
                return retVal;
            }
        }

        /// Represent the shoulder's rotation relative to the user's head.
        /// This is not actually used as part of the arm model calculations, and exists for debugging.
        public Quaternion shoulderRotation
        {
            get
            {
                return m_TorsoRotation;
            }
        }

        /// Represent the elbow's position relative to the user's head.
        public Vector3 elbowPosition
        {
            get
            {
                return m_ElbowPosition;
            }
        }

        /// Represent the elbow's rotation relative to the user's head.
        public Quaternion elbowRotation
        {
            get
            {
                return m_ElbowRotation;
            }
        }

        /// Represent the wrist's position relative to the user's head.
        public Vector3 wristPosition
        {
            get
            {
                return m_WristPosition;
            }
        }

        /// Represent the wrist's rotation relative to the user's head.
        public Quaternion wristRotation
        {
            get
            {
                return m_WristRotation;
            }
        }

        /// Represent the controller's position relative to the head pose
        public Vector3 controllerPosition
        {
            get
            {
                return m_ControllerPosition;
            }
        }

        /// Represent the controllers rotation relative to the user's head.
        public Quaternion controllerRotation
        {
            get
            {
                return m_ControllerRotation;
            }
        }

#if UNITY_EDITOR

        /// Editor only API to allow querying the torso forward direction
        public Vector3 torsoDirection
        {
            get { return m_TorsoDirection; }
        }

        /// Editor only API to allow querying the torso rotation
        public Quaternion torsoRotation
        {
            get { return m_TorsoRotation; }
        }
#endif

        protected Vector3 m_NeckPosition;
        protected Vector3 m_ElbowPosition;
        protected Quaternion m_ElbowRotation;
        protected Vector3 m_WristPosition;
        protected Quaternion m_WristRotation;
        protected Vector3 m_ControllerPosition;
        protected Quaternion m_ControllerRotation;

        /// Multiplier for handedness such that 1 = Right, 0 = Center, -1 = left.
        protected Vector3 m_HandedMultiplier;

        /// Forward direction of user's torso.
        protected Vector3 m_TorsoDirection;

        /// Orientation of the user's torso.
        protected Quaternion m_TorsoRotation;

        // Default values for tuning variables.
        protected static readonly Vector3 DEFAULT_ELBOW_REST_POSITION = new Vector3(0.195f, -0.5f, 0.005f);
        protected static readonly Vector3 DEFAULT_WRIST_REST_POSITION = new Vector3(0.0f, 0.0f, 0.25f);
        protected static readonly Vector3 DEFAULT_CONTROLLER_REST_POSITION = new Vector3(0.0f, 0.0f, 0.05f);
        protected static readonly Vector3 DEFAULT_ARM_EXTENSION_OFFSET = new Vector3(-0.13f, 0.14f, 0.08f);
        protected const float DEFAULT_ELBOW_BEND_RATIO = 0.6f;

        /// Increases elbow bending as the controller moves up (unitless).
        protected const float EXTENSION_WEIGHT = 0.4f;

        /// Rest position for shoulder joint.
        protected static readonly Vector3 SHOULDER_POSITION = new Vector3(0.17f, -0.2f, -0.03f);

        /// Neck offset used to apply the inverse neck model when locked to the head.
        protected static readonly Vector3 NECK_OFFSET = new Vector3(0.0f, 0.075f, 0.08f);

        /// Angle ranges the for arm extension offset to start and end (degrees).
        protected const float MIN_EXTENSION_ANGLE = 7.0f;
        protected const float MAX_EXTENSION_ANGLE = 60.0f;

        protected virtual void OnEnable()
        {
            // Force the torso direction to match the gaze direction immediately.
            // Otherwise, the controller will not be positioned correctly if the ArmModel was enabled
            // when the user wasn't facing forward.
            UpdateTorsoDirection(true);

            // Update immediately to avoid a frame delay before the arm model is applied.
            OnControllerInputUpdated();
        }

        protected virtual void OnDisable()
        {

        }

        public virtual bool OnControllerInputUpdated()
        {
            UpdateHandedness();
            if (UpdateTorsoDirection(false))
            {
                if (UpdateNeckPosition())
                {
                    if (ApplyArmModel())
                    {
                        return true;
                    }
                }
            }
            return false;
        }

        protected virtual void UpdateHandedness()
        {
            // Determine handedness multiplier.
            m_HandedMultiplier.Set(0, 1, 1);
            if (m_PoseSource == XRNode.RightHand || m_PoseSource == XRNode.TrackingReference)
            {
                m_HandedMultiplier.x = 1.0f;
            }
            else if (m_PoseSource == XRNode.LeftHand)
            {
                m_HandedMultiplier.x = -1.0f;
            }
        }

        protected virtual bool UpdateTorsoDirection(bool forceImmediate)
        {
            // Determine the gaze direction horizontally.

            Vector3 gazeDirection = new Vector3();
            if (TryGetForwardVector(m_HeadPoseSource, out gazeDirection))
            {
                gazeDirection.y = 0.0f;
                gazeDirection.Normalize();

                // Use the gaze direction to update the forward direction.
                if (forceImmediate)
                {
                    m_TorsoDirection = gazeDirection;
                }
                else
                {
                    Vector3 angAccel;
                    if (TryGetAngularAcceleration(poseSource, out angAccel))
                    {
                        float angularVelocity = angAccel.magnitude;
                        float gazeFilterStrength = Mathf.Clamp((angularVelocity - 0.2f) / 45.0f, 0.0f, 0.1f);
                        m_TorsoDirection = Vector3.Slerp(m_TorsoDirection, gazeDirection, gazeFilterStrength);
                    }
                }

                // Calculate the torso rotation.
                m_TorsoRotation = Quaternion.FromToRotation(Vector3.forward, m_TorsoDirection);
                return true;
            }
            return false;
        }

        protected virtual bool UpdateNeckPosition()
        {
            if (m_IsLockedToNeck && TryGetPosition(m_HeadPoseSource, out m_NeckPosition))
            {
                // Find the approximate neck position by Applying an inverse neck model.
                // This transforms the head position to the center of the head and also accounts
                // for the head's rotation so that the motion feels more natural.
                return ApplyInverseNeckModel(m_NeckPosition, out m_NeckPosition);
            }
            else
            {
                m_NeckPosition = Vector3.zero;
                return true;
            }
        }

        protected virtual bool ApplyArmModel()
        {
            // Set the starting positions of the joints before they are transformed by the arm model.
            SetUntransformedJointPositions();

            // Get the controller's orientation.
            Quaternion controllerOrientation;
            Quaternion xyRotation;
            float xAngle;
            if (GetControllerRotation(out controllerOrientation, out xyRotation, out xAngle))
            {

                // Offset the elbow by the extension offset.
                float extensionRatio = CalculateExtensionRatio(xAngle);
                ApplyExtensionOffset(extensionRatio);

                // Calculate the lerp rotation, which is used to control how much the rotation of the
                // controller impacts each joint.
                Quaternion lerpRotation = CalculateLerpRotation(xyRotation, extensionRatio);

                CalculateFinalJointRotations(controllerOrientation, xyRotation, lerpRotation);
                ApplyRotationToJoints();
                m_FinalPose.position = m_ControllerPosition;
                m_FinalPose.rotation = m_ControllerRotation;
                return true;
            }
            return false;
        }

        /// Set the starting positions of the joints before they are transformed by the arm model.
        protected virtual void SetUntransformedJointPositions()
        {
            m_ElbowPosition = Vector3.Scale(m_ElbowRestPosition, m_HandedMultiplier);
            m_WristPosition = Vector3.Scale(m_WristRestPosition, m_HandedMultiplier);
            m_ControllerPosition = Vector3.Scale(m_ControllerRestPosition, m_HandedMultiplier);
        }

        /// Calculate the extension ratio based on the angle of the controller along the x axis.
        protected virtual float CalculateExtensionRatio(float xAngle)
        {
            float normalizedAngle = (xAngle - MIN_EXTENSION_ANGLE) / (MAX_EXTENSION_ANGLE - MIN_EXTENSION_ANGLE);
            float extensionRatio = Mathf.Clamp(normalizedAngle, 0.0f, 1.0f);
            return extensionRatio;
        }

        /// Offset the elbow by the extension offset.
        protected virtual void ApplyExtensionOffset(float extensionRatio)
        {
            Vector3 extensionOffset = Vector3.Scale(m_ArmExtensionOffset, m_HandedMultiplier);
            m_ElbowPosition += extensionOffset * extensionRatio;
        }

        /// Calculate the lerp rotation, which is used to control how much the rotation of the
        /// controller impacts each joint.
        protected virtual Quaternion CalculateLerpRotation(Quaternion xyRotation, float extensionRatio)
        {
            float totalAngle = Quaternion.Angle(xyRotation, Quaternion.identity);
            float lerpSuppresion = 1.0f - Mathf.Pow(totalAngle / 180.0f, 6.0f);
            float inverseElbowBendRatio = 1.0f - m_ElbowBendRatio;
            float lerpValue = inverseElbowBendRatio + m_ElbowBendRatio * extensionRatio * EXTENSION_WEIGHT;
            lerpValue *= lerpSuppresion;
            return Quaternion.Lerp(Quaternion.identity, xyRotation, lerpValue);
        }

        /// Determine the final joint rotations relative to the head.
        protected virtual void CalculateFinalJointRotations(Quaternion controllerOrientation, Quaternion xyRotation, Quaternion lerpRotation)
        {
            m_ElbowRotation = m_TorsoRotation * Quaternion.Inverse(lerpRotation) * xyRotation;
            m_WristRotation = m_ElbowRotation * lerpRotation;
            m_ControllerRotation = m_TorsoRotation * controllerOrientation;
        }

        /// Apply the joint rotations to the positions of the joints to determine the final pose.
        protected virtual void ApplyRotationToJoints()
        {
            m_ElbowPosition = m_NeckPosition + m_TorsoRotation * m_ElbowPosition;
            m_WristPosition = m_ElbowPosition + m_ElbowRotation * m_WristPosition;
            m_ControllerPosition = m_WristPosition + m_WristRotation * m_ControllerPosition;
        }

        /// Transform the head position into an approximate neck position.
        protected virtual bool ApplyInverseNeckModel(Vector3 headPosition, out Vector3 calculatedPosition)
        {
            // Determine the gaze direction horizontally.
            Quaternion headRotation = new Quaternion();
            if (TryGetRotation(m_HeadPoseSource, out headRotation))
            {
                Vector3 rotatedNeckOffset =
                    headRotation * NECK_OFFSET - NECK_OFFSET.y * Vector3.up;
                headPosition -= rotatedNeckOffset;

                calculatedPosition = headPosition;
                return true;
            }      
            
            calculatedPosition = Vector3.zero;
            return false;
        }

        protected bool TryGetForwardVector(XRNode node, out Vector3 forward)
        {
            Pose tmpPose = new Pose();
            if (TryGetRotation(node, out tmpPose.rotation) &&
                TryGetPosition(node, out tmpPose.position))
            {
                forward = tmpPose.forward;
                return true;
            }

            forward = Vector3.zero;            
            return false;
        }

        List<XR.XRNodeState> xrNodeStateListOrientation = new List<XRNodeState>();
        protected bool TryGetRotation(XRNode node, out Quaternion rotation)
        {
            XR.InputTracking.GetNodeStates(xrNodeStateListOrientation);
            var length = xrNodeStateListOrientation.Count;           
            XRNodeState nodeState;
            for (int i = 0; i < length; ++i)
            {
                nodeState = xrNodeStateListOrientation[i];
                if (nodeState.nodeType == node)
                {
                    if (nodeState.TryGetRotation(out rotation))
                    {
                        return true;
                    }
                }
            }                          
            rotation = Quaternion.identity;            
            return false;
        }

        List<XR.XRNodeState> xrNodeStateListPosition = new List<XRNodeState>();
        protected bool TryGetPosition(XRNode node, out Vector3 position)
        {
            XR.InputTracking.GetNodeStates(xrNodeStateListPosition);
            var length = xrNodeStateListPosition.Count;      
            XRNodeState nodeState;
            for (int i = 0; i < length; ++i)
            {
                nodeState = xrNodeStateListPosition[i];
                if (nodeState.nodeType == node)
                {
                    if (nodeState.TryGetPosition(out position))
                    {
                        return true;
                    }
                }
            }                            
            position = Vector3.zero;            
            return false;
        }
        
        List<XR.XRNodeState> xrNodeStateListAngularAcceleration = new List<XRNodeState>();
        protected bool TryGetAngularAcceleration(XRNode node, out Vector3 angularAccel)
        {
            XR.InputTracking.GetNodeStates(xrNodeStateListAngularAcceleration);
            var length = xrNodeStateListAngularAcceleration.Count;          
            XRNodeState nodeState;
            for (int i = 0; i < length; ++i)
            {
                nodeState = xrNodeStateListAngularAcceleration[i];
                if (nodeState.nodeType == node)
                {
                    if (nodeState.TryGetAngularAcceleration(out angularAccel))
                    {
                        return true;
                    }
                }
            }
            angularAccel = Vector3.zero;            
            return false;
        }

        List<XR.XRNodeState> xrNodeStateListAngularVelocity = new List<XRNodeState>();
        protected bool TryGetAngularVelocity(XRNode node, out Vector3 angVel)
        {
            XR.InputTracking.GetNodeStates(xrNodeStateListAngularVelocity);
            var length = xrNodeStateListAngularVelocity.Count;
            XRNodeState nodeState;
            for (int i = 0; i < length; ++i)
            {
                nodeState = xrNodeStateListAngularVelocity[i];
                if (nodeState.nodeType == node)
                {
                    if (nodeState.TryGetAngularVelocity(out angVel))
                    {
                        return true;
                    }
                }
            }
            angVel = Vector3.zero;
            return false;
        }

        /// Get the controller's orientation.
        protected bool GetControllerRotation(out Quaternion rotation, out Quaternion xyRotation, out float xAngle)
        {
            // Find the controller's orientation relative to the player.
            if (TryGetRotation(poseSource, out rotation))
            {
                rotation = Quaternion.Inverse(m_TorsoRotation) * rotation;

                // Extract just the x rotation angle.
                Vector3 controllerForward = rotation * Vector3.forward;
                xAngle = 90.0f - Vector3.Angle(controllerForward, Vector3.up);

                // Remove the z rotation from the controller.
                xyRotation = Quaternion.FromToRotation(Vector3.forward, controllerForward);
                return true;
            }
            else
            {
                rotation = Quaternion.identity;
                xyRotation = Quaternion.identity;
                xAngle = 0.0f;
                return false;
            }
        }

#if UNITY_EDITOR
        /// <summary>
        /// Editor only API to draw debug gizmos to help visualize the arm model
        /// </summary>
        public virtual void OnDrawGizmos()
        {
            if (!enabled)
            {
                return;
            }

            if (transform.parent == null) {                
                return;
            }
           
            Vector3 worldShoulder = transform.parent.TransformPoint(shoulderPosition);
            Vector3 worldElbow = transform.parent.TransformPoint(elbowPosition);
            Vector3 worldwrist = transform.parent.TransformPoint(wristPosition);
            Vector3 worldcontroller = transform.parent.TransformPoint(controllerPosition);
    
            Gizmos.color = Color.red;
            Gizmos.DrawSphere(worldShoulder, 0.02f);
            Gizmos.DrawLine(worldShoulder, worldElbow);

            Gizmos.color = Color.green;
            Gizmos.DrawSphere(worldElbow, 0.02f);
            Gizmos.DrawLine(worldElbow, worldwrist);

            Gizmos.color = Color.cyan;
            Gizmos.DrawSphere(worldwrist, 0.02f);

            Gizmos.color = Color.blue;
            Gizmos.DrawSphere(worldcontroller, 0.02f);
        }
#endif // UNITY_EDITOR
    }
}

#endif