[Input] Add haptic support to OpenVR and Oculus runtimes

sources/engine/Stride.VirtualReality/OculusOVR/OculusOVR.cpp

@@ -463,6 +463,15 @@ extern "C" {
 	{
 		ovr_GetAudioDeviceOutGuidStr(deviceString);
 	}
+
+	DLL_EXPORT_API void xnOvrSetLeftVibration(xnOvrSession* session, float frequency, float amplitude) 
+	{
+		ovr_SetControllerVibration(session->Session, ovrControllerType_LTouch, frequency, amplitude);
+	}
+	DLL_EXPORT_API void xnOvrSetRightVibration(xnOvrSession* session, float frequency, float amplitude) 
+	{
+		ovr_SetControllerVibration(session->Session, ovrControllerType_RTouch, frequency, amplitude);
+	}
 }
 
 #else
@@ -587,6 +596,14 @@ extern "C" {
 	DLL_EXPORT_API void xnOvrSetQuadLayerParams(void* layer, float* position, float* orientation, float* size, npBool headLocked)
 	{
 	}
+
+	DLL_EXPORT_API void xnOvrSetLeftVibration(void* session, float frequency, float amplitude)
+	{
+	}
+	DLL_EXPORT_API void xnOvrSetRightVibration(void* session, float frequency, float amplitude)
+	{
+	}
+
 }
 
 #endif

sources/engine/Stride.VirtualReality/OculusOVR/OculusOVR.cs

@@ -224,5 +224,19 @@ public static string GetAudioDeviceFullName()
             GetAudioDeviceID(deviceName);
             return $"\\\\?\\SWD#MMDEVAPI#{deviceName}#{{e6327cad-dcec-4949-ae8a-991e976a79d2}}"; //this should not change the guid is related to audio device type
         }
+
+        [SuppressUnmanagedCodeSecurity]
+        [DllImport(NativeInvoke.Library, EntryPoint = "xnOvrSetLeftVibration", CallingConvention = CallingConvention.Cdecl)]
+        static extern void SetLeftVibration(IntPtr session, float frequency, float amplitude);
+        [SuppressUnmanagedCodeSecurity]
+        [DllImport(NativeInvoke.Library, EntryPoint = "xnOvrSetRightVibration", CallingConvention = CallingConvention.Cdecl)]
+        static extern void SetRightVibration(IntPtr session, float frequency, float amplitude);
+        public static void SetVibration(IntPtr session, TouchControllerHand hand, float frequency, float amplitude)
+        {
+            if (hand == TouchControllerHand.Left)
+                SetLeftVibration(session, frequency, amplitude);
+            else
+                SetRightVibration(session, frequency, amplitude);
+        }
     }
 }

sources/engine/Stride.VirtualReality/OculusOVR/OculusOvrHmd.cs

@@ -83,8 +83,8 @@ public override void Enable(GraphicsDevice device, GraphicsDeviceManager graphic
 
             ActualRenderFrameSize = new Size2(textures[0].Width, textures[0].Height);
 
-            leftHandController = new OculusTouchController(TouchControllerHand.Left);
-            rightHandController = new OculusTouchController(TouchControllerHand.Right);
+            leftHandController = new OculusTouchController(TouchControllerHand.Left, ovrSession);
+            rightHandController = new OculusTouchController(TouchControllerHand.Right, ovrSession);
         }
 
         private OculusOvr.PosesProperties currentPoses;
@@ -162,7 +162,7 @@ public override bool CanInitialize
                 return initDone;
             }
         }
-        
+
         public override void Recenter()
         {
             OculusOvr.Recenter(ovrSession);

sources/engine/Stride.VirtualReality/OculusOVR/OculusTouchController.cs

@@ -1,6 +1,7 @@
 // Copyright (c) .NET Foundation and Contributors (https://dotnetfoundation.org/ & https://stride3d.net) and Silicon Studio Corp. (https://www.siliconstudio.co.jp)
 // Distributed under the MIT license. See the LICENSE.md file in the project root for more information.
 using System;
+using System.Threading.Tasks;
 using Stride.Core.Mathematics;
 
 namespace Stride.VirtualReality
@@ -23,6 +24,10 @@ internal class OculusTouchController : TouchController
         private uint previousButtonsState;
         private Vector2 currentThumbstick;
         private const float TriggerAndGripDeadzone = 0.00001f;
+        private IntPtr OvrSession { get; }
+        //Number of calls to vibrate that are currently executing
+        private int vibrationCount;
+        private readonly object vibrationLock = new();
 
         public override Vector3 Position => currentPos;
 
@@ -137,10 +142,12 @@ public override bool ThumbResting
         public override Vector2 ThumbAxis => currentThumbstick;
 
         public override Vector2 ThumbstickAxis => currentThumbstick;
+        public override ControllerHaptics HapticsSupport => ControllerHaptics.LimitedFrequency;
 
-        public OculusTouchController(TouchControllerHand hand)
+        public OculusTouchController(TouchControllerHand hand, IntPtr OvrSession)
         {
             this.hand = hand;
+            this.OvrSession = OvrSession;
             currentState = DeviceState.Invalid;
         }
 
@@ -399,5 +406,32 @@ public override bool IsTouchReleased(TouchControllerButton button)
                     return false;
             }
         }
+
+        public override async Task Vibrate(int durationMs, float frequency, float amplitude)
+        {
+            void SetOvrVibration(bool enable)
+            {
+                float freqParam = enable ? frequency : 0;
+                float ampParam = enable ? amplitude : 0;
+                OculusOvr.SetVibration(OvrSession, hand, freqParam, ampParam);
+            }
+            lock (vibrationLock)
+            {
+                vibrationCount++;
+            }
+            while (durationMs > 2400)
+            {
+                SetOvrVibration(true);
+                durationMs -= 2400;
+                await Task.Delay(2400);
+            }
+            SetOvrVibration(true);
+            await Task.Delay(durationMs);
+            lock (vibrationLock)
+            {
+                if (--vibrationCount == 0)
+                    SetOvrVibration(false);
+            }
+        }
     }
 }

sources/engine/Stride.VirtualReality/OpenVR/OpenVrTouchController.cs

@@ -2,7 +2,7 @@
 // Distributed under the MIT license. See the LICENSE.md file in the project root for more information.
 #if STRIDE_GRAPHICS_API_DIRECT3D11
 
-using System;
+using System.Threading.Tasks;
 using Stride.Core.Mathematics;
 using Stride.Games;
 
@@ -75,13 +75,14 @@ public override void Update(GameTime gameTime)
         public override Vector2 ThumbAxis => controller?.GetAxis() ?? Vector2.Zero;
 
         public override Vector2 ThumbstickAxis => controller?.GetAxis() ?? Vector2.Zero;
+        public override ControllerHaptics HapticsSupport => ControllerHaptics.Limited;
 
         private OpenVR.Controller.ButtonId ToOpenVrButton(TouchControllerButton button)
         {
             switch (button)
             {
                 case TouchControllerButton.Thumbstick:
-                    return OpenVR.Controller.ButtonId.ButtonSteamVrTouchpad;              
+                    return OpenVR.Controller.ButtonId.ButtonSteamVrTouchpad;
                 case TouchControllerButton.Trigger:
                     return OpenVR.Controller.ButtonId.ButtonSteamVrTrigger;
                 case TouchControllerButton.Grip:
@@ -123,6 +124,17 @@ public override bool IsTouchReleased(TouchControllerButton button)
             return controller?.GetTouchUp(ToOpenVrButton(button)) ?? false;
         }
 
+        public override async Task Vibrate(int durationMs, float frequency, float amplitude)
+        {
+            while (durationMs > 60)
+            {
+                Valve.VR.OpenVR.System.TriggerHapticPulse((uint)controllerIndex + 1, 0, 1000 * 60);
+                durationMs -= 60;
+                await Task.Delay(60);
+            }
+            Valve.VR.OpenVR.System.TriggerHapticPulse((uint)controllerIndex + 1, 0, (ushort)(1000 * durationMs));
+        }
+
         public override Vector3 Position => currentPos;
 
         public override Quaternion Rotation => currentRot;

sources/engine/Stride.VirtualReality/OpenXR/OpenXRInput.cs

@@ -2,7 +2,6 @@
 
 using System;
 using System.Collections.Generic;
-using System.Text;
 using Silk.NET.Core.Native;
 using Silk.NET.OpenXR;
 
@@ -218,9 +217,9 @@ public float GetActionFloat(TouchControllerHand hand, TouchControllerButton butt
         private static unsafe void Initialize(OpenXRHmd hmd)
         {
             // make actions
-            for (int i=0; i<HAND_PATH_COUNT; i++)
+            for (int i = 0; i < HAND_PATH_COUNT; i++)
             {
-                for (int j=0; j<2; j++)
+                for (int j = 0; j < 2; j++)
                 {
                     ActionCreateInfo action_info = new ActionCreateInfo()
                     {
@@ -240,21 +239,21 @@ private static unsafe void Initialize(OpenXRHmd hmd)
             }
 
             // probe bindings for all profiles
-            for (int i=0; i<InteractionProfiles.Length; i++)
+            for (int i = 0; i < InteractionProfiles.Length; i++)
             {
                 ulong profile = 0;
                 hmd.Xr.StringToPath(hmd.Instance, InteractionProfiles[i], ref profile);
 
                 List<ActionSuggestedBinding> bindings = new List<ActionSuggestedBinding>();
                 // for each hand...
-                for (int hand=0; hand<2; hand++)
+                for (int hand = 0; hand < 2; hand++)
                 {
                     // for each path we want to bind...
-                    for (int path=0; path<HAND_PATH_COUNT; path++)
+                    for (int path = 0; path < HAND_PATH_COUNT; path++)
                     {
                         // list all possible paths that might be valid and pick the first one
                         List<string> possiblePaths = PathPriorities[path];
-                        for (int pathattempt=0; pathattempt<possiblePaths.Count; pathattempt++)
+                        for (int pathattempt = 0; pathattempt < possiblePaths.Count; pathattempt++)
                         {
                             // get the hand at the start, then put in the attempt
                             string final_path = hand == (int)TouchControllerHand.Left ? "/user/hand/left" : "/user/hand/right";

sources/engine/Stride.VirtualReality/OpenXR/OpenXrTouchController.cs

@@ -1,8 +1,6 @@
 #nullable enable
 
-using System;
-using System.Collections.Generic;
-using System.Text;
+using System.Threading.Tasks;
 using Silk.NET.OpenXR;
 using Stride.Core.Mathematics;
 using Stride.Games;
@@ -72,6 +70,7 @@ public OpenXrTouchController(OpenXRHmd hmd, OpenXRInput input, TouchControllerHa
         public override Vector2 ThumbstickAxis => GetAxis((int)TouchControllerButton.Thumbstick);
 
         public override Vector2 ThumbAxis => GetAxis((int)TouchControllerButton.Touchpad);
+        public override ControllerHaptics HapticsSupport => ControllerHaptics.None;
 
         public Vector2 GetAxis(int index)
         {
@@ -170,5 +169,8 @@ public override unsafe void Update(GameTime time)
                 currentRot.W = handLocation.Pose.Orientation.W;
             }
         }
+
+        //TODO: Make controller vibrate for duration
+        public override async Task Vibrate(int duration, float frequency, float amplitude) { }
     }
 }

sources/engine/Stride.VirtualReality/TouchController.cs

@@ -1,6 +1,7 @@
 // Copyright (c) .NET Foundation and Contributors (https://dotnetfoundation.org/ & https://stride3d.net) and Silicon Studio Corp. (https://www.siliconstudio.co.jp)
 // Distributed under the MIT license. See the LICENSE.md file in the project root for more information.
 using System;
+using System.Threading.Tasks;
 using Stride.Core.Mathematics;
 using Stride.Games;
 
@@ -19,7 +20,7 @@ public abstract class TouchController : IDisposable
         public abstract DeviceState State { get; }
 
         public virtual void Update(GameTime time)
-        {           
+        {
         }
 
         public abstract float Trigger { get; }
@@ -38,6 +39,22 @@ public virtual void Update(GameTime time)
 
         public abstract Vector2 ThumbstickAxis { get; }
 
+        public enum ControllerHaptics
+        {
+            None,
+            Limited,
+            LimitedFrequency,
+            LimitedAmplitude,
+            Full
+        }
+        /// <summary>
+        /// Degree to which this touch controller type supports haptics.
+        /// None: no haptics support, controller does not vibrate.
+        /// Limited: cannot vibrate at any specific frequency or amplitude. Corresponding parameter is ignored.
+        /// Full: vibrate method respects both frequency and vibration parameters
+        /// </summary>
+        public abstract ControllerHaptics HapticsSupport { get; }
+
         /// <summary>
         /// Returns true if in this frame the button switched to pressed state
         /// </summary>
@@ -80,8 +97,20 @@ public virtual void Update(GameTime time)
         /// <returns></returns>
         public abstract bool IsTouchReleased(TouchControllerButton button);
 
+        /// <summary>
+        /// Vibrate the controller for a fixed duration. Do so at specified frequency/amplitude if supported by runtime.
+        /// Oculus runtime supports vibrating at frequency 0.0, 0.5, or 1.0, and amplitude in range [0.0, 1.0]
+        /// openVR supports vibrating, but does not support frequency or amplitude
+        /// openXR and WindowsMixedReality currently do not support vibration.
+        /// </summary>
+        /// <param name="durationMs">Vibration duration, in milliseconds</param>
+        /// <param name="frequency">Frequency of vibration in range [0.0, 1.0]</param>
+        /// <param name="amplitude">Amplitude of vibration in range [0.0, 1.0]</param>
+        /// <returns></returns>
+        public abstract Task Vibrate(int durationMs, float frequency = 1, float amplitude = 1);
+
         public virtual void Dispose()
-        {          
+        {
         }
     }
 }

sources/engine/Stride.VirtualReality/WindowsMixedReality/WindowsMixedRealityTouchController.cs

@@ -68,6 +68,8 @@ internal WindowsMixedRealityTouchController(TouchControllerHand hand, SpatialInt
         public override bool IsTouchedDown(TouchControllerButton button) => !IsButtonTouched(button, previousState) ? IsButtonTouched(button, currentState) : false;
 
         public override bool IsTouchReleased(TouchControllerButton button) => IsButtonTouched(button, previousState) ? !IsButtonTouched(button, currentState) : false;
+
+        public override ControllerHaptics HapticsSupport => ControllerHaptics.None;
 
         public void Update(PerceptionTimestamp timeStamp, SpatialCoordinateSystem coordinateSystem)
         {
@@ -156,6 +158,9 @@ private void SetSpatialInteractionSourceLocation(SpatialInteractionSourceLocatio
             currentLinearVelocity = location.Velocity?.ToVector3() ?? currentLinearVelocity;
             currentAngularVelocity = location.AngularVelocity?.ToVector3() ?? currentAngularVelocity;
         }
+
+        //TODO: implement this
+        public override async Task Vibrate(int duration, float frequency, float amplitude) { }
     }
 }