Replace UltimateXR with HurricaneVR

Assets/HurricaneVR/Framework/Scripts/Components/HVRControllerOffset.cs

@@ -0,0 +1,184 @@
+using System;
+using HurricaneVR.Framework.ControllerInput;
+using HurricaneVR.Framework.Shared;
+using UnityEngine;
+
+namespace HurricaneVR.Framework.Components
+{
+    /// <summary>
+    /// Handles offsettings the physics hand target based on the connected device. Also offsets the target based on grab point settings if desired.
+    /// To manage custom offsets please use the SetMiscPositionOffset(Vector3 position, Vector3 rotation) and ResetGrabPointOffsets() functions.
+    /// </summary>
+    public class HVRControllerOffset : MonoBehaviour
+    {
+        /// <summary>
+        /// The hand that this controller offset represents.
+        /// </summary>
+        public HVRHandSide HandSide;
+
+        /// <summary>
+        /// The transform that aim's the teleport line, it will be counter rotated when a grabbable requests the hand to rotate when held.
+        /// </summary>
+        [Tooltip("The transform that aim's the teleport line, it will be counter rotated when a grabbable requests the hand to rotate when held.")]
+        public Transform Teleport;
+
+        /// <summary>
+        /// Smooth lerp speed to move towards the target grab point rotation offset
+        /// </summary>
+        [Tooltip("Smooth lerp speed to move towards the target grab point rotation offset")]
+        public float GrabPointSmoothSpeed = 8f;
+
+        private HVRDevicePoseOffset _offsets;
+
+        public Vector3 ControllerPositionOffset => _offsets != null ? _offsets.Position : Vector3.zero;
+        public Vector3 ControllerRotationOffset => _offsets != null ? _offsets.Rotation : Vector3.zero;
+
+        [Header("Debugging")]
+
+        [Tooltip("Enable to test live updating of the Misc offset fields.")]
+        public bool LiveUpdateOffsets;
+
+        [SerializeField] private Vector3 TargetGrabPointPositionOffset;
+        [SerializeField] private Vector3 TargetGrabPointRotationOffset;
+
+        [SerializeField] private Vector3 GrabPointPositionOffset;
+        [SerializeField] private Vector3 GrabPointRotationOffset;
+
+        [SerializeField] private Vector3 MiscPositionOffset;
+        [SerializeField] private Vector3 MiscRotationOffset;
+
+        
+        private Quaternion _teleportStartRotation;
+
+        public bool _updatingRotation;
+        public bool _updatingPosition;
+
+        protected virtual void Awake()
+        {
+            if (Teleport)
+            {
+                _teleportStartRotation = Teleport.localRotation;
+            }
+        }
+
+        private void Start()
+        {
+            if (HandSide == HVRHandSide.Left)
+            {
+                if (HVRInputManager.Instance.LeftController)
+                    ControllerConnected(HVRInputManager.Instance.LeftController);
+                HVRInputManager.Instance.LeftControllerConnected.AddListener(ControllerConnected);
+            }
+            else
+            {
+                if (HVRInputManager.Instance.RightController)
+                    ControllerConnected(HVRInputManager.Instance.RightController);
+                HVRInputManager.Instance.RightControllerConnected.AddListener(ControllerConnected);
+            }
+
+
+        }
+
+        public void Update()
+        {
+            if (_updatingRotation)
+            {
+                GrabPointRotationOffset = Vector3.Lerp(GrabPointRotationOffset, TargetGrabPointRotationOffset, GrabPointSmoothSpeed * Time.deltaTime);
+                if (Vector3.Distance(GrabPointRotationOffset, TargetGrabPointRotationOffset) < .01f)
+                {
+                    _updatingRotation = false;
+                    GrabPointRotationOffset = TargetGrabPointRotationOffset;
+                    ApplyOffsets();
+                }
+            }
+
+            if (_updatingPosition)
+            {
+                GrabPointPositionOffset = Vector3.Lerp(GrabPointPositionOffset, TargetGrabPointPositionOffset, GrabPointSmoothSpeed * Time.deltaTime);
+                if (Vector3.Distance(GrabPointPositionOffset, TargetGrabPointPositionOffset) < .01f)
+                {
+                    _updatingPosition = false;
+                    GrabPointPositionOffset = TargetGrabPointPositionOffset;
+                    ApplyOffsets();
+                }
+            }
+
+            if (LiveUpdateOffsets || _updatingPosition || _updatingRotation)
+            {
+                ApplyOffsets();
+            }
+        }
+
+        public void SetMiscPositionOffset(Vector3 position, Vector3 rotation)
+        {
+            MiscPositionOffset = position;
+            MiscRotationOffset = rotation;
+            ApplyOffsets();
+        }
+
+
+        public void SetGrabPointOffsets(Vector3 position, Vector3 rotation)
+        {
+            TargetGrabPointPositionOffset = position;
+            TargetGrabPointRotationOffset = rotation;
+            _updatingRotation = true;
+            _updatingPosition = true;
+        }
+
+        public void ResetGrabPointOffsets()
+        {
+            TargetGrabPointPositionOffset = Vector3.zero;
+            TargetGrabPointRotationOffset = Vector3.zero;
+            _updatingRotation = true;
+            _updatingPosition = true;
+        }
+
+        public void ApplyOffsets()
+        {
+            var position = ControllerPositionOffset + GrabPointPositionOffset + MiscPositionOffset;
+
+            if (HandSide == HVRHandSide.Left)
+            {
+                position.x *= -1f;
+            }
+
+            transform.localPosition = position;
+
+            var controllerRotation = Quaternion.Euler(ControllerRotationOffset);
+            var grabPointRotation = Quaternion.Euler(GrabPointRotationOffset);
+            var miscRotation = Quaternion.Euler(MiscRotationOffset);
+
+            var finalRotation = controllerRotation * grabPointRotation * miscRotation;
+            var angles = finalRotation.eulerAngles;
+
+            if (HandSide == HVRHandSide.Left)
+            {
+                angles.y *= -1f;
+                angles.z *= -1f;
+            }
+
+            if (Teleport)
+            {
+                Teleport.localRotation = _teleportStartRotation * Quaternion.Inverse(grabPointRotation);
+            }
+
+            transform.localEulerAngles = angles;
+        }
+
+        private void ControllerConnected(HVRController controller)
+        {
+            var offsets = HVRInputManager.Instance.ControllerOffsets;
+            if (!offsets)
+            {
+                Debug.LogWarning($"HVRInputManager.ControllerOffsets are not assigned.");
+                return;
+            }
+
+            _offsets = offsets.GetDeviceOffset(controller.Side);
+
+            ApplyOffsets();
+        }
+
+    }
+
+}