Haptic throttle deadzone

Assets/Scenes/EVRC.unity

@@ -3683,6 +3683,9 @@ MonoBehaviour:
   m_Name: 
   m_EditorClassIdentifier: 
   actionsController: {fileID: 1840785751}
+  hapticAction:
+    actionPath: /actions/default/out/Haptic
+    needsReinit: 0
 --- !u!1 &750486503
 GameObject:
   m_ObjectHideFlags: 0

Assets/Scripts/ActionsController/IBindingsController.cs

@@ -1,5 +1,6 @@
 namespace EVRC
 {
+    using Hand = ActionsController.Hand;
     using TrackpadInterval = ActionsController.TrackpadInterval;
 
     public enum BindingsHintCategory
@@ -17,5 +18,7 @@ public interface IBindingsController
         bool CanShowBindings();
         void ShowBindings(BindingsHintCategory hintCategory);
         void EditBindings();
+        IHaptics GetHapticsForHand(Hand hand);
+
     }
 }

Assets/Scripts/ActionsController/IHaptics.cs

@@ -0,0 +1,8 @@
+namespace EVRC
+{
+    public interface IHaptics
+    {
+        void ThrottleDetent();
+    }
+}
+

Assets/Scripts/ActionsControllerBindingsLoader.cs

@@ -109,5 +109,20 @@ public void EditBindings()
                 Debug.LogWarning("Bindings Controller not available");
             }
         }
+
+        public IHaptics GetHapticsForHand(Hand hand)
+        {
+            var controller = CurrentController;
+            if (controller != null)
+            {
+                return CurrentController.GetHapticsForHand(hand);
+            }
+            else
+            {
+                Debug.LogWarning("Bindings Controller not available");
+                return null;
+            }
+        }
+
     }
 }

Assets/Scripts/ActionsController_SteamVRInputBindings.cs

@@ -20,6 +20,8 @@ public class ActionsController_SteamVRInputBindings : MonoBehaviour, IBindingsCo
     {
         public ActionsController actionsController;
 
+        public SteamVR_Action_Vibration hapticAction;
+
         private Dictionary<SteamVR_Action_Boolean, InputAction> booleanActionMap = new Dictionary<SteamVR_Action_Boolean, InputAction>();
         private Dictionary<SteamVR_Action_Vector2, InputAction> vector2ActionMap = new Dictionary<SteamVR_Action_Vector2, InputAction>();
         private Dictionary<SteamVR_Action_Boolean, InputAction> trackpadSlideTouchActionMap = new Dictionary<SteamVR_Action_Boolean, InputAction>();
@@ -489,5 +491,10 @@ public void EditBindings()
         {
             SteamVR_Input.OpenBindingUI();
         }
+
+        public IHaptics GetHapticsForHand(Hand hand)
+        {
+            return new SteamVRHaptics(hapticAction, hand);
+        }
     }
 }

Assets/Scripts/SteamVRHaptics.cs

@@ -0,0 +1,23 @@
+using Valve.VR;
+
+namespace EVRC
+{
+    using Hand = ActionsController.Hand;
+
+    public class SteamVRHaptics : IHaptics
+    {
+        SteamVR_Action_Vibration hapticAction;
+        SteamVR_Input_Sources inputSource;
+
+        public SteamVRHaptics(SteamVR_Action_Vibration hapticAction, Hand hand)
+        {
+            this.hapticAction = hapticAction;
+            inputSource = ActionsController_SteamVRInputBindings.GetInputSourceForHand(hand);
+        }
+
+        public void ThrottleDetent()
+        {
+            hapticAction.Execute(0, 0.15f, 10, 0.15f, inputSource);
+        }
+    }
+}

Assets/Scripts/VirtualThrottle.cs

@@ -1,8 +1,16 @@
-using System;
-using UnityEngine;
+using UnityEngine;
 
 namespace EVRC
 {
+    enum ThrottleState
+    {
+        Forward,
+        ForwardIdleDetent,
+        Idle,
+        ReverseIdleDetent,
+        Reverse,
+    }
+
     /**
      * A virtual 1-axis movable throttle that outputs to vJoy when grabbed
      */
@@ -21,6 +29,7 @@ public class VirtualThrottle : MonoBehaviour, IGrabable, IHighlightable
         private bool highlighted = false;
         private ControllerInteractionPoint attachedInteractionPoint;
         private Transform attachPoint;
+        private ThrottleState state = ThrottleState.Idle;
 
         public GrabMode GetGrabMode()
         {
@@ -93,6 +102,13 @@ public void Ungrabbed(ControllerInteractionPoint interactionPoint)
                 {
                     buttons.Ungrabbed();
                 }
+
+                var throttle = handle.localPosition.z / magnitudeLength;
+                if (Mathf.Abs(throttle) < output.throttleDeadzonePercentage)
+                {
+                    handle.localPosition = Vector3.zero;
+                    state = ThrottleState.Idle;
+                }
             }
         }
 
@@ -142,10 +158,19 @@ void LateUpdate()
 
             var t = attachPoint;
             handle.position = t.position;
-            handle.localPosition = new Vector3(
-                0,
-                0,
-                Mathf.Clamp(handle.localPosition.z, -magnitudeLength, magnitudeLength));
+
+            var localMagnitude = Mathf.Clamp(handle.localPosition.z, -magnitudeLength, magnitudeLength);
+            var throttle = localMagnitude / magnitudeLength;
+            if (Mathf.Abs(throttle) < detentSize)
+            {
+                MoveThrottleToIdleDetent();
+            }
+            else
+            {
+                handle.localPosition = new Vector3(0, 0, localMagnitude);
+            }
+
+            CheckStateChange(throttle);
         }
 
         void Update()
@@ -156,5 +181,108 @@ void Update()
             var throttle = handle.localPosition.z / magnitudeLength;
             output.SetThrottle(throttle);
         }
+
+        private float detentSize
+        {
+            get
+            {
+                return output.throttleDeadzonePercentage / 100f;
+            }
+        }
+
+        private float reverseDetentSize
+        {
+            get
+            {
+                return 3 * detentSize;
+            }
+        }
+
+
+        private void CheckStateChange(float throttle)
+        {
+            switch (state)
+            {
+                case ThrottleState.Forward:
+                    if (throttle < detentSize)
+                    {
+                        state = ThrottleState.ForwardIdleDetent;
+                        EmitHapticDetent();
+                    }
+                    break;
+
+                case ThrottleState.ForwardIdleDetent:
+                    if (throttle < -reverseDetentSize)
+                    {
+                        state = ThrottleState.Reverse;
+                        EmitHapticDetent();
+                    }
+                    else if (throttle > detentSize)
+                    {
+                        state = ThrottleState.Forward;
+                        EmitHapticDetent();
+                    }
+                    else
+                    {
+                        MoveThrottleToIdleDetent();
+                    }
+                    break;
+
+                case ThrottleState.Idle:
+                    if (throttle > detentSize)
+                    {
+                        state = ThrottleState.Forward;
+                        EmitHapticDetent();
+                    }
+                    else if (throttle < -detentSize)
+                    {
+                        state = ThrottleState.Reverse;
+                        EmitHapticDetent();
+                    }
+                    else
+                    {
+                        MoveThrottleToIdleDetent();
+                    }
+                    break;
+
+                case ThrottleState.ReverseIdleDetent:
+                    if (throttle > reverseDetentSize)
+                    {
+                        state = ThrottleState.Forward;
+                        EmitHapticDetent();
+                    }
+                    else if (throttle < -detentSize)
+                    {
+                        state = ThrottleState.Reverse;
+                        EmitHapticDetent();
+                    }
+                    else
+                    {
+                        MoveThrottleToIdleDetent();
+                    }
+                    break;
+
+                case ThrottleState.Reverse:
+                    if (throttle > -detentSize)
+                    {
+                        state = ThrottleState.ReverseIdleDetent;
+                        EmitHapticDetent();
+                    }
+                    break;
+            }
+        }
+
+        private void MoveThrottleToIdleDetent()
+        {
+            handle.localPosition = Vector3.zero;
+        }
+
+        private void EmitHapticDetent()
+        {
+            var attachment = attachedInteractionPoint;
+            var haptics = ActionsControllerBindingsLoader.CurrentBindingsController
+                .GetHapticsForHand(attachment.Hand);
+            haptics.ThrottleDetent();
+        }
     }
 }