Add haptic and input profiles support

Author: De-Panther

Packages/webxr-interactions/Runtime/InputSystem/InternalSendHapticImpulseCommand.cs

@@ -0,0 +1,28 @@
+#if UNITY_INPUT_SYSTEM_1_4_4_OR_NEWER
+using System.Runtime.InteropServices;
+using UnityEngine.InputSystem.LowLevel;
+using UnityEngine.InputSystem.Utilities;
+
+namespace WebXR.InputSystem
+{
+  [StructLayout(LayoutKind.Explicit, Size = kSize)]
+  internal struct InternalSendHapticImpulseCommand
+  {
+    internal static FourCC Type => new FourCC('X', 'H', 'I', '0');
+
+    private const int kSize = InputDeviceCommand.BaseCommandSize + sizeof(int) + (sizeof(float) * 2);
+
+    [FieldOffset(0)]
+    internal InputDeviceCommand baseCommand;
+
+    [FieldOffset(InputDeviceCommand.BaseCommandSize)]
+    internal int channel;
+
+    [FieldOffset(InputDeviceCommand.BaseCommandSize + sizeof(int))]
+    internal float amplitude;
+
+    [FieldOffset(InputDeviceCommand.BaseCommandSize + sizeof(int) + (sizeof(float)))]
+    internal float duration;
+  }
+}
+#endif

Packages/webxr-interactions/Runtime/InputSystem/InternalSendHapticImpulseCommand.cs.meta

@@ -4,11 +4,13 @@
     "references": [
         "GUID:fd4abe4ffe74ef1448afe15c6cb36bb7",
         "GUID:75469ad4d38634e559750d17036d5f7c",
-        "GUID:ce522b6ed64c8be4c989a1d26d0e3275"
+        "GUID:ce522b6ed64c8be4c989a1d26d0e3275",
+        "GUID:fe685ec1767f73d42b749ea8045bfe43",
+        "GUID:84a2d09f0bb073f40922f5ea5362abe7"
     ],
     "includePlatforms": [],
     "excludePlatforms": [],
-    "allowUnsafeCode": false,
+    "allowUnsafeCode": true,
     "overrideReferences": false,
     "precompiledReferences": [],
     "autoReferenced": false,
@@ -23,6 +25,11 @@
             "name": "com.unity.xr.hands",
             "expression": "1.1.0",
             "define": "XR_HANDS_1_1_OR_NEWER"
+        },
+        {
+            "name": "com.de-panther.webxr-input-profiles-loader",
+            "expression": "0.4.0",
+            "define": "WEBXR_INPUT_PROFILES"
         }
     ],
     "noEngineReferences": false

Packages/webxr-interactions/Runtime/InputSystem/WebXR.InputSystem.asmdef

@@ -144,10 +144,10 @@ public struct WebXRControllerState : IInputStateTypeInfo
     [InputControl(bit = 0, offset = 48, sizeInBits = 1, layout = "Button")]
     public bool isTracked;
 
-    [InputControl(bit = 0, offset = 52, layout = "Vector3")]
+    [InputControl(bit = 0, offset = 52, layout = "Vector3", alias = "gripPosition")]
     public Vector3 devicePosition;
 
-    [InputControl(bit = 0, offset = 64, layout = "Quaternion")]
+    [InputControl(bit = 0, offset = 64, layout = "Quaternion", alias = "gripOrientation")]
     public Quaternion deviceRotation;
 
     [InputControl(bit = 0, offset = 80, layout = "Vector3", noisy = true, dontReset = true)]

Packages/webxr-interactions/Runtime/InputSystem/WebXRInputDevices.cs

@@ -1,8 +1,9 @@
 using UnityEngine;
-using InputDevice = UnityEngine.XR.InputDevice;
+using UnityEngine.Events;
 #if UNITY_INPUT_SYSTEM_1_4_4_OR_NEWER
 using UnityEngine.InputSystem;
 using UnityEngine.InputSystem.Layouts;
+using UnityEngine.InputSystem.LowLevel;
 #if XR_HANDS_1_1_OR_NEWER
 using System.Collections;
 using System.Collections.Generic;
@@ -19,15 +20,35 @@ namespace WebXR.InputSystem
 #endif
   public class WebXRInputSystem : MonoBehaviour
   {
-    public Transform[] leftHandTransforms;
-    public Transform[] rightHandTransforms;
-    private Pose[] leftPoses;
-    private Pose[] rightPoses;
-    public Vector3 rightPos;
-    public Vector3 leftPos;
-    public Vector3 headPos;
-    public int devicesType;
+    [SerializeField]
+    private UnityEvent onLeftControllerProfiles;
+    public UnityEvent OnLeftControllerProfiles
+    {
+      get => onLeftControllerProfiles;
+      set => onLeftControllerProfiles = value;
+    }
+    
+    [SerializeField]
+    private UnityEvent onRightControllerProfiles;
+    public UnityEvent OnRightControllerProfiles
+    {
+      get => onRightControllerProfiles;
+      set => onRightControllerProfiles = value;
+    }
+    private string[] leftProfiles = null;
+    private string[] rightProfiles = null;
+    private bool hasLeftProfiles = false;
+    private bool hasRightProfiles = false;
 
+    public string[] GetLeftProfiles()
+    {
+      return leftProfiles;
+    }
+    
+    public string[] GetRightProfiles()
+    {
+      return rightProfiles;
+    }
 #if UNITY_INPUT_SYSTEM_1_4_4_OR_NEWER
     private static bool initialized = false;
     WebXRController left = null;
@@ -65,19 +86,15 @@ private void Awake()
         }
       }
       subsystemUpdater = new XRHandProviderUtility.SubsystemUpdater(webXRHandsSubsystem);
-      
-      leftPoses = new Pose[leftHandTransforms.Length];
-      rightPoses = new Pose[rightHandTransforms.Length];
-      for (int i = 0; i < leftHandTransforms.Length; i++)
-      {
-        leftPoses[i] = new Pose(leftHandTransforms[i].position, leftHandTransforms[i].rotation);
-        rightPoses[i] = new Pose(rightHandTransforms[i].position, rightHandTransforms[i].rotation);
-      }
 #endif
     }
 
     private void OnEnable()
     {
+      unsafe
+      {
+        InputSystem.onDeviceCommand += HandleOnDeviceCommand;
+      }
       WebXRManager.OnXRChange += OnXRChange;
       WebXRManager.OnHeadsetUpdate += OnHeadsetUpdate;
       WebXRManager.OnControllerUpdate += OnControllerUpdate;
@@ -90,6 +107,10 @@ private void OnEnable()
 
     private void OnDisable()
     {
+      unsafe
+      {
+        InputSystem.onDeviceCommand -= HandleOnDeviceCommand;
+      }
       RemoveAllDevices();
       WebXRManager.OnXRChange -= OnXRChange;
       WebXRManager.OnHeadsetUpdate -= OnHeadsetUpdate;
@@ -121,64 +142,26 @@ private void OnDestroy()
     }
 #endif
 
-    /*
-    private void Update1()
+    private unsafe long? HandleOnDeviceCommand(
+      UnityEngine.InputSystem.InputDevice inputDevice,
+      InputDeviceCommand* command)
     {
-      OnHeadsetUpdate(
-        Matrix4x4.identity,
-        Matrix4x4.identity,
-        Quaternion.identity,
-        Quaternion.identity,
-        headPos,
-        headPos
-      );
-      WebXRHandData handDataLeft = new();
-      handDataLeft.frame = Time.frameCount;
-      handDataLeft.enabled = devicesType == 2;
-      handDataLeft.hand = 1;
-      handDataLeft.trigger = 1;
-      for (int i = 0; i < handDataLeft.joints.Length; i++)
+      if (inputDevice != left && inputDevice != right)
       {
-        handDataLeft.joints[i].radius = 0.01f;
-        handDataLeft.joints[i].position = leftPoses[i].position;
-        handDataLeft.joints[i].rotation = leftPoses[i].rotation;
-        handDataLeft.joints[i].position += leftPos;
+        return null;
       }
-      OnHandUpdate(handDataLeft);
-      WebXRHandData handDataRight = new();
-      handDataRight.frame = Time.frameCount;
-      handDataRight.enabled = devicesType == 2;
-      handDataRight.hand = 2;
-      handDataRight.trigger = 1;
-      for (int i = 0; i < handDataRight.joints.Length; i++)
+      if (command->type != InternalSendHapticImpulseCommand.Type)
       {
-        handDataRight.joints[i].radius = 0.01f;
-        handDataRight.joints[i].position = rightPoses[i].position;
-        handDataRight.joints[i].rotation = rightPoses[i].rotation;
-        handDataRight.joints[i].position += rightPos;
+        return null;
       }
-      OnHandUpdate(handDataRight);
 
-      WebXRControllerData controllerDataLeft = new WebXRControllerData();
-      controllerDataLeft.frame = Time.frameCount;
-      controllerDataLeft.enabled = devicesType == 1;
-      controllerDataLeft.hand = 1;
-      controllerDataLeft.position = leftPos;
-      controllerDataLeft.rotation = Quaternion.identity;
-      controllerDataLeft.gripPosition = leftPos;
-      controllerDataLeft.gripRotation = Quaternion.identity;
-      OnControllerUpdate(controllerDataLeft);
-      WebXRControllerData controllerDataRight = new WebXRControllerData();
-      controllerDataRight.frame = Time.frameCount;
-      controllerDataRight.enabled = devicesType == 1;
-      controllerDataRight.hand = 2;
-      controllerDataRight.position = rightPos;
-      controllerDataRight.rotation = Quaternion.identity;
-      controllerDataRight.gripPosition = rightPos;
-      controllerDataRight.gripRotation = Quaternion.identity;
-      OnControllerUpdate(controllerDataRight);
+      var impulseCommand = *(InternalSendHapticImpulseCommand*)command;
+      WebXRManager.Instance.HapticPulse(
+        inputDevice == left ? WebXRControllerHand.LEFT : WebXRControllerHand.RIGHT,
+        impulseCommand.amplitude,
+        impulseCommand.duration * 1000f);
+      return 0;
     }
-    */
 
     private void OnXRChange(
       WebXRState state,
@@ -232,9 +215,21 @@ private void OnControllerUpdate(WebXRControllerData controllerData)
       {
         case 1:
           UpdateController(controllerData, ref left);
+          if (!hasLeftProfiles && controllerData.profiles != null)
+          {
+            leftProfiles = controllerData.profiles;
+            hasLeftProfiles = true;
+            onLeftControllerProfiles?.Invoke();
+          }
           break;
         case 2:
           UpdateController(controllerData, ref right);
+          if (!hasRightProfiles && controllerData.profiles != null)
+          {
+            rightProfiles = controllerData.profiles;
+            hasRightProfiles = true;
+            onRightControllerProfiles?.Invoke();
+          }
           break;
       }
     }

Packages/webxr-interactions/Runtime/InputSystem/WebXRInputSystem.cs

@@ -106,6 +106,7 @@ public void ToggleVR()
       subsystem?.ToggleVR();
     }
 
+    // duration in milliseconds
     public void HapticPulse(WebXRControllerHand hand, float intensity, float duration)
     {
       subsystem?.HapticPulse(hand, intensity, duration);