Replace UltimateXR with HurricaneVR

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

@@ -0,0 +1,217 @@
+using System;
+using HurricaneVR.Framework.Core.ScriptableObjects;
+using HurricaneVR.Framework.Core.Utils;
+using HurricaneVR.Framework.Shared;
+using UnityEngine;
+
+namespace HurricaneVR.Framework.Components
+{
+    /// <summary>
+    /// Helper component to constrain a drawer along the desired movement axis handling the joint creation and limiting for you.
+    /// Joint is constrained between the start and end position which is defined in the component inspector.
+    /// </summary>
+    [RequireComponent(typeof(Rigidbody))]
+    public class HVRPhysicsDrawer : MonoBehaviour
+    {
+        [Header("Settings")]
+        [Tooltip("Axis the drawer will travel on in local space.")]
+        public HVRAxis Axis;
+
+        [Tooltip("Rigidbody to joint to.")]
+        public Rigidbody ConnectedBody;
+
+        [Tooltip("Optional spring that will return to the starting position")]
+        public float Spring = 0;
+
+        [Tooltip("Damper to provide 'friction' to the drawer.")]
+        public float Damper = 10;
+
+        [Header("SFX")]
+        public float SFXResetThreshold = .02f;
+        public AudioClip SFXOpened;
+        public AudioClip SFXClosed;
+
+        [Header("Editor Fields")]
+        [Tooltip("The resting position of the button")]
+        public Vector3 StartPosition;
+
+        [Tooltip("Furthest position the button can travel")]
+        public Vector3 EndPosition;
+
+        public Vector3 OpenPosition;
+
+
+        [Header("Debug")]
+        public bool UpdateSpring;
+        public bool PreviousOpened;
+        public bool Opened;
+        public bool PreviousClosed;
+        public bool Closed;
+
+        public Rigidbody Rigidbody { get; private set; }
+
+        private Vector3 _axis;
+        private ConfigurableJoint _joint;
+        private ConfigurableJoint _limitJoint;
+
+
+        protected virtual void Awake()
+        {
+            transform.localPosition = StartPosition;
+            Rigidbody = GetComponent<Rigidbody>();
+            _axis = Axis.GetVector();
+            Rigidbody.useGravity = false;
+            SetupJoint();
+
+            //set initial values to prevent sfx on start
+            GetValues(out var distance, out var openedDistance, out var resetThreshold);
+
+            if (distance > openedDistance)
+            {
+                Opened = true;
+            }
+            else if (distance < openedDistance)
+            {
+                Closed = true;
+            }
+        }
+
+        private void SetupJoint()
+        {
+            _joint = gameObject.AddComponent<ConfigurableJoint>();
+            _joint.connectedBody = ConnectedBody;
+            _joint.autoConfigureConnectedAnchor = false;
+            _joint.anchor = Vector3.zero;
+
+            var worldStartPosition = StartPosition;
+            if (transform.parent)
+                worldStartPosition = transform.parent.TransformPoint(StartPosition);
+
+            var worldEndPosition = EndPosition;
+            if (transform.parent)
+                worldEndPosition = transform.parent.TransformPoint(EndPosition);
+
+
+            if (ConnectedBody)
+            {
+                _joint.connectedAnchor = ConnectedBody.transform.InverseTransformPoint(worldStartPosition);
+            }
+            else
+            {
+                _joint.connectedAnchor = worldStartPosition;
+            }
+
+            _joint.SetXDrive(Spring, Damper, Spring);
+
+            _joint.LimitXMotion();
+            _joint.LockYMotion();
+            _joint.LockZMotion();
+            _joint.LockAllAngularMotion();
+            _joint.axis = _axis;
+            _joint.secondaryAxis = _joint.axis.OrthogonalVector();
+            _joint.SetLinearLimit(Vector3.Distance(StartPosition, EndPosition));
+
+            _limitJoint = gameObject.AddComponent<ConfigurableJoint>();
+            _limitJoint.connectedBody = ConnectedBody;
+            _limitJoint.autoConfigureConnectedAnchor = false;
+            _limitJoint.anchor = Vector3.zero;
+
+            if (ConnectedBody)
+            {
+                _limitJoint.connectedAnchor = ConnectedBody.transform.InverseTransformPoint(worldEndPosition);
+            }
+            else
+            {
+                _limitJoint.connectedAnchor = worldEndPosition;
+            }
+
+            _limitJoint.LockYMotion();
+            _limitJoint.LockZMotion();
+            _limitJoint.LockAllAngularMotion();
+            _limitJoint.axis = _axis;
+            _limitJoint.secondaryAxis = _joint.axis.OrthogonalVector();
+            _limitJoint.LimitXMotion();
+            _limitJoint.SetLinearLimit(Vector3.Distance(StartPosition, EndPosition));
+        }
+
+
+
+        private void Update()
+        {
+            GetValues(out var distance, out var openedDistance, out var resetThreshold);
+
+            var closeReset = openedDistance + resetThreshold;
+            var openReset = openedDistance - resetThreshold;
+
+            if (!Opened && distance > openedDistance)
+            {
+                Opened = true;
+                if(SFXPlayer.Instance) SFXPlayer.Instance.PlaySFX(SFXOpened, transform.position);
+            }
+            else if (!Closed && distance < openedDistance)
+            {
+                Closed = true;
+                if(SFXPlayer.Instance) SFXPlayer.Instance.PlaySFX(SFXClosed, transform.position);
+            }
+            else if (Opened && distance < openReset)
+            {
+                Opened = false;
+            }
+            else if (Closed && distance > closeReset)
+            {
+                Closed = false;
+            }
+
+            PreviousClosed = Closed;
+            PreviousOpened = Opened;
+        }
+
+        private void GetValues(out float distance, out float openDistance, out float resetDelta)
+        {
+            distance = 0f;
+            openDistance = 0f;
+            resetDelta = SFXResetThreshold;
+            switch (Axis)
+            {
+                case HVRAxis.X:
+                case HVRAxis.NegX:
+                    distance = transform.localPosition.x - StartPosition.x;
+                    openDistance = OpenPosition.x - StartPosition.x;
+                    break;
+                case HVRAxis.Y:
+                case HVRAxis.NegY:
+                    distance = transform.localPosition.y - StartPosition.y;
+                    openDistance = OpenPosition.y - StartPosition.y;
+                    break;
+                case HVRAxis.Z:
+                case HVRAxis.NegZ:
+                    distance = transform.localPosition.z - StartPosition.z;
+                    openDistance = OpenPosition.z - StartPosition.z;
+                    break;
+            }
+
+            distance = Mathf.Abs(distance);
+            openDistance = Mathf.Abs(openDistance);
+
+            if (resetDelta > openDistance)
+            {
+                resetDelta = openDistance * .5f;
+            }
+        }
+
+        private void OnDrawGizmosSelected()
+        {
+            var forward = (EndPosition - StartPosition).normalized;
+            var closeReset = transform.parent.TransformPoint(OpenPosition + (forward * SFXResetThreshold));
+            var openReset = transform.parent.TransformPoint(OpenPosition - (forward * SFXResetThreshold));
+
+            Gizmos.color = Color.red;
+            Gizmos.DrawWireSphere(closeReset, .005f);
+            Gizmos.color = Color.green;
+            Gizmos.DrawWireSphere(openReset, .005f);
+            Gizmos.color = Color.blue;
+            Gizmos.DrawWireSphere(transform.parent.TransformPoint(OpenPosition), .005f);
+        }
+    }
+
+}