Feature - Hand Controllers + Simulation - CORE

XRTK-Core/Packages/com.xrtk.core/Definitions/Controllers/Hands/BaseHandControllerDataProviderProfile.cs

@@ -0,0 +1,53 @@
+// Copyright (c) XRTK. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+using UnityEngine;
+
+namespace XRTK.Definitions.Controllers.Hands
+{
+    /// <summary>
+    /// Provides additional configuration options for hand data providers.
+    /// </summary>
+    public abstract class BaseHandControllerDataProviderProfile : BaseMixedRealityControllerDataProviderProfile
+    {
+        [Header("General Settings")]
+
+        [SerializeField]
+        [Tooltip("If set, hand mesh data will be read and available for visualization. Disable for optimized performance.")]
+        private bool handMeshingEnabled = false;
+
+        /// <summary>
+        /// If set, hand mesh data will be read and available for visualization. Disable for optimized performance.
+        /// </summary>
+        public bool HandMeshingEnabled => handMeshingEnabled;
+
+        [Header("Hand Physics")]
+
+        [SerializeField]
+        [Tooltip("If set, hands will be setup with colliders and a rigidbody to work with Unity's physics system.")]
+        private bool handPhysicsEnabled = false;
+
+        /// <summary>
+        /// If set, hands will be setup with colliders and a rigidbody to work with Unity's physics system.
+        /// </summary>
+        public bool HandPhysicsEnabled => handPhysicsEnabled;
+
+        [SerializeField]
+        [Tooltip("If set, hand colliders will be setup as triggers.")]
+        private bool useTriggers = false;
+
+        /// <summary>
+        /// If set, hand colliders will be setup as triggers.
+        /// </summary>
+        public bool UseTriggers => useTriggers;
+
+        [SerializeField]
+        [Tooltip("Set the bounds mode to use for calculating hand bounds.")]
+        private HandBoundsMode boundsMode = HandBoundsMode.Hand;
+
+        /// <summary>
+        /// Set the bounds mode to use for calculating hand bounds.
+        /// </summary>
+        public HandBoundsMode BoundsMode => boundsMode;
+    }
+}

XRTK-Core/Packages/com.xrtk.core/Definitions/Controllers/Hands/HandBoundsMode.cs

@@ -0,0 +1,22 @@
+// Copyright (c) XRTK. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+namespace XRTK.Definitions.Controllers.Hands
+{
+    /// <summary>
+    /// Available hand bounds modes.
+    /// </summary>
+    public enum HandBoundsMode
+    {
+        /// <summary>
+        /// Hand bounds mode will only calculate a single bounding
+        /// box encapsulating the whole hand.
+        /// </summary>
+        Hand,
+        /// <summary>
+        /// Fingers bounds mode will create precise bounds for each finger
+        /// and the palm to allow for more precise interactions.
+        /// </summary>
+        Fingers
+    }
+}

XRTK-Core/Packages/com.xrtk.core/Definitions/Controllers/Hands/HandData.cs

@@ -0,0 +1,40 @@
+// Copyright (c) XRTK. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+using System;
+using XRTK.Definitions.Utilities;
+
+namespace XRTK.Definitions.Controllers.Hands
+{
+    /// <summary>
+    /// Snapshot of hand data.
+    /// </summary>
+    [Serializable]
+    public class HandData
+    {
+        /// <summary>
+        /// Gets the total count of joints the hand data supports.
+        /// </summary>
+        public static readonly int JointCount = Enum.GetNames(typeof(TrackedHandJoint)).Length;
+
+        /// <summary>
+        /// Timestamp of hand data, as FileTime, e.g. <see cref="DateTime.UtcNow"/>
+        /// </summary>
+        public long TimeStamp { get; set; } = 0;
+
+        /// <summary>
+        /// Is the hand currently being tracked by the system?
+        /// </summary>
+        public bool IsTracked { get; set; } = false;
+
+        /// <summary>
+        /// Pose information for each hand joint.
+        /// </summary>
+        public MixedRealityPose[] Joints { get; } = new MixedRealityPose[JointCount];
+
+        /// <summary>
+        /// Mesh information of the hand.
+        /// </summary>
+        public HandMeshData Mesh { get; set; } = new HandMeshData();
+    }
+}

XRTK-Core/Packages/com.xrtk.core/Definitions/Controllers/Hands/HandMeshData.cs

@@ -0,0 +1,67 @@
+// Copyright (c) XRTK. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+using UnityEngine;
+
+namespace XRTK.Definitions.Controllers.Hands
+{
+    /// <summary>
+    /// Snapshot of hand mesh information.
+    /// </summary>
+    public struct HandMeshData
+    {
+        /// <summary>
+        /// Constructs a new hand mesh data snapshot.
+        /// </summary>
+        /// <param name="vertices"></param>
+        /// <param name="triangles"></param>
+        /// <param name="normals"></param>
+        /// <param name="uvs"></param>
+        /// <param name="position"></param>
+        /// <param name="rotation"></param>
+        public HandMeshData(Vector3[] vertices, int[] triangles, Vector3[] normals, Vector2[] uvs, Vector3 position, Quaternion rotation)
+        {
+            Vertices = vertices;
+            Triangles = triangles;
+            Normals = normals;
+            Uvs = uvs;
+            Position = position;
+            Rotation = rotation;
+        }
+
+        /// <summary>
+        /// The vertices of the hand mesh in the initial coordinate system.
+        /// </summary>
+        public Vector3[] Vertices { get; }
+
+        /// <summary>
+        /// Mesh triangle indices.
+        /// </summary>
+        public int[] Triangles { get; }
+
+        /// <summary>
+        /// Hand mesh normals, in initial coordinate system.
+        /// </summary>
+        public Vector3[] Normals { get; }
+
+        /// <summary>
+        /// UV mapping of the hand. 
+        /// </summary>
+        public Vector2[] Uvs { get; }
+
+        /// <summary>
+        /// Translation to apply to mesh to go from initial coordinates to world coordinates.
+        /// </summary>
+        public Vector3 Position { get; }
+
+        /// <summary>
+        /// Rotation to apply to mesh to go from initial coordinates to world coordinates.
+        /// </summary>
+        public Quaternion Rotation { get; }
+
+        /// <summary>
+        /// Returns true, if the mesh data is empty.
+        /// </summary>
+        public bool Empty => Vertices == null || Vertices.Length == 0;
+    }
+}

XRTK-Core/Packages/com.xrtk.core/Definitions/Controllers/Hands/MixedRealityHandControllerMappingProfile.cs

@@ -0,0 +1,36 @@
+// Copyright (c) XRTK. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+using UnityEngine;
+using XRTK.Definitions.Devices;
+using XRTK.Definitions.Utilities;
+using XRTK.Providers.Controllers;
+using XRTK.Providers.Controllers.Hands;
+
+namespace XRTK.Definitions.Controllers.Hands
+{
+    [CreateAssetMenu(menuName = "Mixed Reality Toolkit/Input System/Controller Mappings/Hand Controller Mapping Profile", fileName = "HandControllerMappingProfile")]
+    public class MixedRealityHandControllerMappingProfile : BaseMixedRealityControllerMappingProfile
+    {
+        /// <inheritdoc />
+        public override SupportedControllerType ControllerType => SupportedControllerType.Hand;
+
+        /// <inheritdoc />
+        public override string TexturePath => $"{base.TexturePath}Hand";
+
+        /// <inheritdoc />
+        protected override void Awake()
+        {
+            if (!HasSetupDefaults)
+            {
+                ControllerMappings = new[]
+                {
+                    new MixedRealityControllerMapping("Hand Controller Left", typeof(MixedRealityHandController), Handedness.Left),
+                    new MixedRealityControllerMapping("Hand Controller Right", typeof(MixedRealityHandController), Handedness.Right)
+                };
+            }
+
+            base.Awake();
+        }
+    }
+}

XRTK-Core/Packages/com.xrtk.core/Definitions/Controllers/Hands/RecordedHandJoint.cs

@@ -0,0 +1,79 @@
+// Copyright (c) XRTK. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+using System;
+using UnityEngine;
+using XRTK.Definitions.Utilities;
+
+namespace XRTK.Definitions.Controllers.Hands
+{
+    /// <summary>
+    /// Unity's <see cref="JsonUtility"/> "currently" (stated in 2011) does not support top-level arrays.
+    /// But hey, it's on their "future" road-map. That's why we need a wrapper definition around or items.
+    /// </summary>
+    /// <remarks>The <see cref="JsonUtility"/> also does not support properties, so we gotta use fields. Oh and it also
+    /// does not support auto mapping of JSON naming "items" to C# naming "Items".</remarks>
+    [Serializable]
+    public class RecordedHandJoints
+    {
+        /// <summary>
+        /// Gets the joints recorded in this data set.
+        /// </summary>
+        public RecordedHandJoint[] items;
+    }
+
+    /// <summary>
+    /// A single recorded hand joint's information that may be used to restore the joint pose for simulation.
+    /// </summary>
+    [Serializable]
+    public struct RecordedHandJoint
+    {
+        /// <summary>
+        /// Constructs a new joint record.
+        /// </summary>
+        /// <param name="joint"></param>
+        /// <param name="pose"></param>
+        public RecordedHandJoint(TrackedHandJoint joint, MixedRealityPose pose)
+        {
+            this.joint = JointNames[(int)joint];
+            this.pose = pose;
+        }
+
+        private static readonly string[] JointNames = Enum.GetNames(typeof(TrackedHandJoint));
+
+        /// <summary>
+        /// Name of the joint recorded. Rather use <see cref="JointIndex"/> below for convenience.
+        /// </summary>
+        public string joint;
+
+        /// <summary>
+        /// The recorded pose.
+        /// </summary>
+        public MixedRealityPose pose;
+
+        /// <summary>
+        /// Gets the <see cref="TrackedHandJoint"/> this record represents.
+        /// </summary>
+        public TrackedHandJoint JointIndex
+        {
+            get
+            {
+                int nameIndex = Array.FindIndex(JointNames, IsJointName);
+
+                if (nameIndex < 0)
+                {
+                    Debug.LogError($"Joint name {joint} not in {nameof(TrackedHandJoint)} enum");
+                    return TrackedHandJoint.None;
+                }
+
+                return (TrackedHandJoint)nameIndex;
+            }
+            set => joint = JointNames[(int)value];
+        }
+
+        private bool IsJointName(string s)
+        {
+            return string.Equals(s, joint);
+        }
+    }
+}