clean project

Assets/Oculus/Interaction/Runtime/Scripts/Input/OVRIntegration/AnimatedHandOVR.cs

@@ -0,0 +1,114 @@
+/************************************************************************************
+Copyright : Copyright (c) Facebook Technologies, LLC and its affiliates. All rights reserved.
+
+Your use of this SDK or tool is subject to the Oculus SDK License Agreement, available at
+https://developer.oculus.com/licenses/oculussdk/
+
+Unless required by applicable law or agreed to in writing, the Utilities SDK distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+ANY KIND, either express or implied. See the License for the specific language governing
+permissions and limitations under the License.
+************************************************************************************/
+
+using UnityEngine;
+
+namespace Oculus.Interaction.Input
+{
+    public class AnimatedHandOVR : MonoBehaviour
+    {
+        public const string ANIM_LAYER_NAME_POINT = "Point Layer";
+        public const string ANIM_LAYER_NAME_THUMB = "Thumb Layer";
+        public const string ANIM_PARAM_NAME_FLEX = "Flex";
+
+        public const float INPUT_RATE_CHANGE = 20.0f;
+
+        [SerializeField]
+        private OVRInput.Controller _controller = OVRInput.Controller.None;
+        [SerializeField]
+        private Animator _animator = null;
+
+        private int _animLayerIndexThumb = -1;
+        private int _animLayerIndexPoint = -1;
+        private int _animParamIndexFlex = -1;
+
+        private bool _isPointing = false;
+        private bool _isGivingThumbsUp = false;
+        private float _pointBlend = 0.0f;
+        private float _thumbsUpBlend = 0.0f;
+
+        protected virtual void Start()
+        {
+            _animLayerIndexPoint = _animator.GetLayerIndex(ANIM_LAYER_NAME_POINT);
+            _animLayerIndexThumb = _animator.GetLayerIndex(ANIM_LAYER_NAME_THUMB);
+            _animParamIndexFlex = Animator.StringToHash(ANIM_PARAM_NAME_FLEX);
+        }
+
+        protected virtual void Update()
+        {
+            UpdateCapTouchStates();
+
+            _pointBlend = InputValueRateChange(_isPointing, _pointBlend);
+            _thumbsUpBlend = InputValueRateChange(_isGivingThumbsUp, _thumbsUpBlend);
+
+            UpdateAnimStates();
+        }
+
+        private void UpdateCapTouchStates()
+        {
+            _isPointing = !OVRInput.Get(OVRInput.NearTouch.PrimaryIndexTrigger, _controller);
+            _isGivingThumbsUp = !OVRInput.Get(OVRInput.NearTouch.PrimaryThumbButtons, _controller);
+        }
+
+        /// <summary>
+        /// Based on InputValueRateChange from OVR Samples it ensures
+        /// the animation blending happens with controlled timing instead of instantly
+        /// </summary>
+        /// <param name="isDown">Direction of the animation</param>
+        /// <param name="value">Value to change</param>
+        /// <returns>The input value increased or decreased at a fixed rate</returns>
+        private float InputValueRateChange(bool isDown, float value)
+        {
+            float rateDelta = Time.deltaTime * INPUT_RATE_CHANGE;
+            float sign = isDown ? 1.0f : -1.0f;
+            return Mathf.Clamp01(value + rateDelta * sign);
+        }
+
+        private void UpdateAnimStates()
+        {
+            // Flex
+            // blend between open hand and fully closed fist
+            float flex = OVRInput.Get(OVRInput.Axis1D.PrimaryHandTrigger, _controller);
+            _animator.SetFloat(_animParamIndexFlex, flex);
+
+            // Point
+            _animator.SetLayerWeight(_animLayerIndexPoint, _pointBlend);
+
+            // Thumbs up
+            _animator.SetLayerWeight(_animLayerIndexThumb, _thumbsUpBlend);
+
+            float pinch = OVRInput.Get(OVRInput.Axis1D.PrimaryIndexTrigger, _controller);
+            _animator.SetFloat("Pinch", pinch);
+        }
+
+
+        #region Inject
+
+        public void InjectAllAnimatedHandOVR(OVRInput.Controller controller, Animator animator)
+        {
+            InjectController(controller);
+            InjectAnimator(animator);
+        }
+
+        public void InjectController(OVRInput.Controller controller)
+        {
+            _controller = controller;
+        }
+
+        public void InjectAnimator(Animator animator)
+        {
+            _animator = animator;
+        }
+
+        #endregion
+    }
+}

Assets/Oculus/Interaction/Runtime/Scripts/Input/OVRIntegration/AnimatedHandOVR.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2864da2f393a3e948bb12ec4ac9b1782
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/Interaction/Runtime/Scripts/Input/OVRIntegration/FromOVRControllerDataSource.cs

@@ -0,0 +1,283 @@
+/************************************************************************************
+Copyright : Copyright (c) Facebook Technologies, LLC and its affiliates. All rights reserved.
+
+Your use of this SDK or tool is subject to the Oculus SDK License Agreement, available at
+https://developer.oculus.com/licenses/oculussdk/
+
+Unless required by applicable law or agreed to in writing, the Utilities SDK distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+ANY KIND, either express or implied. See the License for the specific language governing
+permissions and limitations under the License.
+************************************************************************************/
+
+using System;
+using UnityEngine;
+using UnityEngine.Assertions;
+using UnityEngine.Serialization;
+
+namespace Oculus.Interaction.Input
+{
+    struct UsageMapping
+    {
+        public UsageMapping(ControllerButtonUsage usage, OVRInput.Touch touch)
+        {
+            Usage = usage;
+            Touch = touch;
+            Button = OVRInput.Button.None;
+        }
+
+        public UsageMapping(ControllerButtonUsage usage, OVRInput.Button button)
+        {
+            Usage = usage;
+            Touch = OVRInput.Touch.None;
+            Button = button;
+        }
+
+        public bool IsTouch => Touch != OVRInput.Touch.None;
+        public bool IsButton => Button != OVRInput.Button.None;
+        public ControllerButtonUsage Usage { get; }
+        public OVRInput.Touch Touch { get; }
+        public OVRInput.Button Button { get; }
+    }
+
+    /// <summary>
+    /// Returns the Pointer Pose for the active controller model
+    /// as found in the official prefabs.
+    /// This point is usually located at the front tip of the controller.
+    /// </summary>
+    struct OVRPointerPoseSelector
+    {
+        private static readonly Pose[] QUEST1_POINTERS = new Pose[2]
+        {
+            new Pose(new Vector3(-0.00779999979f,-0.00410000002f,0.0375000015f),
+                Quaternion.Euler(359.209534f, 6.45196056f, 6.95544577f)),
+            new Pose(new Vector3(0.00779999979f,-0.00410000002f,0.0375000015f),
+                Quaternion.Euler(359.209534f, 353.548035f, 353.044556f))
+        };
+
+        private static readonly Pose[] QUEST2_POINTERS = new Pose[2]
+        {
+            new Pose(new Vector3(0.00899999961f, -0.00321028521f, 0.030869998f),
+                Quaternion.Euler(359.209534f, 6.45196056f, 6.95544577f)),
+            new Pose(new Vector3(-0.00899999961f, -0.00321028521f, 0.030869998f),
+                Quaternion.Euler(359.209534f, 353.548035f, 353.044556f))
+        };
+
+        public Pose LocalPointerPose { get; private set; }
+
+        public OVRPointerPoseSelector(Handedness handedness)
+        {
+            OVRPlugin.SystemHeadset headset = OVRPlugin.GetSystemHeadsetType();
+            switch (headset)
+            {
+                case OVRPlugin.SystemHeadset.Oculus_Quest_2:
+                case OVRPlugin.SystemHeadset.Oculus_Link_Quest_2:
+                    LocalPointerPose =  QUEST2_POINTERS[(int)handedness];
+                    break;
+                default:
+                    LocalPointerPose = QUEST1_POINTERS[(int)handedness];
+                    break;
+            }
+        }
+    }
+
+    public class FromOVRControllerDataSource : DataSource<ControllerDataAsset, ControllerDataSourceConfig>
+    {
+        [Header("OVR Data Source")]
+        [SerializeField, Interface(typeof(IOVRCameraRigRef))]
+        private MonoBehaviour _cameraRigRef;
+
+        [Header("Shared Configuration")]
+        [SerializeField]
+        private Handedness _handedness;
+
+        [SerializeField, Interface(typeof(ITrackingToWorldTransformer))]
+        private MonoBehaviour _trackingToWorldTransformer;
+        private ITrackingToWorldTransformer TrackingToWorldTransformer;
+
+        [SerializeField, Interface(typeof(IDataSource<HmdDataAsset, HmdDataSourceConfig>))]
+        private MonoBehaviour _hmdData;
+        private IDataSource<HmdDataAsset, HmdDataSourceConfig> HmdData;
+
+        private readonly ControllerDataAsset _controllerDataAsset = new ControllerDataAsset();
+        private OVRInput.Controller _ovrController;
+        private Transform _ovrControllerAnchor;
+        private ControllerDataSourceConfig _config;
+
+        private OVRPointerPoseSelector _pointerPoseSelector;
+
+        public IOVRCameraRigRef CameraRigRef { get; private set; }
+
+        #region OVR Controller Mappings
+
+        // Mappings from Unity XR CommonUsage to Oculus Button/Touch.
+        private static readonly UsageMapping[] ControllerUsageMappings =
+        {
+            new UsageMapping(ControllerButtonUsage.PrimaryButton, OVRInput.Button.One),
+            new UsageMapping(ControllerButtonUsage.PrimaryTouch, OVRInput.Touch.One),
+            new UsageMapping(ControllerButtonUsage.SecondaryButton, OVRInput.Button.Two),
+            new UsageMapping(ControllerButtonUsage.SecondaryTouch, OVRInput.Touch.Two),
+            new UsageMapping(ControllerButtonUsage.GripButton,
+                OVRInput.Button.PrimaryHandTrigger),
+            new UsageMapping(ControllerButtonUsage.TriggerButton,
+                OVRInput.Button.PrimaryIndexTrigger),
+            new UsageMapping(ControllerButtonUsage.MenuButton, OVRInput.Button.Start),
+            new UsageMapping(ControllerButtonUsage.Primary2DAxisClick,
+                OVRInput.Button.PrimaryThumbstick),
+            new UsageMapping(ControllerButtonUsage.Primary2DAxisTouch,
+                OVRInput.Touch.PrimaryThumbstick),
+            new UsageMapping(ControllerButtonUsage.Thumbrest, OVRInput.Touch.PrimaryThumbRest)
+        };
+
+        #endregion
+
+        protected void Awake()
+        {
+            TrackingToWorldTransformer = _trackingToWorldTransformer as ITrackingToWorldTransformer;
+            HmdData = _hmdData as IDataSource<HmdDataAsset, HmdDataSourceConfig>;
+            CameraRigRef = _cameraRigRef as IOVRCameraRigRef;
+        }
+
+        protected override void Start()
+        {
+            base.Start();
+            Assert.IsNotNull(CameraRigRef);
+            Assert.IsNotNull(TrackingToWorldTransformer);
+            Assert.IsNotNull(HmdData);
+            if (_handedness == Handedness.Left)
+            {
+                Assert.IsNotNull(CameraRigRef.LeftController);
+                _ovrControllerAnchor = CameraRigRef.LeftController;
+                _ovrController = OVRInput.Controller.LTouch;
+            }
+            else
+            {
+                Assert.IsNotNull(CameraRigRef.RightController);
+                _ovrControllerAnchor = CameraRigRef.RightController;
+                _ovrController = OVRInput.Controller.RTouch;
+            }
+            _pointerPoseSelector = new OVRPointerPoseSelector(_handedness);
+        }
+
+        private void InitConfig()
+        {
+            if (_config != null)
+            {
+                return;
+            }
+
+            _config = new ControllerDataSourceConfig()
+            {
+                Handedness = _handedness,
+                TrackingToWorldTransformer = TrackingToWorldTransformer,
+                HmdData = HmdData
+            };
+        }
+
+        protected override void UpdateData()
+        {
+            var worldToTrackingSpace = CameraRigRef.CameraRig.transform.worldToLocalMatrix;
+            Transform ovrController = _ovrControllerAnchor;
+
+            _controllerDataAsset.IsDataValid = true;
+            _controllerDataAsset.IsConnected =
+                (OVRInput.GetConnectedControllers() & _ovrController) > 0;
+            if (!_controllerDataAsset.IsConnected)
+            {
+                // revert state fields to their defaults
+                _controllerDataAsset.IsTracked = default;
+                _controllerDataAsset.ButtonUsageMask = default;
+                _controllerDataAsset.RootPoseOrigin = default;
+                return;
+            }
+
+            _controllerDataAsset.IsTracked = true;
+
+            // Update button usages
+            _controllerDataAsset.ButtonUsageMask = ControllerButtonUsage.None;
+            OVRInput.Controller controllerMask = _ovrController;
+            foreach (UsageMapping mapping in ControllerUsageMappings)
+            {
+                bool usageActive;
+                if (mapping.IsTouch)
+                {
+                    usageActive = OVRInput.Get(mapping.Touch, controllerMask);
+                }
+                else
+                {
+                    Assert.IsTrue(mapping.IsButton);
+                    usageActive = OVRInput.Get(mapping.Button, controllerMask);
+                }
+
+                if (usageActive)
+                {
+                    _controllerDataAsset.ButtonUsageMask |= mapping.Usage;
+                }
+            }
+
+            // Update poses
+
+            // Convert controller pose from world to tracking space.
+            Pose worldRoot = new Pose(ovrController.position, ovrController.rotation);
+            _controllerDataAsset.RootPose.position = worldToTrackingSpace.MultiplyPoint3x4(worldRoot.position);
+            _controllerDataAsset.RootPose.rotation = worldToTrackingSpace.rotation * worldRoot.rotation;
+            _controllerDataAsset.RootPoseOrigin = PoseOrigin.RawTrackedPose;
+
+
+            // Convert controller pointer pose from local to tracking space.
+            Pose pointerPose = PoseUtils.Multiply(worldRoot, _pointerPoseSelector.LocalPointerPose);
+            _controllerDataAsset.PointerPose.position = worldToTrackingSpace.MultiplyPoint3x4(pointerPose.position);
+            _controllerDataAsset.PointerPose.rotation = worldToTrackingSpace.rotation * pointerPose.rotation;
+            _controllerDataAsset.PointerPoseOrigin = PoseOrigin.RawTrackedPose;
+
+        }
+
+        protected override ControllerDataAsset DataAsset => _controllerDataAsset;
+
+        // It is important that this creates an object on the fly, as it is possible it is called
+        // from other components Awake methods.
+        public override ControllerDataSourceConfig Config
+        {
+            get
+            {
+                if (_config == null)
+                {
+                    InitConfig();
+                }
+
+                return _config;
+            }
+        }
+
+        #region Inject
+
+        public void InjectAllFromOVRControllerDataSource(UpdateModeFlags updateMode, IDataSource updateAfter,
+            Handedness handedness, ITrackingToWorldTransformer trackingToWorldTransformer,
+            IDataSource<HmdDataAsset, HmdDataSourceConfig> hmdData)
+        {
+            base.InjectAllDataSource(updateMode, updateAfter);
+            InjectHandedness(handedness);
+            InjectTrackingToWorldTransformer(trackingToWorldTransformer);
+            InjectHmdData(hmdData);
+        }
+
+        public void InjectHandedness(Handedness handedness)
+        {
+            _handedness = handedness;
+        }
+
+        public void InjectTrackingToWorldTransformer(ITrackingToWorldTransformer trackingToWorldTransformer)
+        {
+            _trackingToWorldTransformer = trackingToWorldTransformer as MonoBehaviour;
+            TrackingToWorldTransformer = trackingToWorldTransformer;
+        }
+
+        public void InjectHmdData(IDataSource<HmdDataAsset,HmdDataSourceConfig> hmdData)
+        {
+            _hmdData = hmdData as MonoBehaviour;
+            HmdData = hmdData;
+        }
+
+        #endregion
+    }
+}

Assets/Oculus/Interaction/Runtime/Scripts/Input/OVRIntegration/FromOVRControllerDataSource.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ee6b94f7bc105c24ea3746dc4141a7eb
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/Interaction/Runtime/Scripts/Input/OVRIntegration/FromOVRControllerHandDataSource.cs

@@ -0,0 +1,270 @@
+/************************************************************************************
+Copyright : Copyright (c) Facebook Technologies, LLC and its affiliates. All rights reserved.
+
+Your use of this SDK or tool is subject to the Oculus SDK License Agreement, available at
+https://developer.oculus.com/licenses/oculussdk/
+
+Unless required by applicable law or agreed to in writing, the Utilities SDK distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+ANY KIND, either express or implied. See the License for the specific language governing
+permissions and limitations under the License.
+************************************************************************************/
+
+using UnityEngine;
+using UnityEngine.Assertions;
+using UnityEngine.Serialization;
+
+namespace Oculus.Interaction.Input
+{
+    public class FromOVRControllerHandDataSource : DataSource<HandDataAsset, HandDataSourceConfig>
+    {
+        [SerializeField]
+        private Transform[] _bones;
+
+        [SerializeField]
+        private AnimationCurve _pinchCurve = AnimationCurve.EaseInOut(0.1f, 0f, 0.9f, 1f);
+
+        [SerializeField]
+        private Vector3 _rootOffset;
+        [SerializeField]
+        private Vector3 _rootAngleOffset;
+
+        [Header("OVR Data Source")]
+        [SerializeField, Interface(typeof(IOVRCameraRigRef))]
+        private MonoBehaviour _cameraRigRef;
+        private IOVRCameraRigRef CameraRigRef;
+
+        [Header("Shared Configuration")]
+        [SerializeField]
+        private Handedness _handedness;
+
+        [SerializeField, Interface(typeof(ITrackingToWorldTransformer))]
+        private MonoBehaviour _trackingToWorldTransformer;
+        private ITrackingToWorldTransformer TrackingToWorldTransformer;
+
+        [SerializeField, Interface(typeof(IDataSource<HmdDataAsset, HmdDataSourceConfig>))]
+        private MonoBehaviour _hmdData;
+        private IDataSource<HmdDataAsset, HmdDataSourceConfig> HmdData;
+
+        private readonly HandDataAsset _handDataAsset = new HandDataAsset();
+        private OVRInput.Controller _ovrController;
+        private Transform _ovrControllerAnchor;
+        private HandDataSourceConfig _config;
+        private Pose _poseOffset;
+
+
+        public static Quaternion WristFixupRotation { get; } =
+            new Quaternion(0.0f, 1.0f, 0.0f, 0.0f);
+
+        protected override HandDataAsset DataAsset => _handDataAsset;
+
+        private HandSkeleton _skeleton;
+
+        public override HandDataSourceConfig Config
+        {
+            get
+            {
+                if (_config == null)
+                {
+                    InitConfig();
+                }
+
+                return _config;
+            }
+        }
+
+        protected void Awake()
+        {
+            _skeleton = HandSkeletonOVR.CreateSkeletonData(_handedness);
+            TrackingToWorldTransformer = _trackingToWorldTransformer as ITrackingToWorldTransformer;
+            HmdData = _hmdData as IDataSource<HmdDataAsset, HmdDataSourceConfig>;
+            CameraRigRef = _cameraRigRef as IOVRCameraRigRef;
+        }
+
+        protected override void Start()
+        {
+            base.Start();
+            Assert.IsNotNull(CameraRigRef);
+            Assert.IsNotNull(TrackingToWorldTransformer);
+            Assert.IsNotNull(HmdData);
+            if (_handedness == Handedness.Left)
+            {
+                Assert.IsNotNull(CameraRigRef.LeftHand);
+                _ovrControllerAnchor = CameraRigRef.LeftController;
+                _ovrController = OVRInput.Controller.LTouch;
+            }
+            else
+            {
+                Assert.IsNotNull(CameraRigRef.RightHand);
+                _ovrControllerAnchor = CameraRigRef.RightController;
+                _ovrController = OVRInput.Controller.RTouch;
+            }
+
+            Pose offset = new Pose(_rootOffset, Quaternion.Euler(_rootAngleOffset));
+            if (_handedness == Handedness.Left)
+            {
+                offset.position.x = -offset.position.x;
+                offset.rotation = Quaternion.Euler(180f, 0f, 0f) * offset.rotation;
+            }
+            _poseOffset = offset;
+
+            InitConfig();
+
+        }
+
+        private void UpdateSkeleton()
+        {
+            for (int i = 0; i < _skeleton.joints.Length; i++)
+            {
+                _skeleton.joints[i].pose.position = _bones[i].localPosition;
+                _skeleton.joints[i].pose.rotation = _bones[i].localRotation;
+            }
+        }
+
+        private void InitConfig()
+        {
+            if (_config != null)
+            {
+                return;
+            }
+
+            UpdateSkeleton();
+
+            _config = new HandDataSourceConfig()
+            {
+                Handedness = _handedness,
+                TrackingToWorldTransformer = TrackingToWorldTransformer,
+                HandSkeleton = _skeleton,
+                HmdData = HmdData
+            };
+        }
+
+        protected override void UpdateData()
+        {
+            _handDataAsset.IsDataValid = true;
+            _handDataAsset.IsConnected = (OVRInput.GetConnectedControllers() & _ovrController) > 0;
+            if (!_handDataAsset.IsConnected)
+            {
+                // revert state fields to their defaults
+                _handDataAsset.IsTracked = default;
+                _handDataAsset.RootPoseOrigin = default;
+                _handDataAsset.PointerPoseOrigin = default;
+                _handDataAsset.IsHighConfidence = default;
+                for (var fingerIdx = 0; fingerIdx < Constants.NUM_FINGERS; fingerIdx++)
+                {
+                    _handDataAsset.IsFingerPinching[fingerIdx] = default;
+                    _handDataAsset.IsFingerHighConfidence[fingerIdx] = default;
+                }
+                return;
+            }
+
+            _handDataAsset.IsTracked = true;
+            _handDataAsset.IsHighConfidence = true;
+            _handDataAsset.HandScale = 1f;
+
+            _handDataAsset.IsDominantHand =
+                OVRInput.GetDominantHand() == OVRInput.Handedness.LeftHanded
+                && _handedness == Handedness.Left
+                || (OVRInput.GetDominantHand() == OVRInput.Handedness.RightHanded
+                    && _handedness == Handedness.Right);
+
+            float indexStrength = _pinchCurve.Evaluate(OVRInput.Get(OVRInput.Axis1D.PrimaryIndexTrigger, _ovrController));
+            float gripStrength = _pinchCurve.Evaluate(OVRInput.Get(OVRInput.Axis1D.PrimaryHandTrigger, _ovrController));
+
+            _handDataAsset.IsFingerHighConfidence[(int)HandFinger.Thumb] = true;
+            _handDataAsset.IsFingerPinching[(int)HandFinger.Thumb] = indexStrength >= 1f || gripStrength >= 1f;
+            _handDataAsset.FingerPinchStrength[(int)HandFinger.Thumb] = Mathf.Max(indexStrength, gripStrength);
+
+            _handDataAsset.IsFingerHighConfidence[(int)HandFinger.Index] = true;
+            _handDataAsset.IsFingerPinching[(int)HandFinger.Index] = indexStrength >= 1f;
+            _handDataAsset.FingerPinchStrength[(int)HandFinger.Index] = indexStrength;
+
+            _handDataAsset.IsFingerHighConfidence[(int)HandFinger.Middle] = true;
+            _handDataAsset.IsFingerPinching[(int)HandFinger.Middle] = gripStrength >= 1f;
+            _handDataAsset.FingerPinchStrength[(int)HandFinger.Middle] = gripStrength;
+
+            _handDataAsset.IsFingerHighConfidence[(int)HandFinger.Ring] = true;
+            _handDataAsset.IsFingerPinching[(int)HandFinger.Ring] = gripStrength >= 1f;
+            _handDataAsset.FingerPinchStrength[(int)HandFinger.Ring] = gripStrength;
+
+            _handDataAsset.IsFingerHighConfidence[(int)HandFinger.Pinky] = true;
+            _handDataAsset.IsFingerPinching[(int)HandFinger.Pinky] = gripStrength >= 1f;
+            _handDataAsset.FingerPinchStrength[(int)HandFinger.Pinky] = gripStrength;
+
+            _handDataAsset.PointerPoseOrigin = PoseOrigin.RawTrackedPose;
+            _handDataAsset.PointerPose = new Pose(
+                OVRInput.GetLocalControllerPosition(_ovrController),
+                OVRInput.GetLocalControllerRotation(_ovrController));
+
+            for (int i = 0; i < _bones.Length; i++)
+            {
+                _handDataAsset.Joints[i] = _bones[i].localRotation;
+            }
+
+            _handDataAsset.Joints[0] = WristFixupRotation;
+
+            // Convert controller pose from world to tracking space.
+            Pose pose = new Pose(_ovrControllerAnchor.position, _ovrControllerAnchor.rotation);
+            pose = Config.TrackingToWorldTransformer.ToTrackingPose(pose);
+
+            PoseUtils.Multiply(pose, _poseOffset, ref _handDataAsset.Root);
+            _handDataAsset.RootPoseOrigin = PoseOrigin.RawTrackedPose;
+        }
+
+        #region Inject
+
+        public void InjectAllFromOVRControllerHandDataSource(UpdateModeFlags updateMode, IDataSource updateAfter,
+            Handedness handedness, ITrackingToWorldTransformer trackingToWorldTransformer,
+            IDataSource<HmdDataAsset, HmdDataSourceConfig> hmdData, Transform[] bones, AnimationCurve pinchCurve,
+            Vector3 rootOffset, Vector3 rootAngleOffset)
+        {
+            base.InjectAllDataSource(updateMode, updateAfter);
+            InjectHandedness(handedness);
+            InjectTrackingToWorldTransformer(trackingToWorldTransformer);
+            InjectHmdData(hmdData);
+            InjectBones(bones);
+            InjectPinchCurve(pinchCurve);
+            InjectRootOffset(rootOffset);
+            InjectRootAngleOffset(rootAngleOffset);
+        }
+
+        public void InjectHandedness(Handedness handedness)
+        {
+            _handedness = handedness;
+        }
+
+        public void InjectTrackingToWorldTransformer(ITrackingToWorldTransformer trackingToWorldTransformer)
+        {
+            _trackingToWorldTransformer = trackingToWorldTransformer as MonoBehaviour;
+            TrackingToWorldTransformer = trackingToWorldTransformer;
+        }
+
+        public void InjectHmdData(IDataSource<HmdDataAsset, HmdDataSourceConfig> hmdData)
+        {
+            _hmdData = hmdData as MonoBehaviour;
+            HmdData = hmdData;
+        }
+
+        public void InjectBones(Transform[] bones)
+        {
+            _bones = bones;
+        }
+
+        public void InjectPinchCurve(AnimationCurve pinchCurve)
+        {
+            _pinchCurve = pinchCurve;
+        }
+
+        public void InjectRootOffset(Vector3 rootOffset)
+        {
+            _rootOffset = rootOffset;
+        }
+
+        public void InjectRootAngleOffset(Vector3 rootAngleOffset)
+        {
+            _rootAngleOffset = rootAngleOffset;
+        }
+
+        #endregion
+    }
+}

Assets/Oculus/Interaction/Runtime/Scripts/Input/OVRIntegration/FromOVRControllerHandDataSource.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: eb7d6cff5f17513488d465cdc4efd298
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/Interaction/Runtime/Scripts/Input/OVRIntegration/FromOVRHandDataSource.cs

@@ -0,0 +1,247 @@
+/************************************************************************************
+Copyright : Copyright (c) Facebook Technologies, LLC and its affiliates. All rights reserved.
+
+Your use of this SDK or tool is subject to the Oculus SDK License Agreement, available at
+https://developer.oculus.com/licenses/oculussdk/
+
+Unless required by applicable law or agreed to in writing, the Utilities SDK distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+ANY KIND, either express or implied. See the License for the specific language governing
+permissions and limitations under the License.
+************************************************************************************/
+
+using System;
+using UnityEngine;
+using UnityEngine.Assertions;
+using UnityEngine.Serialization;
+using static OVRSkeleton;
+
+namespace Oculus.Interaction.Input
+{
+    public class FromOVRHandDataSource : DataSource<HandDataAsset, HandDataSourceConfig>
+    {
+        [Header("OVR Data Source")]
+        [SerializeField, Interface(typeof(IOVRCameraRigRef))]
+        private MonoBehaviour _cameraRigRef;
+
+        [Header("Shared Configuration")]
+        [SerializeField]
+        private Handedness _handedness;
+
+        [SerializeField, Interface(typeof(ITrackingToWorldTransformer))]
+        private MonoBehaviour _trackingToWorldTransformer;
+        private ITrackingToWorldTransformer TrackingToWorldTransformer;
+
+        [SerializeField, Interface(typeof(IHandSkeletonProvider))]
+        private MonoBehaviour _handSkeletonProvider;
+        private IHandSkeletonProvider HandSkeletonProvider;
+
+        [SerializeField, Interface(typeof(IDataSource<HmdDataAsset, HmdDataSourceConfig>))]
+        private MonoBehaviour _hmdData;
+        private IDataSource<HmdDataAsset, HmdDataSourceConfig> HmdData;
+
+        private readonly HandDataAsset _handDataAsset = new HandDataAsset();
+        private OVRHand _ovrHand;
+        private OVRInput.Controller _ovrController;
+        private float _lastHandScale;
+        private HandDataSourceConfig _config;
+
+        private IOVRCameraRigRef CameraRigRef;
+
+        protected override HandDataAsset DataAsset => _handDataAsset;
+
+        // Wrist rotations that come from OVR need correcting.
+        public static Quaternion WristFixupRotation { get; } =
+            new Quaternion(0.0f, 1.0f, 0.0f, 0.0f);
+
+        // It is important that this creates an object on the fly, as it is possible it is called
+        // from other components Start methods.
+        public override HandDataSourceConfig Config => _config ?? InitConfig();
+
+        protected virtual void Awake()
+        {
+            TrackingToWorldTransformer = _trackingToWorldTransformer as ITrackingToWorldTransformer;
+            HmdData = _hmdData as IDataSource<HmdDataAsset, HmdDataSourceConfig>;
+            CameraRigRef = _cameraRigRef as IOVRCameraRigRef;
+            HandSkeletonProvider = _handSkeletonProvider as IHandSkeletonProvider;
+        }
+
+        protected override void Start()
+        {
+            base.Start();
+            Assert.IsNotNull(CameraRigRef);
+            Assert.IsNotNull(TrackingToWorldTransformer);
+            Assert.IsNotNull(HandSkeletonProvider);
+            Assert.IsNotNull(HmdData);
+            if (_handedness == Handedness.Left)
+            {
+                _ovrHand = CameraRigRef.LeftHand;
+                _ovrController = OVRInput.Controller.LHand;
+            }
+            else
+            {
+                _ovrHand = CameraRigRef.RightHand;
+                _ovrController = OVRInput.Controller.RHand;
+            }
+        }
+
+        private HandDataSourceConfig InitConfig()
+        {
+            if (_config != null)
+            {
+                return _config;
+            }
+
+            _config = new HandDataSourceConfig()
+            {
+                Handedness = _handedness,
+                TrackingToWorldTransformer = TrackingToWorldTransformer,
+                HandSkeleton = HandSkeletonProvider[_handedness],
+                HmdData = HmdData
+            };
+
+            return _config;
+        }
+
+        protected override void UpdateData()
+        {
+            _handDataAsset.IsDataValid = true;
+            _handDataAsset.IsConnected =
+                (OVRInput.GetConnectedControllers() & _ovrController) > 0;
+
+            if (_ovrHand != null)
+            {
+                var skeletonProvider = (IOVRSkeletonDataProvider)_ovrHand;
+                var poseData = skeletonProvider.GetSkeletonPoseData();
+                if (poseData.IsDataValid && poseData.RootScale <= 0.0f)
+                {
+                    if (_lastHandScale <= 0.0f)
+                    {
+                        poseData.IsDataValid = false;
+                    }
+                    else
+                    {
+                        poseData.RootScale = _lastHandScale;
+                    }
+                }
+                else
+                {
+                    _lastHandScale = poseData.RootScale;
+                }
+
+                if (poseData.IsDataValid && _handDataAsset.IsConnected)
+                {
+                    UpdateDataPoses(poseData);
+                    return;
+                }
+            }
+
+            // revert state fields to their defaults
+            _handDataAsset.IsConnected = default;
+            _handDataAsset.IsTracked = default;
+            _handDataAsset.RootPoseOrigin = default;
+            _handDataAsset.PointerPoseOrigin = default;
+            _handDataAsset.IsHighConfidence = default;
+            for (var fingerIdx = 0; fingerIdx < Constants.NUM_FINGERS; fingerIdx++)
+            {
+                _handDataAsset.IsFingerPinching[fingerIdx] = default;
+                _handDataAsset.IsFingerHighConfidence[fingerIdx] = default;
+            }
+        }
+
+        private void UpdateDataPoses(SkeletonPoseData poseData)
+        {
+            _handDataAsset.HandScale = poseData.RootScale;
+            _handDataAsset.IsTracked = _ovrHand.IsTracked;
+            _handDataAsset.IsHighConfidence = poseData.IsDataHighConfidence;
+            _handDataAsset.IsDominantHand = _ovrHand.IsDominantHand;
+            _handDataAsset.RootPoseOrigin = _handDataAsset.IsTracked
+                ? PoseOrigin.RawTrackedPose
+                : PoseOrigin.None;
+
+            for (var fingerIdx = 0; fingerIdx < Constants.NUM_FINGERS; fingerIdx++)
+            {
+                var ovrFingerIdx = (OVRHand.HandFinger)fingerIdx;
+                bool isPinching = _ovrHand.GetFingerIsPinching(ovrFingerIdx);
+                _handDataAsset.IsFingerPinching[fingerIdx] = isPinching;
+
+                bool isHighConfidence =
+                    _ovrHand.GetFingerConfidence(ovrFingerIdx) == OVRHand.TrackingConfidence.High;
+                _handDataAsset.IsFingerHighConfidence[fingerIdx] = isHighConfidence;
+
+                float fingerPinchStrength = _ovrHand.GetFingerPinchStrength(ovrFingerIdx);
+                _handDataAsset.FingerPinchStrength[fingerIdx] = fingerPinchStrength;
+            }
+
+            // Read the poses directly from the poseData, so it isn't in conflict with
+            // any modifications that the application makes to OVRSkeleton
+            _handDataAsset.Root = new Pose()
+            {
+                position = poseData.RootPose.Position.FromFlippedZVector3f(),
+                rotation = poseData.RootPose.Orientation.FromFlippedZQuatf()
+            };
+
+            if (_ovrHand.IsPointerPoseValid)
+            {
+                _handDataAsset.PointerPoseOrigin = PoseOrigin.RawTrackedPose;
+                _handDataAsset.PointerPose = new Pose(_ovrHand.PointerPose.localPosition,
+                        _ovrHand.PointerPose.localRotation);
+            }
+            else
+            {
+                _handDataAsset.PointerPoseOrigin = PoseOrigin.None;
+            }
+
+            // Hand joint rotations X axis needs flipping to get to Unity's coordinate system.
+            var bones = poseData.BoneRotations;
+            for (int i = 0; i < bones.Length; i++)
+            {
+                // When using Link in the Unity Editor, the first frame of hand data
+                // sometimes contains bad joint data.
+                _handDataAsset.Joints[i] = float.IsNaN(bones[i].w)
+                    ? Config.HandSkeleton.joints[i].pose.rotation
+                    : bones[i].FromFlippedXQuatf();
+            }
+
+            _handDataAsset.Joints[0] = WristFixupRotation;
+        }
+
+        #region Inject
+
+        public void InjectAllFromOVRHandDataSource(UpdateModeFlags updateMode, IDataSource updateAfter,
+            Handedness handedness, ITrackingToWorldTransformer trackingToWorldTransformer,
+            IHandSkeletonProvider handSkeletonProvider, IDataSource<HmdDataAsset, HmdDataSourceConfig> hmdData)
+        {
+            base.InjectAllDataSource(updateMode, updateAfter);
+            InjectHandedness(handedness);
+            InjectTrackingToWorldTransformer(trackingToWorldTransformer);
+            InjectHandSkeletonProvider(handSkeletonProvider);
+            InjectHmdData(hmdData);
+        }
+
+        public void InjectHandedness(Handedness handedness)
+        {
+            _handedness = handedness;
+        }
+
+        public void InjectTrackingToWorldTransformer(ITrackingToWorldTransformer trackingToWorldTransformer)
+        {
+            _trackingToWorldTransformer = trackingToWorldTransformer as MonoBehaviour;
+            TrackingToWorldTransformer = trackingToWorldTransformer;
+        }
+
+        public void InjectHandSkeletonProvider(IHandSkeletonProvider handSkeletonProvider)
+        {
+            _handSkeletonProvider = handSkeletonProvider as MonoBehaviour;
+            HandSkeletonProvider = handSkeletonProvider;
+        }
+
+        public void InjectHmdData(IDataSource<HmdDataAsset,HmdDataSourceConfig> hmdData)
+        {
+            _hmdData = hmdData as MonoBehaviour;
+            HmdData = hmdData;
+        }
+
+        #endregion
+    }
+}

Assets/Oculus/Interaction/Runtime/Scripts/Input/OVRIntegration/FromOVRHandDataSource.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 4855895ba1c44959a306beb7ae318fc2
+timeCreated: 1630528577

Assets/Oculus/Interaction/Runtime/Scripts/Input/OVRIntegration/FromOVRHmdDataSource.cs

@@ -0,0 +1,157 @@
+/************************************************************************************
+Copyright : Copyright (c) Facebook Technologies, LLC and its affiliates. All rights reserved.
+
+Your use of this SDK or tool is subject to the Oculus SDK License Agreement, available at
+https://developer.oculus.com/licenses/oculussdk/
+
+Unless required by applicable law or agreed to in writing, the Utilities SDK distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+ANY KIND, either express or implied. See the License for the specific language governing
+permissions and limitations under the License.
+************************************************************************************/
+
+using System;
+using UnityEngine;
+using UnityEngine.Assertions;
+using UnityEngine.Serialization;
+using UnityEngine.XR;
+
+namespace Oculus.Interaction.Input
+{
+    public class FromOVRHmdDataSource : DataSource<HmdDataAsset, HmdDataSourceConfig>
+    {
+        [Header("OVR Data Source")]
+        [SerializeField, Interface(typeof(IOVRCameraRigRef))]
+        private MonoBehaviour _cameraRigRef;
+
+        public IOVRCameraRigRef CameraRigRef { get; private set; }
+
+        [SerializeField]
+        [Tooltip("If true, uses OVRManager.headPoseRelativeOffset rather than sensor data for " +
+                 "HMD pose.")]
+        private bool _useOvrManagerEmulatedPose = false;
+
+        [Header("Shared Configuration")]
+        [SerializeField, Interface(typeof(ITrackingToWorldTransformer))]
+        private MonoBehaviour _trackingToWorldTransformer;
+        private ITrackingToWorldTransformer TrackingToWorldTransformer;
+
+        private HmdDataAsset _hmdDataAsset = new HmdDataAsset();
+        private HmdDataSourceConfig _config;
+
+        protected void Awake()
+        {
+            CameraRigRef = _cameraRigRef as IOVRCameraRigRef;
+            TrackingToWorldTransformer = _trackingToWorldTransformer as ITrackingToWorldTransformer;
+        }
+
+        protected override void Start()
+        {
+            base.Start();
+            Assert.IsNotNull(CameraRigRef);
+            Assert.IsNotNull(TrackingToWorldTransformer);
+            InitConfig();
+        }
+        private void InitConfig()
+        {
+            if (_config != null)
+            {
+                return;
+            }
+            _config = new HmdDataSourceConfig()
+            {
+                TrackingToWorldTransformer = TrackingToWorldTransformer
+            };
+        }
+
+        protected override void UpdateData()
+        {
+            bool hmdPresent = OVRNodeStateProperties.IsHmdPresent();
+            ref var centerEyePose = ref _hmdDataAsset.Root;
+            if (_useOvrManagerEmulatedPose)
+            {
+                Quaternion emulatedRotation = Quaternion.Euler(
+                    -OVRManager.instance.headPoseRelativeOffsetRotation.x,
+                    -OVRManager.instance.headPoseRelativeOffsetRotation.y,
+                    OVRManager.instance.headPoseRelativeOffsetRotation.z);
+                centerEyePose.rotation = emulatedRotation;
+                centerEyePose.position = OVRManager.instance.headPoseRelativeOffsetTranslation;
+                hmdPresent = true;
+            }
+            else
+            {
+                var previousEyePose = new Pose();
+
+                if (_hmdDataAsset.IsTracked)
+                {
+                    previousEyePose = _hmdDataAsset.Root;
+                }
+
+                if (hmdPresent)
+                {
+                    // These are already in Unity's coordinate system (LHS)
+                    if (!OVRNodeStateProperties.GetNodeStatePropertyVector3(XRNode.CenterEye,
+                        NodeStatePropertyType.Position, OVRPlugin.Node.EyeCenter,
+                        OVRPlugin.Step.Render, out centerEyePose.position))
+                    {
+                        centerEyePose.position = previousEyePose.position;
+                    }
+
+                    if (!OVRNodeStateProperties.GetNodeStatePropertyQuaternion(XRNode.CenterEye,
+                        NodeStatePropertyType.Orientation, OVRPlugin.Node.EyeCenter,
+                        OVRPlugin.Step.Render, out centerEyePose.rotation))
+                    {
+                        centerEyePose.rotation = previousEyePose.rotation;
+                    }
+                }
+                else
+                {
+                    centerEyePose = previousEyePose;
+                }
+            }
+
+            _hmdDataAsset.IsTracked = hmdPresent;
+            _hmdDataAsset.FrameId = Time.frameCount;
+        }
+
+        protected override HmdDataAsset DataAsset => _hmdDataAsset;
+
+        // It is important that this creates an object on the fly, as it is possible it is called
+        // from other components Awake methods.
+        public override HmdDataSourceConfig Config
+        {
+            get
+            {
+                if (_config == null)
+                {
+                    InitConfig();
+                }
+
+                return _config;
+            }
+        }
+
+        #region Inject
+
+        public void InjectAllFromOVRHmdDataSource(UpdateModeFlags updateMode, IDataSource updateAfter,
+            bool useOvrManagerEmulatedPose, ITrackingToWorldTransformer trackingToWorldTransformer)
+        {
+            base.InjectAllDataSource(updateMode, updateAfter);
+            InjectUseOvrManagerEmulatedPose(useOvrManagerEmulatedPose);
+            InjectTrackingToWorldTransformer(trackingToWorldTransformer);
+        }
+
+        public void InjectUseOvrManagerEmulatedPose(bool useOvrManagerEmulatedPose)
+        {
+            _useOvrManagerEmulatedPose = useOvrManagerEmulatedPose;
+        }
+
+        public void InjectTrackingToWorldTransformer(ITrackingToWorldTransformer trackingToWorldTransformer)
+        {
+            _trackingToWorldTransformer = trackingToWorldTransformer as MonoBehaviour;
+            TrackingToWorldTransformer = trackingToWorldTransformer;
+        }
+
+        #endregion
+    }
+}

Assets/Oculus/Interaction/Runtime/Scripts/Input/OVRIntegration/FromOVRHmdDataSource.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f273abee0604ad2409c9bbc9a60e461e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/Interaction/Runtime/Scripts/Input/OVRIntegration/HandPhysicsCapsules.cs

@@ -0,0 +1,188 @@
+/************************************************************************************
+Copyright : Copyright (c) Facebook Technologies, LLC and its affiliates. All rights reserved.
+
+Your use of this SDK or tool is subject to the Oculus SDK License Agreement, available at
+https://developer.oculus.com/licenses/oculussdk/
+
+Unless required by applicable law or agreed to in writing, the Utilities SDK distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+ANY KIND, either express or implied. See the License for the specific language governing
+permissions and limitations under the License.
+************************************************************************************/
+
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Assertions;
+using UnityEngine.Serialization;
+
+namespace Oculus.Interaction.Input
+{
+    public class HandPhysicsCapsules : MonoBehaviour
+    {
+        [SerializeField] private HandVisual _handVisual;
+
+        private GameObject _capsulesGO;
+        private List<BoneCapsule> _capsules;
+        public IList<BoneCapsule> Capsules { get; private set; }
+        private OVRPlugin.Skeleton2 _skeleton;
+        private bool _capsulesAreActive;
+        protected bool _started;
+
+        protected virtual void Awake()
+        {
+            Assert.IsNotNull(_handVisual);
+        }
+
+        protected virtual void Start()
+        {
+            this.BeginStart(ref _started);
+
+            _skeleton = _handVisual.Hand.Handedness == Handedness.Left
+                ? OVRSkeletonData.LeftSkeleton
+                : OVRSkeletonData.RightSkeleton;
+            _capsulesGO = new GameObject("Capsules");
+            _capsulesGO.transform.SetParent(transform, false);
+            _capsulesGO.transform.localPosition = Vector3.zero;
+            _capsulesGO.transform.localRotation = Quaternion.identity;
+
+            _capsules = new List<BoneCapsule>(new BoneCapsule[_skeleton.NumBoneCapsules]);
+            Capsules = _capsules.AsReadOnly();
+
+            for (int i = 0; i < _capsules.Count; ++i)
+            {
+                Transform boneTransform = _handVisual.Joints[_skeleton.BoneCapsules[i].BoneIndex];
+                BoneCapsule capsule = new BoneCapsule();
+                _capsules[i] = capsule;
+
+                capsule.BoneIndex = _skeleton.BoneCapsules[i].BoneIndex;
+
+                capsule.CapsuleRigidbody = new GameObject((boneTransform.name).ToString() + "_CapsuleRigidbody")
+                    .AddComponent<Rigidbody>();
+                capsule.CapsuleRigidbody.mass = 1.0f;
+                capsule.CapsuleRigidbody.isKinematic = true;
+                capsule.CapsuleRigidbody.useGravity = false;
+                capsule.CapsuleRigidbody.collisionDetectionMode = CollisionDetectionMode.ContinuousSpeculative;
+
+                GameObject rbGO = capsule.CapsuleRigidbody.gameObject;
+                rbGO.transform.SetParent(_capsulesGO.transform, false);
+                rbGO.transform.position = boneTransform.position;
+                rbGO.transform.rotation = boneTransform.rotation;
+                rbGO.SetActive(false);
+
+                capsule.CapsuleCollider = new GameObject((boneTransform.name).ToString() + "_CapsuleCollider")
+                    .AddComponent<CapsuleCollider>();
+                capsule.CapsuleCollider.isTrigger = false;
+
+                var p0 = _skeleton.BoneCapsules[i].StartPoint.FromFlippedXVector3f();
+                var p1 = _skeleton.BoneCapsules[i].EndPoint.FromFlippedXVector3f();
+                var delta = p1 - p0;
+                var mag = delta.magnitude;
+                var rot = Quaternion.FromToRotation(Vector3.right, delta);
+                capsule.CapsuleCollider.radius = _skeleton.BoneCapsules[i].Radius;
+                capsule.CapsuleCollider.height = mag + _skeleton.BoneCapsules[i].Radius * 2.0f;
+                capsule.CapsuleCollider.direction = 0;
+                capsule.CapsuleCollider.center = Vector3.right * mag * 0.5f;
+
+                GameObject ccGO = capsule.CapsuleCollider.gameObject;
+                ccGO.transform.SetParent(rbGO.transform, false);
+                ccGO.transform.localPosition = p0;
+                ccGO.transform.localRotation = rot;
+            }
+            this.EndStart(ref _started);
+        }
+
+        protected virtual void OnEnable()
+        {
+            if (_started)
+            {
+                _handVisual.WhenHandVisualUpdated += HandleHandVisualUpdated;
+            }
+        }
+        protected virtual void OnDisable()
+        {
+            if (_started)
+            {
+                _handVisual.WhenHandVisualUpdated -= HandleHandVisualUpdated;
+
+                if (_capsules != null)
+                {
+                    for (int i = 0; i < _capsules.Count; ++i)
+                    {
+                        var capsuleGO = _capsules[i].CapsuleRigidbody.gameObject;
+                        capsuleGO.SetActive(false);
+                    }
+                    _capsulesAreActive = false;
+                }
+            }
+        }
+
+        protected virtual void FixedUpdate()
+        {
+            if (_capsulesAreActive && !_handVisual.IsVisible)
+            {
+                for (int i = 0; i < _capsules.Count; ++i)
+                {
+                    var capsuleGO = _capsules[i].CapsuleRigidbody.gameObject;
+                    capsuleGO.SetActive(false);
+                }
+                _capsulesAreActive = false;
+            }
+        }
+
+        private void HandleHandVisualUpdated()
+        {
+            _capsulesAreActive = _handVisual.IsVisible;
+
+            for (int i = 0; i < _capsules.Count; ++i)
+            {
+                BoneCapsule capsule = _capsules[i];
+                var capsuleGO = capsule.CapsuleRigidbody.gameObject;
+
+                if (_capsulesAreActive)
+                {
+                    Transform boneTransform = _handVisual.Joints[(int)capsule.BoneIndex];
+
+                    if (capsuleGO.activeSelf)
+                    {
+                        capsule.CapsuleRigidbody.MovePosition(boneTransform.position);
+                        capsule.CapsuleRigidbody.MoveRotation(boneTransform.rotation);
+                    }
+                    else
+                    {
+                        capsuleGO.SetActive(true);
+                        capsule.CapsuleRigidbody.position = boneTransform.position;
+                        capsule.CapsuleRigidbody.rotation = boneTransform.rotation;
+                    }
+                }
+                else
+                {
+                    if (capsuleGO.activeSelf)
+                    {
+                        capsuleGO.SetActive(false);
+                    }
+                }
+            }
+        }
+
+        #region Inject
+
+        public void InjectAllOVRHandPhysicsCapsules(HandVisual hand)
+        {
+            InjectHandSkeleton(hand);
+}
+
+        public void InjectHandSkeleton(HandVisual hand)
+        {
+            _handVisual = hand;
+        }
+
+        #endregion
+    }
+
+    public class BoneCapsule
+    {
+        public short BoneIndex { get; set; }
+        public Rigidbody CapsuleRigidbody { get; set; }
+        public CapsuleCollider CapsuleCollider { get; set; }
+    }
+}

Assets/Oculus/Interaction/Runtime/Scripts/Input/OVRIntegration/HandPhysicsCapsules.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a1e477b940c8a084ab4f2dda703b49ef
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/Interaction/Runtime/Scripts/Input/OVRIntegration/HandSkeletonOVR.cs

@@ -0,0 +1,69 @@
+/************************************************************************************
+Copyright : Copyright (c) Facebook Technologies, LLC and its affiliates. All rights reserved.
+
+Your use of this SDK or tool is subject to the Oculus SDK License Agreement, available at
+https://developer.oculus.com/licenses/oculussdk/
+
+Unless required by applicable law or agreed to in writing, the Utilities SDK distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+ANY KIND, either express or implied. See the License for the specific language governing
+permissions and limitations under the License.
+************************************************************************************/
+
+using System;
+using UnityEngine;
+using UnityEngine.Assertions;
+
+namespace Oculus.Interaction.Input
+{
+    public class HandSkeletonOVR : MonoBehaviour, IHandSkeletonProvider
+    {
+        private readonly HandSkeleton[] _skeletons = { null, null };
+
+        public HandSkeleton this[Handedness handedness] => _skeletons[(int)handedness];
+
+        protected void Awake()
+        {
+            _skeletons[0] = CreateSkeletonData(Handedness.Left);
+            _skeletons[1] = CreateSkeletonData(Handedness.Right);
+        }
+
+        public static HandSkeleton CreateSkeletonData(Handedness handedness)
+        {
+            HandSkeleton handSkeleton = new HandSkeleton();
+
+            // When running in the editor, the call to load the skeleton from OVRPlugin may fail. Use baked skeleton
+            // data.
+            if (handedness == Handedness.Left)
+            {
+                ApplyToSkeleton(OVRSkeletonData.LeftSkeleton, handSkeleton);
+            }
+            else
+            {
+                ApplyToSkeleton(OVRSkeletonData.RightSkeleton, handSkeleton);
+            }
+
+            return handSkeleton;
+        }
+
+        private static void ApplyToSkeleton(in OVRPlugin.Skeleton2 ovrSkeleton, HandSkeleton handSkeleton)
+        {
+            int numJoints = handSkeleton.joints.Length;
+            Assert.AreEqual(ovrSkeleton.NumBones, numJoints);
+
+            for (int i = 0; i < numJoints; ++i)
+            {
+                ref var srcPose = ref ovrSkeleton.Bones[i].Pose;
+                handSkeleton.joints[i] = new HandSkeletonJoint()
+                {
+                    pose = new Pose()
+                    {
+                        position = srcPose.Position.FromFlippedXVector3f(),
+                        rotation = srcPose.Orientation.FromFlippedXQuatf()
+                    },
+                    parent = ovrSkeleton.Bones[i].ParentBoneIndex
+                };
+            }
+        }
+    }
+}

Assets/Oculus/Interaction/Runtime/Scripts/Input/OVRIntegration/HandSkeletonOVR.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 86bd0d3098d25db4c9c839739557480b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/Interaction/Runtime/Scripts/Input/OVRIntegration/InputDataProviderUpdateTriggerOVR.cs

@@ -0,0 +1,138 @@
+/************************************************************************************
+Copyright : Copyright (c) Facebook Technologies, LLC and its affiliates. All rights reserved.
+
+Your use of this SDK or tool is subject to the Oculus SDK License Agreement, available at
+https://developer.oculus.com/licenses/oculussdk/
+
+Unless required by applicable law or agreed to in writing, the Utilities SDK distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+ANY KIND, either express or implied. See the License for the specific language governing
+permissions and limitations under the License.
+************************************************************************************/
+
+using UnityEngine;
+using UnityEngine.Assertions;
+using UnityEngine.Serialization;
+
+namespace Oculus.Interaction.Input
+{
+    // When it is desired for HandDataAsset to drive OVRSkeleton, the DataSources:
+    // Must execute after OVRHands (so that the modifier stack can read the latest IsTracked value)
+    // Must execute before OVRSkeleton (so that the created IOVRSkeletonDataProvider injected into
+    // OVRSkeleton can read from the updated HandDataAsset)
+    //   By deriving from InputDataProviderUpdateTrigger, we ensure that the InputData will be
+    //   invalidated at the right time (at priority -85), so that it is recalculated just-in-time
+    //   in the skeleton data callbacks (at priority -80)
+    [DefaultExecutionOrder(-85)]
+    public class InputDataProviderUpdateTriggerOVR : MonoBehaviour
+    {
+        [SerializeField, Interface(typeof(IDataSource))]
+        private MonoBehaviour _dataSource;
+        private IDataSource DataSource;
+
+        [SerializeField]
+        private bool _enableUpdate = true;
+        [SerializeField]
+        private bool _enableFixedUpdate = true;
+
+        [SerializeField, Interface(typeof(IOVRCameraRigRef)), Optional]
+        private MonoBehaviour _cameraRigRef;
+
+        protected bool _started = false;
+
+        public IOVRCameraRigRef CameraRigRef { get; private set; } = null;
+
+        protected virtual void Awake()
+        {
+            DataSource = _dataSource as IDataSource;
+            CameraRigRef = _cameraRigRef as IOVRCameraRigRef;
+        }
+
+        protected virtual void Start()
+        {
+            this.BeginStart(ref _started);
+            Assert.IsNotNull(DataSource);
+            if (_cameraRigRef != null)
+            {
+                Assert.IsNotNull(CameraRigRef);
+            }
+            this.EndStart(ref _started);
+        }
+
+        protected virtual void OnEnable()
+        {
+            if (_started)
+            {
+                if (CameraRigRef != null)
+                {
+                    CameraRigRef.OnAnchorsUpdated += MarkRequiresUpdate;
+                }
+            }
+        }
+
+        private void MarkRequiresUpdate()
+        {
+            DataSource.MarkInputDataRequiresUpdate();
+        }
+
+        protected virtual void Update()
+        {
+            if (_enableUpdate)
+            {
+                MarkRequiresUpdate();
+            }
+        }
+
+        protected virtual void FixedUpdate()
+        {
+            if (_enableFixedUpdate)
+            {
+                MarkRequiresUpdate();
+            }
+        }
+
+        protected virtual void OnDisable()
+        {
+            if (_started)
+            {
+                if (CameraRigRef != null)
+                {
+                    CameraRigRef.OnAnchorsUpdated -= MarkRequiresUpdate;
+                }
+            }
+        }
+
+        #region Inject
+
+        public void InjectAllInputDataProviderUpdateTriggerOVR(IDataSource dataSource, bool enableUpdate, bool enableFixedUpdate)
+        {
+            InjectDataSource(dataSource);
+            InjectEnableUpdate(enableUpdate);
+            InjectEnableFixedUpdate(enableFixedUpdate);
+        }
+
+        public void InjectDataSource(IDataSource dataSource)
+        {
+            _dataSource = dataSource as MonoBehaviour;
+            DataSource = dataSource;
+        }
+
+        public void InjectEnableUpdate(bool enableUpdate)
+        {
+            _enableUpdate = enableUpdate;
+        }
+
+        public void InjectEnableFixedUpdate(bool enableFixedUpdate)
+        {
+            _enableFixedUpdate = enableFixedUpdate;
+        }
+
+        public void InjectOptionalCameraRigRef(IOVRCameraRigRef cameraRigRef)
+        {
+            _cameraRigRef = cameraRigRef as MonoBehaviour;
+            CameraRigRef = cameraRigRef;
+        }
+
+        #endregion
+    }
+}

Assets/Oculus/Interaction/Runtime/Scripts/Input/OVRIntegration/InputDataProviderUpdateTriggerOVR.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7198950508e319a40b9b3ca5c3960e58
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/Interaction/Runtime/Scripts/Input/OVRIntegration/OVRCameraRigRef.cs

@@ -0,0 +1,133 @@
+/************************************************************************************
+Copyright : Copyright (c) Facebook Technologies, LLC and its affiliates. All rights reserved.
+
+Your use of this SDK or tool is subject to the Oculus SDK License Agreement, available at
+https://developer.oculus.com/licenses/oculussdk/
+
+Unless required by applicable law or agreed to in writing, the Utilities SDK distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+ANY KIND, either express or implied. See the License for the specific language governing
+permissions and limitations under the License.
+************************************************************************************/
+
+using System;
+using UnityEngine;
+using UnityEngine.Assertions;
+
+namespace Oculus.Interaction.Input
+{
+    public interface IOVRCameraRigRef
+    {
+        OVRCameraRig CameraRig { get; }
+        /// <summary>
+        /// Returns a valid OVRHand object representing the left hand, if one exists on the
+        /// OVRCameraRig. If none is available, returns null.
+        /// </summary>
+        OVRHand LeftHand { get; }
+        /// <summary>
+        /// Returns a valid OVRHand object representing the right hand, if one exists on the
+        /// OVRCameraRig. If none is available, returns null.
+        /// </summary>
+        OVRHand RightHand { get; }
+        Transform LeftController { get; }
+        Transform RightController { get; }
+
+        event Action OnAnchorsUpdated;
+    }
+
+    /// <summary>
+    /// Points to an OVRCameraRig instance. This level of indirection provides a single
+    /// configuration point on the root of a prefab.
+    /// Must execute before all other OVR related classes so that the fields are
+    /// initialized correctly and ready to use.
+    /// </summary>
+    [DefaultExecutionOrder(-90)]
+    public class OVRCameraRigRef : MonoBehaviour, IOVRCameraRigRef
+    {
+        [Header("Configuration")]
+        [SerializeField]
+        private OVRCameraRig _ovrCameraRig;
+
+        [SerializeField]
+        private bool _requireOvrHands = true;
+
+        public OVRCameraRig CameraRig => _ovrCameraRig;
+
+        private OVRHand _leftHand;
+        private OVRHand _rightHand;
+        public OVRHand LeftHand => GetHandCached(ref _leftHand, _ovrCameraRig.leftHandAnchor);
+        public OVRHand RightHand => GetHandCached(ref _rightHand, _ovrCameraRig.rightHandAnchor);
+
+        public Transform LeftController => _ovrCameraRig.leftControllerAnchor;
+        public Transform RightController => _ovrCameraRig.rightControllerAnchor;
+
+        public event Action OnAnchorsUpdated = delegate { };
+
+        protected bool _started = false;
+
+        protected virtual void Start()
+        {
+            this.BeginStart(ref _started);
+            Assert.IsNotNull(_ovrCameraRig);
+            this.EndStart(ref _started);
+        }
+
+        protected virtual void OnEnable()
+        {
+            if (_started)
+            {
+                _ovrCameraRig.UpdatedAnchors += OnUpdateAnchors;
+            }
+        }
+
+        protected virtual void OnDisable()
+        {
+            if (_started)
+            {
+                _ovrCameraRig.UpdatedAnchors -= OnUpdateAnchors;
+            }
+        }
+
+        private OVRHand GetHandCached(ref OVRHand cachedValue, Transform handAnchor)
+        {
+            if (cachedValue != null)
+            {
+                return cachedValue;
+            }
+
+            cachedValue = handAnchor.GetComponentInChildren<OVRHand>(true);
+            if (_requireOvrHands)
+            {
+                Assert.IsNotNull(cachedValue);
+            }
+
+            return cachedValue;
+        }
+
+        private void OnUpdateAnchors(OVRCameraRig ovrCameraRig)
+        {
+            OnAnchorsUpdated();
+        }
+
+        #region Inject
+        public void InjectAllOVRCameraRigRef(OVRCameraRig ovrCameraRig, bool requireHands)
+        {
+            InjectOVRCameraRig(ovrCameraRig);
+            InjectRequireHands(requireHands);
+        }
+
+        public void InjectOVRCameraRig(OVRCameraRig ovrCameraRig)
+        {
+            _ovrCameraRig = ovrCameraRig;
+            // Clear the cached values to force new values to be read on next access
+            _leftHand = null;
+            _rightHand = null;
+        }
+
+        public void InjectRequireHands(bool requireHands)
+        {
+            _requireOvrHands = requireHands;
+        }
+        #endregion
+    }
+}

Assets/Oculus/Interaction/Runtime/Scripts/Input/OVRIntegration/OVRCameraRigRef.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a7b47e36715521d4e8a30d2c5b6e83e2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/Interaction/Runtime/Scripts/Input/OVRIntegration/OVRInputDeviceActiveState.cs

@@ -0,0 +1,55 @@
+/************************************************************************************
+Copyright : Copyright (c) Facebook Technologies, LLC and its affiliates. All rights reserved.
+
+Your use of this SDK or tool is subject to the Oculus SDK License Agreement, available at
+https://developer.oculus.com/licenses/oculussdk/
+
+Unless required by applicable law or agreed to in writing, the Utilities SDK distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+ANY KIND, either express or implied. See the License for the specific language governing
+permissions and limitations under the License.
+************************************************************************************/
+
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Oculus.Interaction.Input
+{
+    /// <summary>
+    /// Returns the active status of an OVRInput device based on whether
+    /// OVRInput's current active controller matches any of the controller
+    /// types set up in the inspector. OVRInput `Controllers` include
+    /// types like Touch, L Touch, R TouchR, Hands, L Hand, R Hand
+    /// </summary>
+    public class OVRInputDeviceActiveState : MonoBehaviour, IActiveState
+    {
+        [SerializeField]
+        private List<OVRInput.Controller> _controllerTypes;
+
+        public bool Active
+        {
+            get
+            {
+                foreach (OVRInput.Controller controllerType in _controllerTypes)
+                {
+                    if (OVRInput.GetConnectedControllers() == controllerType) return true;
+                }
+                return false;
+            }
+        }
+
+        #region Inject
+
+        public void InjectAllOVRInputDeviceActiveState(List<OVRInput.Controller> controllerTypes)
+        {
+            InjectControllerTypes(controllerTypes);
+        }
+
+        public void InjectControllerTypes(List<OVRInput.Controller> controllerTypes)
+        {
+            _controllerTypes = controllerTypes;
+        }
+
+        #endregion
+    }
+}

Assets/Oculus/Interaction/Runtime/Scripts/Input/OVRIntegration/OVRInputDeviceActiveState.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ce6a3535bf452cd42a0b2fb1c571b76e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/Interaction/Runtime/Scripts/Input/OVRIntegration/OVRSkeletonData.cs

@@ -0,0 +1,171 @@
+/************************************************************************************
+Copyright : Copyright (c) Facebook Technologies, LLC and its affiliates. All rights reserved.
+
+Your use of this SDK or tool is subject to the Oculus SDK License Agreement, available at
+https://developer.oculus.com/licenses/oculussdk/
+
+Unless required by applicable law or agreed to in writing, the Utilities SDK distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+ANY KIND, either express or implied. See the License for the specific language governing
+permissions and limitations under the License.
+************************************************************************************/
+
+using UnityEngine;
+
+namespace Oculus.Interaction.Input
+{
+    public class OVRSkeletonData
+    {
+#if UNITY_EDITOR
+        // This method can be used to generate a serialized skeleton in C# format.
+        public static string CreateString(OVRPlugin.Skeleton2 skeleton)
+        {
+            string bonesJson = "";
+            for (int i = 0; i < skeleton.NumBones; i++)
+            {
+                var bone = skeleton.Bones[i];
+                bonesJson +=
+                    "new OVRPlugin.Bone() { " +
+                    "Id=OVRPlugin.BoneId." + bone.Id.ToString() + ", " +
+                    "ParentBoneIndex=" + bone.ParentBoneIndex + ", " +
+                    "Pose=new OVRPlugin.Posef() { " +
+                        "Position=new OVRPlugin.Vector3f() {x=" + bone.Pose.Position.x + "f,y=" + bone.Pose.Position.y + "f,z=" + bone.Pose.Position.z + "f}, " +
+                        "Orientation=new OVRPlugin.Quatf(){x=" + bone.Pose.Orientation.x + "f,y=" + bone.Pose.Orientation.y + "f,z=" + bone.Pose.Orientation.z + "f,w=" + bone.Pose.Orientation.w + "f}}}";
+                if (i != skeleton.Bones.Length - 1)
+                {
+                    bonesJson += ",";
+                }
+                bonesJson += "\n";
+            }
+
+            string boneCapsulesJson = "";
+            for (int i = 0; i < skeleton.NumBoneCapsules; i++)
+            {
+                var cap = skeleton.BoneCapsules[i];
+                boneCapsulesJson += "new OVRPlugin.BoneCapsule() { BoneIndex=" + cap.BoneIndex + ", Radius=" + cap.Radius + "f, " +
+                    "StartPoint=new OVRPlugin.Vector3f() {x=" + cap.StartPoint.x + "f,y=" + cap.StartPoint.y + "f,z=" + cap.StartPoint.z + "f}, " +
+                    "EndPoint=new OVRPlugin.Vector3f() {x=" + cap.EndPoint.x + "f,y=" + cap.EndPoint.y + "f,z=" + cap.EndPoint.z + "f}}";
+                if (i != skeleton.Bones.Length - 1)
+                {
+                    boneCapsulesJson += ",";
+                }
+                boneCapsulesJson += "\n";
+            }
+
+            return "new OVRPlugin.Skeleton2() { " +
+                "Type=OVRPlugin.SkeletonType." + skeleton.Type.ToString() + ", " +
+                "NumBones=" + skeleton.NumBones + ", " +
+                "NumBoneCapsules=" + skeleton.NumBoneCapsules + ", " +
+                "Bones=new OVRPlugin.Bone[] {" + bonesJson + "}, " +
+                "BoneCapsules=new OVRPlugin.BoneCapsule[] {" + boneCapsulesJson + "}" +
+                "};";
+        }
+#endif
+
+        public static readonly OVRPlugin.Skeleton2 LeftSkeleton = new OVRPlugin.Skeleton2()
+        {
+            Type = OVRPlugin.SkeletonType.HandLeft,
+            NumBones = 24,
+            NumBoneCapsules = 19,
+            Bones = new OVRPlugin.Bone[] {
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_Start, ParentBoneIndex=-1, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=0f,y=0f,z=0f}, Orientation=new OVRPlugin.Quatf(){x=0f,y=0f,z=0f,w=1f}}},
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_ForearmStub, ParentBoneIndex=0, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=0f,y=0f,z=0f}, Orientation=new OVRPlugin.Quatf(){x=0f,y=0f,z=0f,w=1f}}},
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_Thumb0, ParentBoneIndex=0, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=0.0200693f,y=0.0115541f,z=-0.01049652f}, Orientation=new OVRPlugin.Quatf(){x=0.3753869f,y=0.4245841f,z=-0.007778856f,w=0.8238644f}}},
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_Thumb1, ParentBoneIndex=2, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=0.02485256f,y=-9.31E-10f,z=-1.863E-09f}, Orientation=new OVRPlugin.Quatf(){x=0.2602303f,y=0.02433088f,z=0.125678f,w=0.9570231f}}},
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_Thumb2, ParentBoneIndex=3, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=0.03251291f,y=5.82E-10f,z=1.863E-09f}, Orientation=new OVRPlugin.Quatf(){x=-0.08270377f,y=-0.0769617f,z=-0.08406223f,w=0.9900357f}}},
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_Thumb3, ParentBoneIndex=4, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=0.0337931f,y=3.26E-09f,z=1.863E-09f}, Orientation=new OVRPlugin.Quatf(){x=0.08350593f,y=0.06501573f,z=-0.05827406f,w=0.9926752f}}},
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_Index1, ParentBoneIndex=0, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=0.09599624f,y=0.007316455f,z=-0.02355068f}, Orientation=new OVRPlugin.Quatf(){x=0.03068309f,y=-0.01885559f,z=0.04328144f,w=0.9984136f}}},
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_Index2, ParentBoneIndex=6, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=0.0379273f,y=-5.82E-10f,z=-5.97E-10f}, Orientation=new OVRPlugin.Quatf(){x=-0.02585241f,y=-0.007116061f,z=0.003292944f,w=0.999635f}}},
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_Index3, ParentBoneIndex=7, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=0.02430365f,y=-6.73E-10f,z=-6.75E-10f}, Orientation=new OVRPlugin.Quatf(){x=-0.016056f,y=-0.02714872f,z=-0.072034f,w=0.9969034f}}},
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_Middle1, ParentBoneIndex=0, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=0.09564661f,y=0.002543155f,z=-0.001725906f}, Orientation=new OVRPlugin.Quatf(){x=-0.009066326f,y=-0.05146559f,z=0.05183575f,w=0.9972874f}}},
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_Middle2, ParentBoneIndex=9, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=0.042927f,y=-8.51E-10f,z=-1.193E-09f}, Orientation=new OVRPlugin.Quatf(){x=-0.01122823f,y=-0.004378874f,z=-0.001978267f,w=0.9999254f}}},
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_Middle3, ParentBoneIndex=10, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=0.02754958f,y=3.09E-10f,z=1.128E-09f}, Orientation=new OVRPlugin.Quatf(){x=-0.03431955f,y=-0.004611839f,z=-0.09300701f,w=0.9950631f}}},
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_Ring1, ParentBoneIndex=0, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=0.0886938f,y=0.006529308f,z=0.01746524f}, Orientation=new OVRPlugin.Quatf(){x=-0.05315936f,y=-0.1231034f,z=0.04981349f,w=0.9897162f}}},
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_Ring2, ParentBoneIndex=12, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=0.0389961f,y=0f,z=5.24E-10f}, Orientation=new OVRPlugin.Quatf(){x=-0.03363252f,y=-0.00278984f,z=0.00567602f,w=0.9994143f}}},
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_Ring3, ParentBoneIndex=13, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=0.02657339f,y=1.281E-09f,z=1.63E-09f}, Orientation=new OVRPlugin.Quatf(){x=-0.003477462f,y=0.02917945f,z=-0.02502854f,w=0.9992548f}}},
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_Pinky0, ParentBoneIndex=0, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=0.03407356f,y=0.009419836f,z=0.02299858f}, Orientation=new OVRPlugin.Quatf(){x=-0.207036f,y=-0.1403428f,z=0.0183118f,w=0.9680417f}}},
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_Pinky1, ParentBoneIndex=15, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=0.04565055f,y=9.97679E-07f,z=-2.193963E-06f}, Orientation=new OVRPlugin.Quatf(){x=0.09111304f,y=0.00407137f,z=0.02812923f,w=0.9954349f}}},
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_Pinky2, ParentBoneIndex=16, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=0.03072042f,y=1.048E-09f,z=-1.75E-10f}, Orientation=new OVRPlugin.Quatf(){x=-0.03761665f,y=-0.04293772f,z=-0.01328605f,w=0.9982809f}}},
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_Pinky3, ParentBoneIndex=17, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=0.02031138f,y=-2.91E-10f,z=9.31E-10f}, Orientation=new OVRPlugin.Quatf(){x=0.0006447434f,y=0.04917067f,z=-0.02401883f,w=0.9985014f}}},
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_ThumbTip, ParentBoneIndex=5, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=0.02459077f,y=-0.001026974f,z=0.0006703701f}, Orientation=new OVRPlugin.Quatf(){x=0f,y=0f,z=0f,w=1f}}},
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_IndexTip, ParentBoneIndex=8, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=0.02236338f,y=-0.00102507f,z=0.0002956076f}, Orientation=new OVRPlugin.Quatf(){x=0f,y=0f,z=0f,w=1f}}},
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_MiddleTip, ParentBoneIndex=11, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=0.02496492f,y=-0.001137299f,z=0.0003086528f}, Orientation=new OVRPlugin.Quatf(){x=0f,y=0f,z=0f,w=1f}}},
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_RingTip, ParentBoneIndex=14, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=0.02432613f,y=-0.001608172f,z=0.000257905f}, Orientation=new OVRPlugin.Quatf(){x=0f,y=0f,z=0f,w=1f}}},
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_PinkyTip, ParentBoneIndex=18, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=0.02192238f,y=-0.001216086f,z=-0.0002464796f}, Orientation=new OVRPlugin.Quatf(){x=0f,y=0f,z=0f,w=1f}}},
+        },
+            BoneCapsules = new OVRPlugin.BoneCapsule[] {
+            new OVRPlugin.BoneCapsule() { BoneIndex=0, Radius=0.01822828f, StartPoint=new OVRPlugin.Vector3f() {x=0.02755879f,y=0.01404149f,z=-0.01685145f}, EndPoint=new OVRPlugin.Vector3f() {x=0.07794081f,y=0.009090679f,z=-0.02178327f}},
+            new OVRPlugin.BoneCapsule() { BoneIndex=0, Radius=0.02323196f, StartPoint=new OVRPlugin.Vector3f() {x=0.02632602f,y=0.008661013f,z=-0.006531342f}, EndPoint=new OVRPlugin.Vector3f() {x=0.07255958f,y=0.004580691f,z=-0.003326343f}},
+            new OVRPlugin.BoneCapsule() { BoneIndex=0, Radius=0.01608828f, StartPoint=new OVRPlugin.Vector3f() {x=0.0297035f,y=0.00920606f,z=0.01111641f}, EndPoint=new OVRPlugin.Vector3f() {x=0.07271415f,y=0.007254403f,z=0.01574543f}},
+            new OVRPlugin.BoneCapsule() { BoneIndex=0, Radius=0.02346085f, StartPoint=new OVRPlugin.Vector3f() {x=0.02844799f,y=0.008827154f,z=0.01446979f}, EndPoint=new OVRPlugin.Vector3f() {x=0.06036391f,y=0.009573798f,z=0.02133043f}},
+            new OVRPlugin.BoneCapsule() { BoneIndex=3, Radius=0.01838252f, StartPoint=new OVRPlugin.Vector3f() {x=0f,y=2.561E-09f,z=1.863E-09f}, EndPoint=new OVRPlugin.Vector3f() {x=0.03251291f,y=6.98E-10f,z=-3.492E-09f}},
+            new OVRPlugin.BoneCapsule() { BoneIndex=4, Radius=0.01028295f, StartPoint=new OVRPlugin.Vector3f() {x=7.451E-09f,y=2.794E-09f,z=-3.725E-09f}, EndPoint=new OVRPlugin.Vector3f() {x=0.03379309f,y=6.519E-09f,z=-8.382E-09f}},
+            new OVRPlugin.BoneCapsule() { BoneIndex=5, Radius=0.009768805f, StartPoint=new OVRPlugin.Vector3f() {x=7.451E-09f,y=5.588E-09f,z=-4.657E-09f}, EndPoint=new OVRPlugin.Vector3f() {x=0.01500075f,y=-0.0006525163f,z=0.0005929575f}},
+            new OVRPlugin.BoneCapsule() { BoneIndex=6, Radius=0.01029526f, StartPoint=new OVRPlugin.Vector3f() {x=0f,y=0f,z=-1.863E-09f}, EndPoint=new OVRPlugin.Vector3f() {x=0.03792731f,y=4.66E-10f,z=-3.725E-09f}},
+            new OVRPlugin.BoneCapsule() { BoneIndex=7, Radius=0.008038102f, StartPoint=new OVRPlugin.Vector3f() {x=0f,y=-9.31E-10f,z=-1.863E-09f}, EndPoint=new OVRPlugin.Vector3f() {x=0.02430364f,y=-1.863E-09f,z=-3.725E-09f}},
+            new OVRPlugin.BoneCapsule() { BoneIndex=8, Radius=0.007636196f, StartPoint=new OVRPlugin.Vector3f() {x=-1.4901E-08f,y=-1.863E-09f,z=0f}, EndPoint=new OVRPlugin.Vector3f() {x=0.01507758f,y=-0.0005028695f,z=6.049499E-05f}},
+            new OVRPlugin.BoneCapsule() { BoneIndex=9, Radius=0.01117394f, StartPoint=new OVRPlugin.Vector3f() {x=0f,y=-4.66E-10f,z=9.31E-10f}, EndPoint=new OVRPlugin.Vector3f() {x=0.042927f,y=-2.328E-09f,z=-9.31E-10f}},
+            new OVRPlugin.BoneCapsule() { BoneIndex=10, Radius=0.008030958f, StartPoint=new OVRPlugin.Vector3f() {x=1.4901E-08f,y=-4.66E-10f,z=0f}, EndPoint=new OVRPlugin.Vector3f() {x=0.02754962f,y=-4.66E-10f,z=-1.863E-09f}},
+            new OVRPlugin.BoneCapsule() { BoneIndex=11, Radius=0.007629411f, StartPoint=new OVRPlugin.Vector3f() {x=1.4901E-08f,y=-3.725E-09f,z=0f}, EndPoint=new OVRPlugin.Vector3f() {x=0.01719159f,y=-0.0007450115f,z=0.0004036371f}},
+            new OVRPlugin.BoneCapsule() { BoneIndex=12, Radius=0.009922137f, StartPoint=new OVRPlugin.Vector3f() {x=0f,y=2.33E-10f,z=2.328E-09f}, EndPoint=new OVRPlugin.Vector3f() {x=0.03899612f,y=0f,z=4.66E-10f}},
+            new OVRPlugin.BoneCapsule() { BoneIndex=13, Radius=0.007611672f, StartPoint=new OVRPlugin.Vector3f() {x=1.4901E-08f,y=-4.66E-10f,z=1.863E-09f}, EndPoint=new OVRPlugin.Vector3f() {x=0.02657339f,y=1.397E-09f,z=0f}},
+            new OVRPlugin.BoneCapsule() { BoneIndex=14, Radius=0.007231089f, StartPoint=new OVRPlugin.Vector3f() {x=0f,y=9.31E-10f,z=2.328E-09f}, EndPoint=new OVRPlugin.Vector3f() {x=0.01632451f,y=-0.001288094f,z=0.0001235888f}},
+            new OVRPlugin.BoneCapsule() { BoneIndex=16, Radius=0.008483353f, StartPoint=new OVRPlugin.Vector3f() {x=0f,y=-2.33E-10f,z=1.863E-09f}, EndPoint=new OVRPlugin.Vector3f() {x=0.03072041f,y=-1.164E-09f,z=0f}},
+            new OVRPlugin.BoneCapsule() { BoneIndex=17, Radius=0.006764194f, StartPoint=new OVRPlugin.Vector3f() {x=-7.451E-09f,y=-1.717E-09f,z=1.863E-09f}, EndPoint=new OVRPlugin.Vector3f() {x=0.02031137f,y=1.46E-10f,z=1.863E-09f}},
+            new OVRPlugin.BoneCapsule() { BoneIndex=18, Radius=0.006425985f, StartPoint=new OVRPlugin.Vector3f() {x=0f,y=0f,z=-1.863E-09f}, EndPoint=new OVRPlugin.Vector3f() {x=0.01507002f,y=-0.0006056242f,z=-2.491474E-05f}},
+        }
+        };
+
+        public static readonly OVRPlugin.Skeleton2 RightSkeleton = new OVRPlugin.Skeleton2()
+        {
+            Type = OVRPlugin.SkeletonType.HandRight,
+            NumBones = 24,
+            NumBoneCapsules = 19,
+            Bones = new OVRPlugin.Bone[] {new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_Start, ParentBoneIndex=-1, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=0f,y=0f,z=0f}, Orientation=new OVRPlugin.Quatf(){x=0f,y=0f,z=0f,w=1f}}},
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_ForearmStub, ParentBoneIndex=0, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=0f,y=0f,z=0f}, Orientation=new OVRPlugin.Quatf(){x=0f,y=0f,z=0f,w=1f}}},
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_Thumb0, ParentBoneIndex=0, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=-0.0200693f,y=-0.0115541f,z=0.01049652f}, Orientation=new OVRPlugin.Quatf(){x=0.3753869f,y=0.4245841f,z=-0.007778856f,w=0.8238644f}}},
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_Thumb1, ParentBoneIndex=2, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=-0.02485256f,y=2.328E-09f,z=0f}, Orientation=new OVRPlugin.Quatf(){x=0.2602303f,y=0.02433088f,z=0.125678f,w=0.9570231f}}},
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_Thumb2, ParentBoneIndex=3, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=-0.03251291f,y=-1.16E-10f,z=0f}, Orientation=new OVRPlugin.Quatf(){x=-0.08270377f,y=-0.0769617f,z=-0.08406223f,w=0.9900357f}}},
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_Thumb3, ParentBoneIndex=4, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=-0.0337931f,y=-3.26E-09f,z=-1.863E-09f}, Orientation=new OVRPlugin.Quatf(){x=0.08350593f,y=0.06501573f,z=-0.05827406f,w=0.9926752f}}},
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_Index1, ParentBoneIndex=0, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=-0.09599624f,y=-0.007316455f,z=0.02355068f}, Orientation=new OVRPlugin.Quatf(){x=0.03068309f,y=-0.01885559f,z=0.04328144f,w=0.9984136f}}},
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_Index2, ParentBoneIndex=6, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=-0.0379273f,y=1.16E-10f,z=5.97E-10f}, Orientation=new OVRPlugin.Quatf(){x=-0.02585241f,y=-0.007116061f,z=0.003292944f,w=0.999635f}}},
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_Index3, ParentBoneIndex=7, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=-0.02430365f,y=6.73E-10f,z=6.75E-10f}, Orientation=new OVRPlugin.Quatf(){x=-0.016056f,y=-0.02714872f,z=-0.072034f,w=0.9969034f}}},
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_Middle1, ParentBoneIndex=0, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=-0.09564661f,y=-0.002543155f,z=0.001725906f}, Orientation=new OVRPlugin.Quatf(){x=-0.009066326f,y=-0.05146559f,z=0.05183575f,w=0.9972874f}}},
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_Middle2, ParentBoneIndex=9, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=-0.042927f,y=1.317E-09f,z=1.193E-09f}, Orientation=new OVRPlugin.Quatf(){x=-0.01122823f,y=-0.004378874f,z=-0.001978267f,w=0.9999254f}}},
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_Middle3, ParentBoneIndex=10, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=-0.02754958f,y=-7.71E-10f,z=-1.12E-09f}, Orientation=new OVRPlugin.Quatf(){x=-0.03431955f,y=-0.004611839f,z=-0.09300701f,w=0.9950631f}}},
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_Ring1, ParentBoneIndex=0, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=-0.0886938f,y=-0.006529307f,z=-0.01746524f}, Orientation=new OVRPlugin.Quatf(){x=-0.05315936f,y=-0.1231034f,z=0.04981349f,w=0.9897162f}}},
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_Ring2, ParentBoneIndex=12, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=-0.0389961f,y=-4.66E-10f,z=-5.24E-10f}, Orientation=new OVRPlugin.Quatf(){x=-0.03363252f,y=-0.00278984f,z=0.00567602f,w=0.9994143f}}},
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_Ring3, ParentBoneIndex=13, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=-0.02657339f,y=-1.281E-09f,z=-1.63E-09f}, Orientation=new OVRPlugin.Quatf(){x=-0.003477462f,y=0.02917945f,z=-0.02502854f,w=0.9992548f}}},
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_Pinky0, ParentBoneIndex=0, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=-0.03407356f,y=-0.009419835f,z=-0.02299858f}, Orientation=new OVRPlugin.Quatf(){x=-0.207036f,y=-0.1403428f,z=0.0183118f,w=0.9680417f}}},
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_Pinky1, ParentBoneIndex=15, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=-0.04565055f,y=-9.98611E-07f,z=2.193963E-06f}, Orientation=new OVRPlugin.Quatf(){x=0.09111304f,y=0.00407137f,z=0.02812923f,w=0.9954349f}}},
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_Pinky2, ParentBoneIndex=16, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=-0.03072042f,y=6.98E-10f,z=1.106E-09f}, Orientation=new OVRPlugin.Quatf(){x=-0.03761665f,y=-0.04293772f,z=-0.01328605f,w=0.9982809f}}},
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_Pinky3, ParentBoneIndex=17, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=-0.02031138f,y=-1.455E-09f,z=-1.397E-09f}, Orientation=new OVRPlugin.Quatf(){x=0.0006447434f,y=0.04917067f,z=-0.02401883f,w=0.9985014f}}},
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_ThumbTip, ParentBoneIndex=5, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=-0.02459077f,y=0.001026974f,z=-0.0006703701f}, Orientation=new OVRPlugin.Quatf(){x=0f,y=0f,z=0f,w=1f}}},
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_IndexTip, ParentBoneIndex=8, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=-0.02236338f,y=0.00102507f,z=-0.0002956076f}, Orientation=new OVRPlugin.Quatf(){x=0f,y=0f,z=0f,w=1f}}},
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_MiddleTip, ParentBoneIndex=11, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=-0.02496492f,y=0.001137299f,z=-0.0003086528f}, Orientation=new OVRPlugin.Quatf(){x=0f,y=0f,z=0f,w=1f}}},
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_RingTip, ParentBoneIndex=14, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=-0.02432613f,y=0.001608172f,z=-0.000257905f}, Orientation=new OVRPlugin.Quatf(){x=0f,y=0f,z=0f,w=1f}}},
+            new OVRPlugin.Bone() { Id=OVRPlugin.BoneId.Hand_PinkyTip, ParentBoneIndex=18, Pose=new OVRPlugin.Posef() { Position=new OVRPlugin.Vector3f() {x=-0.02192238f,y=0.001216086f,z=0.0002464796f}, Orientation=new OVRPlugin.Quatf(){x=0f,y=0f,z=0f,w=1f}}},
+        },
+            BoneCapsules = new OVRPlugin.BoneCapsule[] {new OVRPlugin.BoneCapsule() { BoneIndex=0, Radius=0.01822828f, StartPoint=new OVRPlugin.Vector3f() {x=-0.02755879f,y=-0.01404148f,z=0.01685145f}, EndPoint=new OVRPlugin.Vector3f() {x=-0.07794081f,y=-0.009090678f,z=0.02178326f}},
+            new OVRPlugin.BoneCapsule() { BoneIndex=0, Radius=0.02323196f, StartPoint=new OVRPlugin.Vector3f() {x=-0.02632602f,y=-0.008661013f,z=0.006531343f}, EndPoint=new OVRPlugin.Vector3f() {x=-0.07255958f,y=-0.004580691f,z=0.003326343f}},
+            new OVRPlugin.BoneCapsule() { BoneIndex=0, Radius=0.01608828f, StartPoint=new OVRPlugin.Vector3f() {x=-0.0297035f,y=-0.00920606f,z=-0.01111641f}, EndPoint=new OVRPlugin.Vector3f() {x=-0.07271415f,y=-0.007254403f,z=-0.01574543f}},
+            new OVRPlugin.BoneCapsule() { BoneIndex=0, Radius=0.02346085f, StartPoint=new OVRPlugin.Vector3f() {x=-0.02844799f,y=-0.008827153f,z=-0.01446979f}, EndPoint=new OVRPlugin.Vector3f() {x=-0.06036392f,y=-0.009573797f,z=-0.02133043f}},
+            new OVRPlugin.BoneCapsule() { BoneIndex=3, Radius=0.01838251f, StartPoint=new OVRPlugin.Vector3f() {x=3.725E-09f,y=-6.98E-10f,z=-2.794E-09f}, EndPoint=new OVRPlugin.Vector3f() {x=-0.03251291f,y=-6.98E-10f,z=2.561E-09f}},
+            new OVRPlugin.BoneCapsule() { BoneIndex=4, Radius=0.01028296f, StartPoint=new OVRPlugin.Vector3f() {x=0f,y=-9.31E-10f,z=5.588E-09f}, EndPoint=new OVRPlugin.Vector3f() {x=-0.03379308f,y=-4.657E-09f,z=1.0245E-08f}},
+            new OVRPlugin.BoneCapsule() { BoneIndex=5, Radius=0.009768807f, StartPoint=new OVRPlugin.Vector3f() {x=-7.451E-09f,y=1.863E-09f,z=8.382E-09f}, EndPoint=new OVRPlugin.Vector3f() {x=-0.0150008f,y=0.0006525647f,z=-0.000592957f}},
+            new OVRPlugin.BoneCapsule() { BoneIndex=6, Radius=0.01029526f, StartPoint=new OVRPlugin.Vector3f() {x=0f,y=4.66E-10f,z=1.863E-09f}, EndPoint=new OVRPlugin.Vector3f() {x=-0.03792731f,y=-4.66E-10f,z=3.725E-09f}},
+            new OVRPlugin.BoneCapsule() { BoneIndex=7, Radius=0.008038101f, StartPoint=new OVRPlugin.Vector3f() {x=0f,y=9.31E-10f,z=1.863E-09f}, EndPoint=new OVRPlugin.Vector3f() {x=-0.02430364f,y=1.863E-09f,z=3.725E-09f}},
+            new OVRPlugin.BoneCapsule() { BoneIndex=8, Radius=0.007636196f, StartPoint=new OVRPlugin.Vector3f() {x=1.4901E-08f,y=1.863E-09f,z=0f}, EndPoint=new OVRPlugin.Vector3f() {x=-0.01507759f,y=0.0005028695f,z=-6.052852E-05f}},
+            new OVRPlugin.BoneCapsule() { BoneIndex=9, Radius=0.01117394f, StartPoint=new OVRPlugin.Vector3f() {x=0f,y=0f,z=-9.31E-10f}, EndPoint=new OVRPlugin.Vector3f() {x=-0.042927f,y=1.863E-09f,z=9.31E-10f}},
+            new OVRPlugin.BoneCapsule() { BoneIndex=10, Radius=0.008030958f, StartPoint=new OVRPlugin.Vector3f() {x=-1.4901E-08f,y=0f,z=0f}, EndPoint=new OVRPlugin.Vector3f() {x=-0.02754962f,y=4.66E-10f,z=1.863E-09f}},
+            new OVRPlugin.BoneCapsule() { BoneIndex=11, Radius=0.00762941f, StartPoint=new OVRPlugin.Vector3f() {x=-1.4901E-08f,y=1.863E-09f,z=0f}, EndPoint=new OVRPlugin.Vector3f() {x=-0.01719156f,y=0.0007450022f,z=-0.0004036473f}},
+            new OVRPlugin.BoneCapsule() { BoneIndex=12, Radius=0.009922139f, StartPoint=new OVRPlugin.Vector3f() {x=0f,y=-2.33E-10f,z=-2.328E-09f}, EndPoint=new OVRPlugin.Vector3f() {x=-0.03899612f,y=4.66E-10f,z=-4.66E-10f}},
+            new OVRPlugin.BoneCapsule() { BoneIndex=13, Radius=0.007611674f, StartPoint=new OVRPlugin.Vector3f() {x=-1.4901E-08f,y=1.863E-09f,z=-1.863E-09f}, EndPoint=new OVRPlugin.Vector3f() {x=-0.02657339f,y=0f,z=0f}},
+            new OVRPlugin.BoneCapsule() { BoneIndex=14, Radius=0.00723109f, StartPoint=new OVRPlugin.Vector3f() {x=0f,y=9.31E-10f,z=-2.328E-09f}, EndPoint=new OVRPlugin.Vector3f() {x=-0.01632455f,y=0.001288087f,z=-0.0001235851f}},
+            new OVRPlugin.BoneCapsule() { BoneIndex=16, Radius=0.008483353f, StartPoint=new OVRPlugin.Vector3f() {x=0f,y=2.33E-10f,z=-1.863E-09f}, EndPoint=new OVRPlugin.Vector3f() {x=-0.03072041f,y=1.164E-09f,z=0f}},
+            new OVRPlugin.BoneCapsule() { BoneIndex=17, Radius=0.006764191f, StartPoint=new OVRPlugin.Vector3f() {x=7.451E-09f,y=1.717E-09f,z=1.863E-09f}, EndPoint=new OVRPlugin.Vector3f() {x=-0.02031137f,y=-1.46E-10f,z=-1.863E-09f}},
+            new OVRPlugin.BoneCapsule() { BoneIndex=18, Radius=0.006425982f, StartPoint=new OVRPlugin.Vector3f() {x=0f,y=0f,z=1.863E-09f}, EndPoint=new OVRPlugin.Vector3f() {x=-0.01507004f,y=0.0006056186f,z=2.490915E-05f}},
+        }
+        };
+    }
+}

Assets/Oculus/Interaction/Runtime/Scripts/Input/OVRIntegration/OVRSkeletonData.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: dfb63309ade4ca04dbff7beff6784781
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/Interaction/Runtime/Scripts/Input/OVRIntegration/OVRSkeletonDataProviders.cs

@@ -0,0 +1,690 @@
+/************************************************************************************
+Copyright : Copyright (c) Facebook Technologies, LLC and its affiliates. All rights reserved.
+
+Your use of this SDK or tool is subject to the Oculus SDK License Agreement, available at
+https://developer.oculus.com/licenses/oculussdk/
+
+Unless required by applicable law or agreed to in writing, the Utilities SDK distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+ANY KIND, either express or implied. See the License for the specific language governing
+permissions and limitations under the License.
+************************************************************************************/
+
+using UnityEngine;
+using UnityEngine.Assertions;
+using UnityEngine.Serialization;
+using static OVRMesh;
+using static OVRMeshRenderer;
+using static OVRSkeleton;
+using static OVRSkeletonRenderer;
+
+namespace Oculus.Interaction.Input
+{
+    public delegate HandDataAsset HandInputDataReadFunction();
+
+    internal class OVRInputHandComponents
+    {
+        public OVRInputHandComponents(Transform handAnchor)
+        {
+            Anchor = handAnchor;
+            OvrHand = handAnchor.GetComponentInChildren<OVRHand>(true);
+            if (OvrHand != null)
+            {
+                OvrMesh = OvrHand.GetComponent<OVRMesh>();
+                OvrMeshRenderer = OvrHand.GetComponent<OVRMeshRenderer>();
+                OvrSkeleton = OvrHand.GetComponent<OVRSkeleton>();
+                OvrSkeletonRenderer = OvrHand.GetComponent<OVRSkeletonRenderer>();
+            }
+        }
+
+        public Transform Anchor { get; }
+        public OVRMesh OvrMesh { get; }
+        public OVRMeshRenderer OvrMeshRenderer { get; }
+        public OVRSkeleton OvrSkeleton { get; }
+        public OVRSkeletonRenderer OvrSkeletonRenderer { get; }
+        public OVRHand OvrHand { get; }
+    }
+
+    public enum HandRenderPoseOriginBehavior
+    {
+        /// <summary>
+        /// Show hand if it's PoseOrigin is RawTrackedPose or FilteredTrackedPose, regardless of the
+        /// tracking confidence
+        /// </summary>
+        ShowTrackedOnly,
+
+        /// <summary>
+        /// Show hand if it's PoseOrigin is RawTrackedPose or FilteredTrackedPose, and also has high
+        /// tracking confidence
+        /// </summary>
+        ShowHighConfidenceTrackedOnly,
+
+        /// <summary>
+        /// Show hand if it's PoseOrigin is any value other than None, and it is connected.
+        /// </summary>
+        ShowConnectedOnly,
+    }
+
+    public class BaseOVRDataProvider
+    {
+        private readonly HandRenderPoseOriginBehavior _poseOriginBehavior;
+
+        protected BaseOVRDataProvider(HandRenderPoseOriginBehavior poseOriginBehavior)
+        {
+            this._poseOriginBehavior = poseOriginBehavior;
+        }
+
+        public bool ToOvrConfidence(HandDataAsset handDataAsset)
+        {
+
+            bool isRootPoseTracked =
+                handDataAsset.RootPoseOrigin == PoseOrigin.RawTrackedPose ||
+                handDataAsset.RootPoseOrigin == PoseOrigin.FilteredTrackedPose;
+            switch (_poseOriginBehavior)
+            {
+                case HandRenderPoseOriginBehavior.ShowConnectedOnly:
+                    {
+                        bool isSyntheticPose =
+                            handDataAsset.RootPoseOrigin == PoseOrigin.SyntheticPose;
+                        return isRootPoseTracked || isSyntheticPose;
+                    }
+                case HandRenderPoseOriginBehavior.ShowTrackedOnly:
+                    return isRootPoseTracked;
+                case HandRenderPoseOriginBehavior.ShowHighConfidenceTrackedOnly:
+                    return isRootPoseTracked && handDataAsset.IsHighConfidence;
+                default:
+                    // Should not reach this.
+                    return false;
+            }
+        }
+
+    }
+
+    public class FromDataAssetOVRMeshRendererDataProvider : BaseOVRDataProvider, IOVRMeshRendererDataProvider
+    {
+        public IOVRMeshRendererDataProvider originalProvider;
+        public HandInputDataReadFunction handInputDataProvider;
+
+        public FromDataAssetOVRMeshRendererDataProvider(
+            HandRenderPoseOriginBehavior poseOriginBehavior) : base(poseOriginBehavior)
+        {
+        }
+
+        public MeshRendererData GetMeshRendererData()
+        {
+            var data = originalProvider.GetMeshRendererData();
+
+            var handInputData = handInputDataProvider.Invoke();
+            if (handInputData == null)
+            {
+                return data;
+            }
+
+            if (!data.IsDataValid)
+            {
+                data.ShouldUseSystemGestureMaterial = false;
+            }
+
+            data.IsDataValid = handInputData.IsDataValid && handInputData.IsConnected;
+            if (!data.IsDataValid)
+            {
+                return data;
+            }
+
+            data.IsDataHighConfidence = ToOvrConfidence(handInputData);
+
+            return data;
+        }
+    }
+
+    public class FromDataAssetOVRSkeletonDataProvider : BaseOVRDataProvider, IOVRSkeletonDataProvider
+    {
+        public IOVRSkeletonDataProvider originalProvider;
+        public HandInputDataReadFunction handInputDataProvider;
+        public SkeletonType skeletonType;
+
+        private readonly OVRPlugin.Quatf[] _boneRotations =
+            new OVRPlugin.Quatf[OVRSkeletonData.LeftSkeleton.NumBones];
+
+        private SkeletonPoseData _poseData;
+
+        public FromDataAssetOVRSkeletonDataProvider(
+            HandRenderPoseOriginBehavior poseOriginBehavior) : base(poseOriginBehavior)
+        {
+        }
+
+        public static int InitialSkeletonChangeCount => 1;
+
+        public SkeletonPoseData GetSkeletonPoseData()
+        {
+            return _poseData;
+        }
+
+        public void UpdateSkeletonPoseData()
+        {
+            _poseData = originalProvider.GetSkeletonPoseData();
+
+            // If the hand is not connected, treat it as if there is no valid data.
+            var handInputData = handInputDataProvider.Invoke();
+
+            bool isValid = handInputData.IsDataValid && handInputData.IsConnected;
+            _poseData.IsDataValid = isValid;
+            if (!isValid)
+            {
+                return;
+            }
+
+            for (int i = 0; i < _boneRotations.Length; i++)
+            {
+                _boneRotations[i] = handInputData.Joints[i].ToFlippedXQuatf();
+            }
+
+            if (handInputData.HandScale <= 0.0f)
+            {
+                // If handScale is zero it will cause rendering artifacts on the hand meshes.
+                handInputData.HandScale = 1.0f;
+            }
+
+            _poseData.IsDataHighConfidence = ToOvrConfidence(handInputData);
+            _poseData.BoneRotations = _boneRotations;
+            _poseData.RootPose = new OVRPlugin.Posef()
+            {
+                Orientation = handInputData.Root.rotation.ToFlippedZQuatf(),
+                Position = handInputData.Root.position.ToFlippedZVector3f()
+            };
+            _poseData.RootScale = handInputData.HandScale;
+        }
+
+        public SkeletonType GetSkeletonType()
+        {
+            return skeletonType;
+        }
+    }
+
+    public class FromDataAssetOVRSkeletonRendererDataProvider : BaseOVRDataProvider, IOVRSkeletonRendererDataProvider
+    {
+        public HandInputDataReadFunction handInputDataProvider;
+        public IOVRSkeletonRendererDataProvider originalProvider;
+
+        public FromDataAssetOVRSkeletonRendererDataProvider(
+            HandRenderPoseOriginBehavior poseOriginBehavior) : base(poseOriginBehavior)
+        {
+        }
+
+        public SkeletonRendererData GetSkeletonRendererData()
+        {
+            var data = new SkeletonRendererData();
+            var handInputData = handInputDataProvider.Invoke();
+            if (handInputData == null)
+            {
+                return originalProvider.GetSkeletonRendererData();
+            }
+
+            data.IsDataValid = handInputData.RootPoseOrigin != PoseOrigin.None;
+            data.IsDataHighConfidence = ToOvrConfidence(handInputData);
+            data.RootScale = handInputData.HandScale;
+            data.ShouldUseSystemGestureMaterial = false;
+            return data;
+        }
+    }
+
+    /// <summary>
+    /// Reads hand & HMD pose data from the DataSources, and copies them onto the
+    /// given OVRSkeleton. Can also provide more sophisticated control of the mesh rendering,
+    /// to keep hand meshes visible when tracking is lost.
+    ///
+    /// This class is not required if you are using the HandSkeletonVisual to render the hand.
+    /// </summary>
+    public class OVRSkeletonDataProviders : MonoBehaviour
+    {
+        [SerializeField, Interface(typeof(IOVRCameraRigRef))]
+        private MonoBehaviour _cameraRigRef;
+
+        public IOVRCameraRigRef CameraRigRef { get; private set; }
+
+        [Header("Update CameraRig Transforms")]
+        [SerializeField, Interface(typeof(IDataSource<HmdDataAsset, HmdDataSourceConfig>))]
+        private MonoBehaviour _hmdData;
+        private IDataSource<HmdDataAsset, HmdDataSourceConfig> _hmdDataSource;
+
+        [SerializeField]
+        private Hand _leftHand;
+
+        [SerializeField]
+        private Hand _rightHand;
+
+        [SerializeField]
+        private bool _modifyCameraRigAnchorTransforms = true;
+
+        [SerializeField]
+        private bool _modifyHandTransformsLeft = true;
+
+        [SerializeField]
+        private bool _modifyHandTransformsRight = true;
+
+        [Header("Hand Meshes")]
+        [Tooltip("If true, use the following hand meshes in place of those provided by OVRPlugin")]
+        [SerializeField]
+        private bool _replaceHandMeshRendererProviders = true;
+
+        [SerializeField, Optional]
+        private Mesh _leftHandMesh;
+
+        [SerializeField, Optional]
+        private Mesh _rightHandMesh;
+
+        [SerializeField]
+        private HandRenderPoseOriginBehavior _handRenderBehavior =
+            HandRenderPoseOriginBehavior.ShowConnectedOnly;
+
+        OVRInputHandComponents _leftHandComponents;
+        OVRInputHandComponents _rightHandComponents;
+        private FromDataAssetOVRSkeletonDataProvider _leftHandOvrSkeletonDataProvider;
+        private FromDataAssetOVRSkeletonDataProvider _rightHandOvrSkeletonDataProvider;
+
+        private const System.Reflection.BindingFlags PrivateInstanceFlags =
+            System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance;
+
+        private const System.Reflection.BindingFlags InstanceFlags =
+            PrivateInstanceFlags | System.Reflection.BindingFlags.Public;
+
+        public void SetModifyCameraRigAndHandTransformState(bool modifyCameraRig,
+            bool modifyLeftHand, bool modifyRightHand)
+        {
+            _modifyCameraRigAnchorTransforms = modifyCameraRig;
+            _modifyHandTransformsLeft = modifyLeftHand;
+            _modifyHandTransformsRight = modifyRightHand;
+        }
+
+        protected bool _started = false;
+
+        protected virtual void Awake()
+        {
+            CameraRigRef = _cameraRigRef as IOVRCameraRigRef;
+            _hmdDataSource = _hmdData as IDataSource<HmdDataAsset, HmdDataSourceConfig>;
+        }
+
+        protected virtual void Start()
+        {
+            this.BeginStart(ref _started);
+            Assert.IsNotNull(CameraRigRef);
+            Assert.IsNotNull(_hmdDataSource);
+            Assert.IsNotNull(_leftHand);
+            Assert.IsNotNull(_rightHand);
+
+            OVRCameraRig cameraRig = CameraRigRef.CameraRig;
+            Assert.IsNotNull(cameraRig);
+            Assert.IsNotNull(cameraRig.leftHandAnchor);
+            Assert.IsNotNull(cameraRig.rightHandAnchor);
+            Assert.IsNotNull(cameraRig.centerEyeAnchor);
+
+            _leftHandComponents = new OVRInputHandComponents(cameraRig.leftHandAnchor);
+            _rightHandComponents = new OVRInputHandComponents(cameraRig.rightHandAnchor);
+
+            HandDataAsset LeftHandProvider() =>
+                _leftHand.isActiveAndEnabled
+                    ? _leftHand.GetData()
+                    : null;
+
+            HandDataAsset RightHandProvider() =>
+                _rightHand.isActiveAndEnabled
+                    ? _rightHand.GetData()
+                    : null;
+
+            if (_replaceHandMeshRendererProviders && _leftHandComponents.OvrHand != null &&
+                _rightHandComponents.OvrHand != null)
+            {
+                InitializeBakedMeshes();
+            }
+
+            // Inject a custom DataProvider to provide confidence levels to the
+            // OVRMeshRenderer
+            InitializeMeshRendererDataProvider(_leftHandComponents, LeftHandProvider);
+            InitializeMeshRendererDataProvider(_rightHandComponents, RightHandProvider);
+
+            // Inject a custom DataProvider to provide finger joints to the OVRSkeleton,
+            // which are surfaced though the `Bones` property.
+            // We update this providers state in this components Update method, so that we can
+            // catch skeleton changes and notify the DataSources.
+            _leftHandOvrSkeletonDataProvider = CreateHandSkeletonPoseDataProvider(
+                _leftHandComponents, LeftHandProvider);
+            _rightHandOvrSkeletonDataProvider = CreateHandSkeletonPoseDataProvider(
+                _rightHandComponents, RightHandProvider);
+            InitializeHandSkeletonPoseDataProvider(
+                _leftHandComponents, _leftHandOvrSkeletonDataProvider);
+            InitializeHandSkeletonPoseDataProvider(
+                _rightHandComponents, _rightHandOvrSkeletonDataProvider);
+
+            // Inject a custom DataProvider to provide poses to the OVRSkeletonRenderer
+            // (debug skeleton joint visualization)
+            InitializeHandSkeletonRendererPoseDataProvider(_leftHandComponents, LeftHandProvider);
+            InitializeHandSkeletonRendererPoseDataProvider(_rightHandComponents, RightHandProvider);
+            this.EndStart(ref _started);
+        }
+
+        private void InitializeBakedMeshes()
+        {
+            /*
+            Q: Why all the reflection to update OVRXYZ classes?
+            A: Since OVRMesh, OVRSkeleton etc directly call OVRPlugin.XYZ methods, without any hooks,
+               hooks, I can't easily get past the fact that on Oculus Link, when hand tracking is
+               not active, OVRHands/OVRSkeleton do not work. (OVRPlugin.GetMesh returns nothing)
+               The goal of this code below is to provide baked skeleton and mesh data to the OVR classes,
+               classes,  rather than them retrieving it from OVRPlugin. This allows OVRHands to
+               render in the Editor using poses sourced from GRVF files,  without needing to
+               call the OVRPlugin API's.
+
+            Q: Why are the hand fingers all messed up!
+            A: You might be using the mesh provided by the Oculus Integration (OculusHand_L or
+               OculusHand_R). These meshes are not compatible with OVRSkeleton by themselves; they
+               are intended for use with OVRCustomSkeleton. To fix this, use the provided meshes
+               (HandLeft, HandRight).
+            */
+            ReplaceSkeletonData(_leftHandComponents.OvrSkeleton, OVRSkeletonData.LeftSkeleton);
+            ReplaceSkeletonData(_rightHandComponents.OvrSkeleton, OVRSkeletonData.RightSkeleton);
+
+            if (_leftHandMesh != null)
+            {
+                ReplaceHandMeshes(_leftHandComponents, _leftHandMesh);
+            }
+
+            if (_rightHandMesh != null)
+            {
+                ReplaceHandMeshes(_rightHandComponents, _rightHandMesh);
+            }
+            // Inject a custom DataProvider to provide finger joints to the OVRSkeleton,
+            // Inject a custom DataProvider to provide poses to the OVRSkeletonRenderer
+        }
+
+        protected virtual void OnEnable()
+        {
+            if (_started)
+            {
+                _leftHand.HandUpdated += OnLeftHandDataAvailable;
+                _rightHand.HandUpdated += OnRightHandDataAvailable;
+
+                // The root poses of the Hand and HMD must be updated just after OVRCameraRig, which is at
+                //   priority 0. Otherwise the changes will be overwritten in that update. To solve this, root
+                //   poses are updated in the OVRCameraRig.UpdatedAnchors callback.
+                CameraRigRef.CameraRig.UpdatedAnchors += OnCameraRigUpdatedAnchors;
+            }
+        }
+
+        protected virtual void OnDisable()
+        {
+            if (_started)
+            {
+                CameraRigRef.CameraRig.UpdatedAnchors -= OnCameraRigUpdatedAnchors;
+                _leftHand.HandUpdated -= OnLeftHandDataAvailable;
+                _rightHand.HandUpdated -= OnRightHandDataAvailable;
+            }
+        }
+
+        protected virtual void Update()
+        {
+            // Handle the case where OVRManager is not initialized (usually due to an HMD not being
+            // plugged in, when using LINK.
+            if (!OVRManager.OVRManagerinitialized && !CameraRigRef.CameraRig.useFixedUpdateForTracking)
+            {
+                CameraRigRef.CameraRig.EnsureGameObjectIntegrity();
+                OverwriteHandTransforms();
+            }
+        }
+
+        private void FixedUpdate()
+        {
+            // Handle the case where OVRManager is not initialized (usually due to an HMD not being
+            // plugged in, when using LINK.
+            if (!OVRManager.OVRManagerinitialized && CameraRigRef.CameraRig.useFixedUpdateForTracking)
+            {
+                CameraRigRef.CameraRig.EnsureGameObjectIntegrity();
+                OverwriteHandTransforms();
+            }
+        }
+
+        private void OnCameraRigUpdatedAnchors(OVRCameraRig obj)
+        {
+            OverwriteHandTransforms();
+        }
+
+        private void OnLeftHandDataAvailable()
+        {
+            _leftHandOvrSkeletonDataProvider.UpdateSkeletonPoseData();
+        }
+
+        private void OnRightHandDataAvailable()
+        {
+            _rightHandOvrSkeletonDataProvider.UpdateSkeletonPoseData();
+        }
+
+        private void OverwriteHandTransforms()
+        {
+            // Apply modified state back to the camera rig anchors
+            if (_modifyCameraRigAnchorTransforms && _hmdData.isActiveAndEnabled)
+            {
+                var hmdInputData = _hmdDataSource.GetData();
+                if (_modifyCameraRigAnchorTransforms && hmdInputData.IsTracked)
+                {
+                    SetLocalTransform(CameraRigRef.CameraRig.centerEyeAnchor, hmdInputData.Root);
+                }
+            }
+
+            if (_modifyHandTransformsLeft && _leftHand.isActiveAndEnabled)
+            {
+                if (_modifyHandTransformsLeft && _leftHand.GetRootPose(out Pose rootPose))
+                {
+                    SetTransform(_leftHandComponents.Anchor, rootPose);
+                }
+            }
+
+            if (_modifyHandTransformsRight && _rightHand.isActiveAndEnabled)
+            {
+                if (_modifyHandTransformsRight && _rightHand.GetRootPose(out Pose rootPose))
+                {
+                    SetTransform(_rightHandComponents.Anchor, rootPose);
+                }
+            }
+        }
+
+        private static void SetLocalTransform(Transform transform, in Pose root)
+        {
+            transform.localPosition = root.position;
+            transform.localRotation = root.rotation;
+        }
+
+        private static void SetTransform(Transform transform, in Pose root)
+        {
+            transform.position = root.position;
+            transform.rotation = root.rotation;
+        }
+
+        private void ReplaceHandMeshes(OVRInputHandComponents handComponents, Mesh mesh)
+        {
+            if (handComponents.OvrMesh == null)
+            {
+                return;
+            }
+
+            // OVRSkeleton and OVRMesh will not initialize the skeleton in editor mode if the hand
+            // is not connected. This is a limitation with Link, the skeleton isn't available unless
+            // hands are tracked.
+            Assert.IsNotNull(mesh);
+
+            // Create a clone of the mesh, so that vertices in the asset file are not modified by
+            // changes to sharedMesh.
+            mesh = Instantiate(mesh);
+
+            InvokeSetField(handComponents.OvrMesh, "_mesh", mesh);
+            InvokeSetProp(handComponents.OvrMesh, "IsInitialized", true);
+        }
+
+        private void InitializeMeshRendererDataProvider(OVRInputHandComponents handComponents,
+            HandInputDataReadFunction inputDataProvider)
+        {
+            if (handComponents.OvrMeshRenderer == null)
+            {
+                return;
+            }
+
+            var dataProvider = new FromDataAssetOVRMeshRendererDataProvider(_handRenderBehavior)
+            {
+                handInputDataProvider = inputDataProvider,
+                originalProvider = handComponents.OvrHand
+            };
+
+            InvokeSetField(handComponents.OvrMeshRenderer, "_dataProvider", dataProvider);
+        }
+
+        private FromDataAssetOVRSkeletonDataProvider CreateHandSkeletonPoseDataProvider(
+            OVRInputHandComponents handComponents, HandInputDataReadFunction inputDataProvider)
+        {
+            var ovrMeshType = handComponents.OvrHand.GetComponent<IOVRMeshDataProvider>()
+                .GetMeshType();
+            SkeletonType skeletonType =
+                ovrMeshType == MeshType.HandLeft ? SkeletonType.HandLeft : SkeletonType.HandRight;
+            return new FromDataAssetOVRSkeletonDataProvider(_handRenderBehavior)
+            {
+                originalProvider = handComponents.OvrHand,
+                skeletonType = skeletonType,
+                handInputDataProvider = inputDataProvider
+            };
+        }
+
+        private void InitializeHandSkeletonPoseDataProvider(OVRInputHandComponents handComponents,
+            FromDataAssetOVRSkeletonDataProvider dataProvider)
+        {
+            InvokeSetField(handComponents.OvrSkeleton, "_dataProvider", dataProvider);
+        }
+
+        private void InitializeHandSkeletonRendererPoseDataProvider(
+            OVRInputHandComponents handComponents, HandInputDataReadFunction inputDataProvider)
+        {
+            if (handComponents.OvrSkeletonRenderer == null)
+            {
+                return;
+            }
+
+            var dataProvider = new FromDataAssetOVRSkeletonRendererDataProvider(_handRenderBehavior)
+            {
+                handInputDataProvider = inputDataProvider,
+                originalProvider = handComponents.OvrHand
+            };
+
+            InvokeSetField(handComponents.OvrSkeletonRenderer, "_dataProvider", dataProvider);
+        }
+
+        private void ReplaceSkeletonData(OVRSkeleton ovrLeftHandSkeleton,
+            OVRPlugin.Skeleton2 skeletonData)
+        {
+            var skeletonChangeCount = FromDataAssetOVRSkeletonDataProvider.InitialSkeletonChangeCount;
+            var nullParams = new object[] { };
+
+            InvokeSetField(ovrLeftHandSkeleton, "_skeleton", skeletonData);
+
+            InvokeMethod(ovrLeftHandSkeleton, "InitializeBones", nullParams);
+            InvokeMethod(ovrLeftHandSkeleton, "InitializeBindPose", nullParams);
+            InvokeMethod(ovrLeftHandSkeleton, "InitializeCapsules", nullParams);
+            InvokeSetProp(ovrLeftHandSkeleton, "IsInitialized", true);
+            InvokeSetProp(ovrLeftHandSkeleton, "SkeletonChangedCount", -1);
+        }
+
+        private static void InvokeMethod<T>(T instance, string methodName, object[] args)
+        {
+            var method = typeof(T).GetMethod(methodName, InstanceFlags);
+            Assert.IsNotNull(method, methodName + " method must exist on type: " + nameof(T));
+            method.Invoke(instance, args);
+        }
+
+        private static void InvokeSetField<T>(T instance, string fieldName, object val)
+        {
+            var prop = typeof(T).GetField(fieldName, InstanceFlags);
+            Assert.IsNotNull(prop, prop + " field must exist on type: " + nameof(T));
+            prop.SetValue(instance, val);
+        }
+
+        private static void InvokeSetProp<T>(T instance, string propName, object val)
+        {
+            var prop = typeof(T).GetProperty(propName, InstanceFlags);
+            Assert.IsNotNull(prop, prop + " property must exist on type: " + nameof(T));
+            prop.SetMethod.Invoke(instance, new[] { val });
+        }
+
+        #region Inject
+
+        public void InjectOVRSkeletonDataProviders(IOVRCameraRigRef cameraRigRef,
+            IDataSource<HmdDataAsset, HmdDataSourceConfig> hmdData,
+            Hand leftHand, Hand rightHand, bool modifyCameraRigAnchorTransforms, bool modifyHandTransformsLeft,
+            bool modifyHandTransformsRight, bool replaceHandMeshRendererProviders,
+            HandRenderPoseOriginBehavior handRenderBehavior)
+        {
+            InjectCameraRigRef(cameraRigRef);
+            InjectHmdData(hmdData);
+            InjectLeftHand(leftHand);
+            InjectRightHand(rightHand);
+            InjectModifyCameraRigAnchorTransforms(modifyCameraRigAnchorTransforms);
+            InjectModifyHandTransformsLeft(modifyHandTransformsLeft);
+            InjectModifyHandTransformsRight(modifyHandTransformsRight);
+            InjectReplaceHandMeshRendererProviders(replaceHandMeshRendererProviders);
+            InjectHandRenderBehavior(handRenderBehavior);
+        }
+
+        public void InjectCameraRigRef(IOVRCameraRigRef cameraRigRef)
+        {
+            _cameraRigRef = cameraRigRef as MonoBehaviour;
+            CameraRigRef = cameraRigRef;
+        }
+
+        public void InjectHmdData(IDataSource<HmdDataAsset,HmdDataSourceConfig> hmdData)
+        {
+            _hmdData = hmdData as MonoBehaviour;
+            _hmdDataSource = hmdData;
+        }
+
+        public void InjectLeftHand(Hand leftHand)
+        {
+            _leftHand = leftHand;
+        }
+
+        public void InjectRightHand(Hand rightHand)
+        {
+            _rightHand = rightHand;
+        }
+
+        public void InjectModifyCameraRigAnchorTransforms(bool modifyCameraRigAnchorTransforms)
+        {
+            _modifyCameraRigAnchorTransforms = modifyCameraRigAnchorTransforms;
+        }
+
+        public void InjectModifyHandTransformsLeft(bool modifyHandTransformsLeft)
+        {
+            _modifyHandTransformsLeft = modifyHandTransformsLeft;
+        }
+
+        public void InjectModifyHandTransformsRight(bool modifyHandTransformsRight)
+        {
+            _modifyHandTransformsRight = modifyHandTransformsRight;
+        }
+
+        public void InjectReplaceHandMeshRendererProviders(bool replaceHandMeshRendererProviders)
+        {
+            _replaceHandMeshRendererProviders = replaceHandMeshRendererProviders;
+        }
+
+        public void InjectHandRenderBehavior(HandRenderPoseOriginBehavior handRenderBehavior)
+        {
+            _handRenderBehavior = handRenderBehavior;
+        }
+
+        public void InjectOptionalLeftHandMesh(Mesh handMesh)
+        {
+            _leftHandMesh = handMesh;
+        }
+
+        public void InjectOptionalRightHandMesh(Mesh handMesh)
+        {
+            _rightHandMesh = handMesh;
+        }
+
+        #endregion
+    }
+}

Assets/Oculus/Interaction/Runtime/Scripts/Input/OVRIntegration/OVRSkeletonDataProviders.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ffac1ecd519bd1d409558219f47d07b0
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/Interaction/Runtime/Scripts/Input/OVRIntegration/SetDisplayRefresh.cs

@@ -0,0 +1,39 @@
+/************************************************************************************
+Copyright : Copyright (c) Facebook Technologies, LLC and its affiliates. All rights reserved.
+
+Your use of this SDK or tool is subject to the Oculus SDK License Agreement, available at
+https://developer.oculus.com/licenses/oculussdk/
+
+Unless required by applicable law or agreed to in writing, the Utilities SDK distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+ANY KIND, either express or implied. See the License for the specific language governing
+permissions and limitations under the License.
+************************************************************************************/
+
+using System.Linq;
+using UnityEngine;
+
+namespace Oculus.Interaction.Input
+{
+    public class SetDisplayRefresh : MonoBehaviour
+    {
+        [SerializeField]
+        private float _desiredDisplayFrequency = 90f;
+
+        public void SetDesiredDisplayFrequency(float desiredDisplayFrequency)
+        {
+            var validFrequencies = OVRPlugin.systemDisplayFrequenciesAvailable;
+
+            if (validFrequencies.Contains(_desiredDisplayFrequency))
+            {
+                Debug.Log("[Oculus.Interaction] Setting desired display frequency to " + _desiredDisplayFrequency);
+                OVRPlugin.systemDisplayFrequency = _desiredDisplayFrequency;
+            }
+        }
+
+        protected virtual void Awake()
+        {
+            SetDesiredDisplayFrequency(_desiredDisplayFrequency);
+        }
+    }
+}

Assets/Oculus/Interaction/Runtime/Scripts/Input/OVRIntegration/SetDisplayRefresh.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 215d90758f7ed4f42b7ad0a64d0dfec4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Oculus/Interaction/Runtime/Scripts/Input/OVRIntegration/TrackingToWorldTransformerOVR.cs

@@ -0,0 +1,79 @@
+/************************************************************************************
+Copyright : Copyright (c) Facebook Technologies, LLC and its affiliates. All rights reserved.
+
+Your use of this SDK or tool is subject to the Oculus SDK License Agreement, available at
+https://developer.oculus.com/licenses/oculussdk/
+
+Unless required by applicable law or agreed to in writing, the Utilities SDK distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+ANY KIND, either express or implied. See the License for the specific language governing
+permissions and limitations under the License.
+************************************************************************************/
+
+using System;
+using UnityEngine;
+using UnityEngine.Assertions;
+
+namespace Oculus.Interaction.Input
+{
+    public class TrackingToWorldTransformerOVR : MonoBehaviour, ITrackingToWorldTransformer
+    {
+        [SerializeField, Interface(typeof(IOVRCameraRigRef))]
+        private MonoBehaviour _cameraRigRef;
+        public IOVRCameraRigRef CameraRigRef { get; private set; }
+
+        public Transform Transform => CameraRigRef.CameraRig.transform;
+
+        /// <summary>
+        /// Converts a tracking space pose to a world space pose (Applies any transform applied to the OVRCameraRig)
+        /// </summary>
+        public Pose ToWorldPose(Pose pose)
+        {
+            Transform trackingToWorldSpace = Transform;
+
+            pose.position = trackingToWorldSpace.TransformPoint(pose.position);
+            pose.rotation = trackingToWorldSpace.rotation * pose.rotation;
+            return pose;
+        }
+
+        /// <summary>
+        /// Converts a world space pose to a tracking space pose (Removes any transform applied to the OVRCameraRig)
+        /// </summary>
+        public Pose ToTrackingPose(in Pose worldPose)
+        {
+            Transform trackingToWorldSpace = Transform;
+
+            Vector3 position = trackingToWorldSpace.InverseTransformPoint(worldPose.position);
+            Quaternion rotation = Quaternion.Inverse(trackingToWorldSpace.rotation) * worldPose.rotation;
+
+            return new Pose(position, rotation);
+        }
+
+        public Quaternion WorldToTrackingWristJointFixup => FromOVRHandDataSource.WristFixupRotation;
+
+        protected virtual void Awake()
+        {
+            CameraRigRef = _cameraRigRef as IOVRCameraRigRef;
+        }
+
+        protected virtual void Start()
+        {
+            Assert.IsNotNull(CameraRigRef);
+        }
+
+        #region Inject
+
+        public void InjectAllTrackingToWorldTransformerOVR(IOVRCameraRigRef cameraRigRef)
+        {
+            InjectCameraRigRef(cameraRigRef);
+        }
+
+        public void InjectCameraRigRef(IOVRCameraRigRef cameraRigRef)
+        {
+            _cameraRigRef = cameraRigRef as MonoBehaviour;
+            CameraRigRef = cameraRigRef;
+        }
+
+        #endregion
+    }
+}

Assets/Oculus/Interaction/Runtime/Scripts/Input/OVRIntegration/TrackingToWorldTransformerOVR.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 998a5646185efb9488265f3a2f35a99a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: