Initialer Upload neues Unity-Projekt

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

@@ -0,0 +1,156 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * Licensed under the Oculus SDK License Agreement (the "License");
+ * you may not use the Oculus SDK except in compliance with the License,
+ * which is provided at the time of installation or download, or which
+ * otherwise accompanies this software in either electronic or hard copy form.
+ *
+ * You may obtain a copy of the License at
+ *
+ * https://developer.oculus.com/licenses/oculussdk/
+ *
+ * Unless required by applicable law or agreed to in writing, the Oculus 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 enum AllowThumbUp
+        {
+            Always,
+            GripRequired,
+            TriggerAndGripRequired,
+        }
+        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 string ANIM_PARAM_NAME_PINCH = "Pinch";
+        public const string ANIM_PARAM_NAME_INDEX_SLIDE = "IndexSlide";
+
+        [SerializeField]
+        private OVRInput.Controller _controller = OVRInput.Controller.None;
+        [SerializeField]
+        private Animator _animator = null;
+        [SerializeField]
+        private AllowThumbUp _allowThumbUp = AllowThumbUp.TriggerAndGripRequired;
+
+        [Header("Animation Speed")]
+        [SerializeField]
+        private float _animFlexhGain = 35;
+        [SerializeField]
+        private float _animPinchGain = 35;
+        [SerializeField]
+        private float _animPointAndThumbsUpGain = 20;
+
+        private int _animLayerIndexThumb = -1;
+        private int _animLayerIndexPoint = -1;
+        private int _animParamIndexFlex = Animator.StringToHash(ANIM_PARAM_NAME_FLEX);
+        private int _animParamPinch = Animator.StringToHash(ANIM_PARAM_NAME_PINCH);
+        private int _animParamIndexSlide = Animator.StringToHash(ANIM_PARAM_NAME_INDEX_SLIDE);
+
+        private bool _isGivingThumbsUp = false;
+        private float _pointBlend = 0.0f;
+        private float _slideBlend = 0.0f;
+
+        private float _thumbsUpBlend = 0.0f;
+        private float _pointTarget = 0.0f;
+        private float _slideTarget = 0.0f;
+
+        private float _animFlex = 0;
+        private float _animPinch = 0;
+
+        private const float TRIGGER_MAX = 0.95f;
+
+        protected virtual void Start()
+        {
+            _animLayerIndexPoint = _animator.GetLayerIndex(ANIM_LAYER_NAME_POINT);
+            _animLayerIndexThumb = _animator.GetLayerIndex(ANIM_LAYER_NAME_THUMB);
+        }
+
+        protected virtual void Update()
+        {
+            UpdateCapTouchStates();
+
+            _pointBlend = Mathf.Lerp(_pointBlend, _pointTarget, _animPointAndThumbsUpGain * Time.deltaTime);
+            _slideBlend = Mathf.Lerp(_slideBlend, _slideTarget, _animPointAndThumbsUpGain * Time.deltaTime);
+            _thumbsUpBlend = Mathf.Lerp(_thumbsUpBlend, _isGivingThumbsUp ? 1 : 0, _animPointAndThumbsUpGain * Time.deltaTime);
+
+            UpdateAnimStates();
+        }
+
+        private void UpdateCapTouchStates()
+        {
+            float indexCurl = OVRControllerUtility.GetIndexCurl(_controller);
+            float indexSlide = OVRControllerUtility.GetIndexSlide(_controller);
+            _pointTarget = 1 - indexCurl;
+            _slideTarget = indexSlide;
+
+            bool triggerThumbsUp = _allowThumbUp == AllowThumbUp.Always ||
+                (_allowThumbUp == AllowThumbUp.GripRequired
+                    && OVRInput.Get(OVRInput.Axis1D.PrimaryHandTrigger, _controller) >= TRIGGER_MAX) ||
+                (_allowThumbUp == AllowThumbUp.TriggerAndGripRequired
+                    && OVRInput.Get(OVRInput.Axis1D.PrimaryHandTrigger, _controller) >= TRIGGER_MAX
+                    && OVRInput.Get(OVRInput.Axis1D.PrimaryIndexTrigger, _controller) >= TRIGGER_MAX);
+
+            _isGivingThumbsUp = !OVRInput.Get(OVRInput.NearTouch.PrimaryThumbButtons, _controller)
+                && !OVRInput.Get(OVRInput.Button.One, _controller)
+                && !OVRInput.Get(OVRInput.Button.Two, _controller)
+                && !OVRInput.Get(OVRInput.Button.Three, _controller)
+                && !OVRInput.Get(OVRInput.Button.Four, _controller)
+                && !OVRInput.Get(OVRInput.Button.PrimaryThumbstick, _controller)
+                && OVRInput.Get(OVRInput.Axis2D.PrimaryThumbstick, _controller).magnitude == 0
+                && triggerThumbsUp;
+        }
+
+        private void UpdateAnimStates()
+        {
+            // Flex
+            // blend between open hand and fully closed fist
+            float flex = OVRInput.Get(OVRInput.Axis1D.PrimaryHandTrigger, _controller);
+            _animFlex = Mathf.Lerp(_animFlex, flex, _animFlexhGain * Time.deltaTime);
+            _animator.SetFloat(_animParamIndexFlex, _animFlex);
+
+            // Pinch
+            float pinchAmount = OVRInput.Get(OVRInput.Axis1D.PrimaryIndexTrigger, _controller);
+            _animPinch = Mathf.Lerp(_animPinch, pinchAmount, _animPinchGain * Time.deltaTime);
+            _animator.SetFloat(_animParamPinch, _animPinch);
+
+            // Point
+            _animator.SetLayerWeight(_animLayerIndexPoint, _pointBlend);
+            _animator.SetFloat(_animParamIndexSlide, _slideBlend);
+
+            // Thumbs up
+            _animator.SetLayerWeight(_animLayerIndexThumb, _thumbsUpBlend);
+        }
+
+
+        #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/OVRIntegration/Runtime/Scripts/Input/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/OVRIntegration/Runtime/Scripts/Input/FromOVRControllerDataSource.cs

@@ -0,0 +1,321 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * Licensed under the Oculus SDK License Agreement (the "License");
+ * you may not use the Oculus SDK except in compliance with the License,
+ * which is provided at the time of installation or download, or which
+ * otherwise accompanies this software in either electronic or hard copy form.
+ *
+ * You may obtain a copy of the License at
+ *
+ * https://developer.oculus.com/licenses/oculussdk/
+ *
+ * Unless required by applicable law or agreed to in writing, the Oculus 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;
+
+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>
+    {
+        [Header("OVR Data Source")]
+        [SerializeField, Interface(typeof(IOVRCameraRigRef))]
+        private UnityEngine.Object _cameraRigRef;
+        public IOVRCameraRigRef CameraRigRef { get; private set; }
+
+        [SerializeField]
+        private bool _processLateUpdates = false;
+
+        [Header("Shared Configuration")]
+        [SerializeField]
+        private Handedness _handedness;
+
+        [SerializeField, Interface(typeof(ITrackingToWorldTransformer))]
+        private UnityEngine.Object _trackingToWorldTransformer;
+        private ITrackingToWorldTransformer TrackingToWorldTransformer;
+
+        public bool ProcessLateUpdates
+        {
+            get
+            {
+                return _processLateUpdates;
+            }
+            set
+            {
+                _processLateUpdates = value;
+            }
+        }
+
+        private readonly ControllerDataAsset _controllerDataAsset = new ControllerDataAsset();
+        private OVRInput.Controller _ovrController;
+        private Transform _ovrControllerAnchor;
+        private ControllerDataSourceConfig _config;
+
+        private OVRPointerPoseSelector _pointerPoseSelector;
+
+        #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;
+            CameraRigRef = _cameraRigRef as IOVRCameraRigRef;
+
+            UpdateConfig();
+        }
+
+        protected override void Start()
+        {
+            this.BeginStart(ref _started, () => base.Start());
+            this.AssertField(CameraRigRef, nameof(CameraRigRef));
+            this.AssertField(TrackingToWorldTransformer, nameof(TrackingToWorldTransformer));
+            if (_handedness == Handedness.Left)
+            {
+                this.AssertField(CameraRigRef.LeftController, nameof(CameraRigRef.LeftController));
+                _ovrControllerAnchor = CameraRigRef.LeftController;
+                _ovrController = OVRInput.Controller.LTouch;
+            }
+            else
+            {
+                this.AssertField(CameraRigRef.RightController, nameof(CameraRigRef.RightController));
+                _ovrControllerAnchor = CameraRigRef.RightController;
+                _ovrController = OVRInput.Controller.RTouch;
+            }
+            _pointerPoseSelector = new OVRPointerPoseSelector(_handedness);
+
+            UpdateConfig();
+            this.EndStart(ref _started);
+        }
+
+        protected override void OnEnable()
+        {
+            base.OnEnable();
+            if (_started)
+            {
+                CameraRigRef.WhenInputDataDirtied += HandleInputDataDirtied;
+            }
+        }
+
+        protected override void OnDisable()
+        {
+            if (_started)
+            {
+                CameraRigRef.WhenInputDataDirtied -= HandleInputDataDirtied;
+            }
+
+            base.OnDisable();
+        }
+
+        private void HandleInputDataDirtied(bool isLateUpdate)
+        {
+            if (isLateUpdate && !_processLateUpdates)
+            {
+                return;
+            }
+            MarkInputDataRequiresUpdate();
+        }
+
+        private ControllerDataSourceConfig Config
+        {
+            get
+            {
+                if (_config != null)
+                {
+                    return _config;
+                }
+
+                _config = new ControllerDataSourceConfig()
+                {
+                    Handedness = _handedness
+                };
+
+                return _config;
+            }
+        }
+
+        private void UpdateConfig()
+        {
+            Config.Handedness = _handedness;
+            Config.TrackingToWorldTransformer = TrackingToWorldTransformer;
+        }
+
+        protected override void UpdateData()
+        {
+            _controllerDataAsset.Config = Config;
+            var worldToTrackingSpace = TrackingToWorldTransformer.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
+                {
+                    this.AssertIsTrue(mapping.IsButton,
+                        $"Element in {AssertUtils.Nicify(nameof(ControllerUsageMappings))} has {AssertUtils.Nicify(nameof(mapping.IsButton))} set to false.");
+
+                    usageActive = OVRInput.Get(mapping.Button, controllerMask);
+                }
+
+                if (usageActive)
+                {
+                    _controllerDataAsset.ButtonUsageMask |= mapping.Usage;
+                }
+            }
+
+            // Update poses
+
+            // Root pose, in tracking space.
+            _controllerDataAsset.RootPose = new Pose(
+                OVRInput.GetLocalControllerPosition(_ovrController),
+                OVRInput.GetLocalControllerRotation(_ovrController));
+            _controllerDataAsset.RootPoseOrigin = PoseOrigin.RawTrackedPose;
+
+            // Convert controller pointer pose from local to tracking space.
+            Matrix4x4 controllerModelToTracking = Matrix4x4.TRS(
+                _controllerDataAsset.RootPose.position, _controllerDataAsset.RootPose.rotation,
+                Vector3.one);
+            _controllerDataAsset.PointerPose =
+                new Pose(controllerModelToTracking.MultiplyPoint3x4(_pointerPoseSelector.LocalPointerPose.position),
+                    _controllerDataAsset.RootPose.rotation * _pointerPoseSelector.LocalPointerPose.rotation);
+
+            _controllerDataAsset.PointerPoseOrigin = PoseOrigin.RawTrackedPose;
+        }
+
+        protected override ControllerDataAsset DataAsset => _controllerDataAsset;
+
+        #region Inject
+
+        public void InjectAllFromOVRControllerDataSource(UpdateModeFlags updateMode, IDataSource updateAfter,
+            Handedness handedness, ITrackingToWorldTransformer trackingToWorldTransformer)
+        {
+            base.InjectAllDataSource(updateMode, updateAfter);
+            InjectHandedness(handedness);
+            InjectTrackingToWorldTransformer(trackingToWorldTransformer);
+        }
+
+        public void InjectHandedness(Handedness handedness)
+        {
+            _handedness = handedness;
+        }
+
+        public void InjectTrackingToWorldTransformer(ITrackingToWorldTransformer trackingToWorldTransformer)
+        {
+            _trackingToWorldTransformer = trackingToWorldTransformer as UnityEngine.Object;
+            TrackingToWorldTransformer = trackingToWorldTransformer;
+        }
+
+        #endregion
+    }
+}

Assets/Oculus/Interaction/OVRIntegration/Runtime/Scripts/Input/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/OVRIntegration/Runtime/Scripts/Input/FromOVRControllerHandDataSource.cs

@@ -0,0 +1,311 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * Licensed under the Oculus SDK License Agreement (the "License");
+ * you may not use the Oculus SDK except in compliance with the License,
+ * which is provided at the time of installation or download, or which
+ * otherwise accompanies this software in either electronic or hard copy form.
+ *
+ * You may obtain a copy of the License at
+ *
+ * https://developer.oculus.com/licenses/oculussdk/
+ *
+ * Unless required by applicable law or agreed to in writing, the Oculus 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;
+
+namespace Oculus.Interaction.Input
+{
+    public class FromOVRControllerHandDataSource : DataSource<HandDataAsset>
+    {
+        [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 UnityEngine.Object _cameraRigRef;
+        private IOVRCameraRigRef CameraRigRef;
+
+        [SerializeField]
+        private bool _processLateUpdates = false;
+
+        [Header("Shared Configuration")]
+        [SerializeField]
+        private Handedness _handedness;
+
+        [SerializeField, Interface(typeof(ITrackingToWorldTransformer))]
+        private UnityEngine.Object _trackingToWorldTransformer;
+        private ITrackingToWorldTransformer TrackingToWorldTransformer;
+
+        public bool ProcessLateUpdates
+        {
+            get
+            {
+                return _processLateUpdates;
+            }
+            set
+            {
+                _processLateUpdates = value;
+            }
+        }
+
+        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;
+
+        protected void Awake()
+        {
+            _skeleton = HandSkeletonOVR.CreateSkeletonData(_handedness);
+            TrackingToWorldTransformer = _trackingToWorldTransformer as ITrackingToWorldTransformer;
+            CameraRigRef = _cameraRigRef as IOVRCameraRigRef;
+
+            UpdateConfig();
+        }
+
+        protected override void Start()
+        {
+            this.BeginStart(ref _started, () => base.Start());
+            this.AssertField(CameraRigRef, nameof(CameraRigRef));
+            this.AssertField(TrackingToWorldTransformer, nameof(TrackingToWorldTransformer));
+            if (_handedness == Handedness.Left)
+            {
+                this.AssertField(CameraRigRef.LeftHand, nameof(CameraRigRef.LeftHand));
+                _ovrControllerAnchor = CameraRigRef.LeftController;
+                _ovrController = OVRInput.Controller.LTouch;
+            }
+            else
+            {
+                this.AssertField(CameraRigRef.RightHand, nameof(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;
+
+            UpdateSkeleton();
+            UpdateConfig();
+            this.EndStart(ref _started);
+        }
+
+        protected override void OnEnable()
+        {
+            base.OnEnable();
+            if (_started)
+            {
+                CameraRigRef.WhenInputDataDirtied += HandleInputDataDirtied;
+            }
+        }
+
+        protected override void OnDisable()
+        {
+            if (_started)
+            {
+                CameraRigRef.WhenInputDataDirtied -= HandleInputDataDirtied;
+            }
+
+            base.OnDisable();
+        }
+
+        private void HandleInputDataDirtied(bool isLateUpdate)
+        {
+            if (isLateUpdate && !_processLateUpdates)
+            {
+                return;
+            }
+            MarkInputDataRequiresUpdate();
+        }
+
+        private void UpdateSkeleton()
+        {
+            if (_started)
+            {
+                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 HandDataSourceConfig Config
+        {
+            get
+            {
+                if (_config != null)
+                {
+                    return _config;
+                }
+
+                _config = new HandDataSourceConfig()
+                {
+                    Handedness = _handedness
+                };
+
+                return _config;
+            }
+        }
+
+        private void UpdateConfig()
+        {
+            Config.Handedness = _handedness;
+            Config.TrackingToWorldTransformer = TrackingToWorldTransformer;
+            Config.HandSkeleton = _skeleton;
+        }
+
+        protected override void UpdateData()
+        {
+            _handDataAsset.Config = Config;
+            _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 pinchStrength = _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] = pinchStrength >= 1f || gripStrength >= 1f;
+            _handDataAsset.FingerPinchStrength[(int)HandFinger.Thumb] = Mathf.Max(pinchStrength, gripStrength);
+
+            _handDataAsset.IsFingerHighConfidence[(int)HandFinger.Index] = true;
+            _handDataAsset.IsFingerPinching[(int)HandFinger.Index] = pinchStrength >= 1f;
+            _handDataAsset.FingerPinchStrength[(int)HandFinger.Index] = pinchStrength;
+
+            _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);
+            if (Config.TrackingToWorldTransformer != null)
+            {
+                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,
+            Transform[] bones, AnimationCurve pinchCurve,
+            Vector3 rootOffset, Vector3 rootAngleOffset)
+        {
+            base.InjectAllDataSource(updateMode, updateAfter);
+            InjectHandedness(handedness);
+            InjectTrackingToWorldTransformer(trackingToWorldTransformer);
+            InjectBones(bones);
+            InjectPinchCurve(pinchCurve);
+            InjectRootOffset(rootOffset);
+            InjectRootAngleOffset(rootAngleOffset);
+        }
+
+        public void InjectHandedness(Handedness handedness)
+        {
+            _handedness = handedness;
+        }
+
+        public void InjectTrackingToWorldTransformer(ITrackingToWorldTransformer trackingToWorldTransformer)
+        {
+            _trackingToWorldTransformer = trackingToWorldTransformer as UnityEngine.Object;
+            TrackingToWorldTransformer = trackingToWorldTransformer;
+        }
+
+        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/OVRIntegration/Runtime/Scripts/Input/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/OVRIntegration/Runtime/Scripts/Input/FromOVRHandDataSource.cs

@@ -0,0 +1,294 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * Licensed under the Oculus SDK License Agreement (the "License");
+ * you may not use the Oculus SDK except in compliance with the License,
+ * which is provided at the time of installation or download, or which
+ * otherwise accompanies this software in either electronic or hard copy form.
+ *
+ * You may obtain a copy of the License at
+ *
+ * https://developer.oculus.com/licenses/oculussdk/
+ *
+ * Unless required by applicable law or agreed to in writing, the Oculus 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 static OVRSkeleton;
+
+namespace Oculus.Interaction.Input
+{
+    public class FromOVRHandDataSource : DataSource<HandDataAsset>
+    {
+        [Header("OVR Data Source")]
+        [SerializeField, Interface(typeof(IOVRCameraRigRef))]
+        private UnityEngine.Object _cameraRigRef;
+
+        [SerializeField]
+        private bool _processLateUpdates = false;
+
+        [Header("Shared Configuration")]
+        [SerializeField]
+        private Handedness _handedness;
+
+        [SerializeField, Interface(typeof(ITrackingToWorldTransformer))]
+        private UnityEngine.Object _trackingToWorldTransformer;
+        private ITrackingToWorldTransformer TrackingToWorldTransformer;
+
+        [SerializeField, Interface(typeof(IHandSkeletonProvider))]
+        private UnityEngine.Object _handSkeletonProvider;
+        private IHandSkeletonProvider HandSkeletonProvider;
+
+        public bool ProcessLateUpdates
+        {
+            get
+            {
+                return _processLateUpdates;
+            }
+            set
+            {
+                _processLateUpdates = value;
+            }
+        }
+
+        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);
+
+        protected virtual void Awake()
+        {
+            TrackingToWorldTransformer = _trackingToWorldTransformer as ITrackingToWorldTransformer;
+            CameraRigRef = _cameraRigRef as IOVRCameraRigRef;
+            HandSkeletonProvider = _handSkeletonProvider as IHandSkeletonProvider;
+
+            UpdateConfig();
+        }
+
+        protected override void Start()
+        {
+            this.BeginStart(ref _started, () => base.Start());
+            this.AssertField(CameraRigRef, nameof(CameraRigRef));
+            this.AssertField(TrackingToWorldTransformer, nameof(TrackingToWorldTransformer));
+            this.AssertField(HandSkeletonProvider, nameof(HandSkeletonProvider));
+            if (_handedness == Handedness.Left)
+            {
+                _ovrHand = CameraRigRef.LeftHand;
+                _ovrController = OVRInput.Controller.LHand;
+            }
+            else
+            {
+                _ovrHand = CameraRigRef.RightHand;
+                _ovrController = OVRInput.Controller.RHand;
+            }
+
+            UpdateConfig();
+
+            this.EndStart(ref _started);
+        }
+
+        protected override void OnEnable()
+        {
+            base.OnEnable();
+            if (_started)
+            {
+                CameraRigRef.WhenInputDataDirtied += HandleInputDataDirtied;
+            }
+        }
+
+        protected override void OnDisable()
+        {
+            if (_started)
+            {
+                CameraRigRef.WhenInputDataDirtied -= HandleInputDataDirtied;
+            }
+
+            base.OnDisable();
+        }
+
+        private void HandleInputDataDirtied(bool isLateUpdate)
+        {
+            if (isLateUpdate && !_processLateUpdates)
+            {
+                return;
+            }
+            MarkInputDataRequiresUpdate();
+        }
+
+
+        private HandDataSourceConfig Config
+        {
+            get
+            {
+                if (_config != null)
+                {
+                    return _config;
+                }
+
+                _config = new HandDataSourceConfig()
+                {
+                    Handedness = _handedness
+                };
+
+                return _config;
+            }
+        }
+
+        private void UpdateConfig()
+        {
+            Config.Handedness = _handedness;
+            Config.TrackingToWorldTransformer = TrackingToWorldTransformer;
+            Config.HandSkeleton = HandSkeletonProvider[_handedness];
+        }
+
+        protected override void UpdateData()
+        {
+            _handDataAsset.Config = Config;
+            _handDataAsset.IsDataValid = true;
+            _handDataAsset.IsConnected =
+                (OVRInput.GetConnectedControllers() & _ovrController) > 0;
+
+            if (_ovrHand != null)
+            {
+                IOVRSkeletonDataProvider skeletonProvider = _ovrHand;
+                SkeletonPoseData 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)
+        {
+            base.InjectAllDataSource(updateMode, updateAfter);
+            InjectHandedness(handedness);
+            InjectTrackingToWorldTransformer(trackingToWorldTransformer);
+            InjectHandSkeletonProvider(handSkeletonProvider);
+        }
+
+        public void InjectHandedness(Handedness handedness)
+        {
+            _handedness = handedness;
+        }
+
+        public void InjectTrackingToWorldTransformer(ITrackingToWorldTransformer trackingToWorldTransformer)
+        {
+            _trackingToWorldTransformer = trackingToWorldTransformer as UnityEngine.Object;
+            TrackingToWorldTransformer = trackingToWorldTransformer;
+        }
+
+        public void InjectHandSkeletonProvider(IHandSkeletonProvider handSkeletonProvider)
+        {
+            _handSkeletonProvider = handSkeletonProvider as UnityEngine.Object;
+            HandSkeletonProvider = handSkeletonProvider;
+        }
+
+        #endregion
+    }
+}

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

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

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

@@ -0,0 +1,201 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * Licensed under the Oculus SDK License Agreement (the "License");
+ * you may not use the Oculus SDK except in compliance with the License,
+ * which is provided at the time of installation or download, or which
+ * otherwise accompanies this software in either electronic or hard copy form.
+ *
+ * You may obtain a copy of the License at
+ *
+ * https://developer.oculus.com/licenses/oculussdk/
+ *
+ * Unless required by applicable law or agreed to in writing, the Oculus 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>
+    {
+        [Header("OVR Data Source")]
+        [SerializeField, Interface(typeof(IOVRCameraRigRef))]
+        private UnityEngine.Object _cameraRigRef;
+
+        public IOVRCameraRigRef CameraRigRef { get; private set; }
+
+        [SerializeField]
+        private bool _processLateUpdates = false;
+
+        [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 UnityEngine.Object _trackingToWorldTransformer;
+        private ITrackingToWorldTransformer TrackingToWorldTransformer;
+
+        public bool ProcessLateUpdates
+        {
+            get
+            {
+                return _processLateUpdates;
+            }
+            set
+            {
+                _processLateUpdates = value;
+            }
+        }
+
+        private HmdDataAsset _hmdDataAsset = new HmdDataAsset();
+        private HmdDataSourceConfig _config;
+
+        protected void Awake()
+        {
+            CameraRigRef = _cameraRigRef as IOVRCameraRigRef;
+            TrackingToWorldTransformer = _trackingToWorldTransformer as ITrackingToWorldTransformer;
+        }
+
+        protected override void Start()
+        {
+            this.BeginStart(ref _started, () => base.Start());
+            this.AssertField(CameraRigRef, nameof(CameraRigRef));
+            this.AssertField(TrackingToWorldTransformer, nameof(TrackingToWorldTransformer));
+            this.EndStart(ref _started);
+        }
+
+        protected override void OnEnable()
+        {
+            base.OnEnable();
+            if (_started)
+            {
+                CameraRigRef.WhenInputDataDirtied += HandleInputDataDirtied;
+            }
+        }
+
+        protected override void OnDisable()
+        {
+            if (_started)
+            {
+                CameraRigRef.WhenInputDataDirtied -= HandleInputDataDirtied;
+            }
+
+            base.OnDisable();
+        }
+
+        private void HandleInputDataDirtied(bool isLateUpdate)
+        {
+            if (isLateUpdate && !_processLateUpdates)
+            {
+                return;
+            }
+            MarkInputDataRequiresUpdate();
+        }
+
+        private HmdDataSourceConfig Config
+        {
+            get
+            {
+                if (_config != null)
+                {
+                    return _config;
+                }
+
+                _config = new HmdDataSourceConfig()
+                {
+                    TrackingToWorldTransformer = TrackingToWorldTransformer
+                };
+
+                return _config;
+            }
+        }
+
+        protected override void UpdateData()
+        {
+            _hmdDataAsset.Config = Config;
+            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 = Pose.identity;
+
+                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;
+
+        #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 UnityEngine.Object;
+            TrackingToWorldTransformer = trackingToWorldTransformer;
+        }
+
+        #endregion
+    }
+}

Assets/Oculus/Interaction/OVRIntegration/Runtime/Scripts/Input/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/OVRIntegration/Runtime/Scripts/Input/HandSkeletonOVR.cs

@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * Licensed under the Oculus SDK License Agreement (the "License");
+ * you may not use the Oculus SDK except in compliance with the License,
+ * which is provided at the time of installation or download, or which
+ * otherwise accompanies this software in either electronic or hard copy form.
+ *
+ * You may obtain a copy of the License at
+ *
+ * https://developer.oculus.com/licenses/oculussdk/
+ *
+ * Unless required by applicable law or agreed to in writing, the Oculus 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;
+
+namespace Oculus.Interaction.Input
+{
+    public class HandSkeletonOVR : MonoBehaviour, IHandSkeletonProvider
+    {
+        private readonly HandSkeleton[] _skeletons = { new HandSkeleton(), new HandSkeleton() };
+
+        public HandSkeleton this[Handedness handedness] => _skeletons[(int)handedness];
+
+        protected void Awake()
+        {
+            ApplyToSkeleton(OVRSkeletonData.LeftSkeleton, _skeletons[0]);
+            ApplyToSkeleton(OVRSkeletonData.RightSkeleton, _skeletons[1]);
+        }
+
+        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;
+                int boneIndex = i;
+                if (i == (int)HandJointId.HandThumb0)
+                {
+                    boneIndex = (int)HandJointId.HandThumb1;
+                }
+                else if (i == (int)HandJointId.HandPinky0)
+                {
+                    boneIndex = (int)HandJointId.HandPinky1;
+                }
+
+                int capsuleIndex = System.Array.FindIndex(ovrSkeleton.BoneCapsules, c => c.BoneIndex == boneIndex);
+                float radius = capsuleIndex < 0 ? 0f : ovrSkeleton.BoneCapsules[capsuleIndex].Radius;
+
+                handSkeleton.joints[i] = new HandSkeletonJoint()
+                {
+                    pose = new Pose()
+                    {
+                        position = srcPose.Position.FromFlippedXVector3f(),
+                        rotation = srcPose.Orientation.FromFlippedXQuatf()
+                    },
+                    parent = ovrSkeleton.Bones[i].ParentBoneIndex,
+                    radius = radius
+                };
+            }
+        }
+    }
+}

Assets/Oculus/Interaction/OVRIntegration/Runtime/Scripts/Input/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/OVRIntegration/Runtime/Scripts/Input/OVRAxis1D.cs

@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * Licensed under the Oculus SDK License Agreement (the "License");
+ * you may not use the Oculus SDK except in compliance with the License,
+ * which is provided at the time of installation or download, or which
+ * otherwise accompanies this software in either electronic or hard copy form.
+ *
+ * You may obtain a copy of the License at
+ *
+ * https://developer.oculus.com/licenses/oculussdk/
+ *
+ * Unless required by applicable law or agreed to in writing, the Oculus 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 Oculus.Interaction.Input;
+using System;
+using UnityEngine;
+
+namespace Oculus.Interaction.OVR.Input
+{
+    public class OVRAxis1D : MonoBehaviour, IAxis1D
+    {
+        [SerializeField]
+        private OVRInput.Controller _controller;
+
+        [SerializeField]
+        private OVRInput.Axis1D _axis1D;
+
+        [SerializeField]
+        private RemapConfig _remapConfig = new RemapConfig()
+        {
+            Enabled = false,
+            Curve = AnimationCurve.Linear(0,0,1,1)
+        };
+
+        [Serializable]
+        public class RemapConfig
+        {
+            public bool Enabled;
+            public AnimationCurve Curve;
+        }
+
+        public float Value()
+        {
+            float value = OVRInput.Get(_axis1D, _controller);
+            if (_remapConfig.Enabled)
+            {
+                value = _remapConfig.Curve.Evaluate(value);
+            }
+
+            return value;
+        }
+    }
+}

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

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

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

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * Licensed under the Oculus SDK License Agreement (the "License");
+ * you may not use the Oculus SDK except in compliance with the License,
+ * which is provided at the time of installation or download, or which
+ * otherwise accompanies this software in either electronic or hard copy form.
+ *
+ * You may obtain a copy of the License at
+ *
+ * https://developer.oculus.com/licenses/oculussdk/
+ *
+ * Unless required by applicable law or agreed to in writing, the Oculus 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 Oculus.Interaction.Input;
+using UnityEngine;
+
+namespace Oculus.Interaction.OVR.Input
+{
+    public class OVRAxis2D : MonoBehaviour, IAxis2D
+    {
+        [SerializeField]
+        private OVRInput.Controller _controller;
+
+        [SerializeField]
+        private OVRInput.Axis2D _axis2D;
+
+        public Vector2 Value()
+        {
+            return OVRInput.Get(_axis2D, _controller);
+        }
+    }
+}

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

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

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

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * Licensed under the Oculus SDK License Agreement (the "License");
+ * you may not use the Oculus SDK except in compliance with the License,
+ * which is provided at the time of installation or download, or which
+ * otherwise accompanies this software in either electronic or hard copy form.
+ *
+ * You may obtain a copy of the License at
+ *
+ * https://developer.oculus.com/licenses/oculussdk/
+ *
+ * Unless required by applicable law or agreed to in writing, the Oculus 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 Oculus.Interaction.Input;
+using UnityEngine;
+
+namespace Oculus.Interaction.OVR.Input
+{
+    public class OVRButton : MonoBehaviour, IButton
+    {
+        [SerializeField]
+        private OVRInput.Controller _controller;
+
+        [SerializeField]
+        private OVRInput.Button _button;
+
+        public bool Value()
+        {
+            return OVRInput.Get(_button, _controller);
+        }
+    }
+}

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

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

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

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * Licensed under the Oculus SDK License Agreement (the "License");
+ * you may not use the Oculus SDK except in compliance with the License,
+ * which is provided at the time of installation or download, or which
+ * otherwise accompanies this software in either electronic or hard copy form.
+ *
+ * You may obtain a copy of the License at
+ *
+ * https://developer.oculus.com/licenses/oculussdk/
+ *
+ * Unless required by applicable law or agreed to in writing, the Oculus 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.OVR.Input
+{
+    public class OVRButtonActiveState : MonoBehaviour, IActiveState
+    {
+        [SerializeField]
+        private OVRInput.Button _button;
+
+        public bool Active => OVRInput.Get(_button);
+    }
+}

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

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

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

@@ -0,0 +1,160 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * Licensed under the Oculus SDK License Agreement (the "License");
+ * you may not use the Oculus SDK except in compliance with the License,
+ * which is provided at the time of installation or download, or which
+ * otherwise accompanies this software in either electronic or hard copy form.
+ *
+ * You may obtain a copy of the License at
+ *
+ * https://developer.oculus.com/licenses/oculussdk/
+ *
+ * Unless required by applicable law or agreed to in writing, the Oculus 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 Oculus.Interaction.Input;
+using UnityEngine;
+
+namespace Oculus.Interaction
+{
+    /// <summary>
+    /// Takes a set of OVR Near, Touch and Button bools and remaps them to an Axis1D float.
+    /// </summary>
+    public class OVRButtonAxis1D : MonoBehaviour, IAxis1D
+    {
+        [SerializeField]
+        private OVRInput.Controller _controller;
+
+        [SerializeField]
+        private OVRInput.Button _near;
+
+        [SerializeField]
+        private OVRInput.Button _touch;
+
+        [SerializeField]
+        private OVRInput.Button _button;
+
+        [SerializeField]
+        private float _nearValue = 0.1f;
+
+        [SerializeField]
+        private float _touchValue = 0.5f;
+
+        [SerializeField]
+        private float _buttonValue = 1.0f;
+
+        [SerializeField]
+        private ProgressCurve _curve = new ProgressCurve(
+            AnimationCurve.EaseInOut(0, 0, 1, 1),
+            0.1f
+        );
+
+        #region Properties
+
+        public float NearValue
+        {
+            get
+            {
+                return _nearValue;
+            }
+            set
+            {
+                _nearValue = value;
+            }
+        }
+
+        public float TouchValue
+        {
+            get
+            {
+                return _touchValue;
+            }
+            set
+            {
+                _touchValue = value;
+            }
+        }
+
+        public float ButtonValue
+        {
+            get
+            {
+                return _buttonValue;
+            }
+            set
+            {
+                _buttonValue = value;
+            }
+        }
+
+        #endregion
+
+        private float _baseValue = 0;
+        private float _value = 0;
+        private float _currentTarget = 0;
+
+        public float Value()
+        {
+            return _value;
+        }
+
+        private float Target {
+            get
+            {
+                if (OVRInput.Get(_button, _controller))
+                {
+                    return _buttonValue;
+                }
+
+                if (OVRInput.Get(_touch, _controller))
+                {
+                    return _touchValue;
+                }
+
+                if (OVRInput.Get(_near, _controller))
+                {
+                    return _nearValue;
+                }
+
+                return 0;
+            }
+        }
+
+        protected virtual void Update()
+        {
+            float newTarget = Target;
+            if (_currentTarget != newTarget)
+            {
+                _baseValue = _value;
+                _currentTarget = newTarget;
+                _curve.Start();
+            }
+
+            _value = _curve.Progress() * (_currentTarget - _baseValue);
+        }
+
+        #region Inject
+
+        public void InjectAllOVRButtonAxis1D(OVRInput.Controller controller,
+            OVRInput.Button near, OVRInput.Button touch, OVRInput.Button button)
+        {
+            _controller = controller;
+            _near = near;
+            _touch = touch;
+            _button = button;
+        }
+
+        public void InjectOptionalCurve(ProgressCurve progressCurve)
+        {
+            _curve = progressCurve;
+        }
+
+        #endregion
+    }
+}

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

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

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

@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * Licensed under the Oculus SDK License Agreement (the "License");
+ * you may not use the Oculus SDK except in compliance with the License,
+ * which is provided at the time of installation or download, or which
+ * otherwise accompanies this software in either electronic or hard copy form.
+ *
+ * You may obtain a copy of the License at
+ *
+ * https://developer.oculus.com/licenses/oculussdk/
+ *
+ * Unless required by applicable law or agreed to in writing, the Oculus 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<bool> WhenInputDataDirtied;
+    }
+
+    /// <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<bool> WhenInputDataDirtied = delegate { };
+
+        protected bool _started = false;
+
+        private bool _isLateUpdate;
+
+        protected virtual void Start()
+        {
+            this.BeginStart(ref _started);
+            this.AssertField(_ovrCameraRig, nameof(_ovrCameraRig));
+            this.EndStart(ref _started);
+        }
+
+        protected virtual void FixedUpdate()
+        {
+            _isLateUpdate = false;
+        }
+
+        protected virtual void Update()
+        {
+            _isLateUpdate = false;
+        }
+
+        protected virtual void LateUpdate()
+        {
+            _isLateUpdate = true;
+        }
+
+        protected virtual void OnEnable()
+        {
+            if (_started)
+            {
+                CameraRig.UpdatedAnchors += HandleInputDataDirtied;
+            }
+        }
+
+        protected virtual void OnDisable()
+        {
+            if (_started)
+            {
+                CameraRig.UpdatedAnchors -= HandleInputDataDirtied;
+            }
+        }
+
+        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 HandleInputDataDirtied(OVRCameraRig cameraRig)
+        {
+            WhenInputDataDirtied(_isLateUpdate);
+        }
+
+        #region Inject
+        public void InjectAllOVRCameraRigRef(OVRCameraRig ovrCameraRig, bool requireHands)
+        {
+            InjectInteractionOVRCameraRig(ovrCameraRig);
+            InjectRequireHands(requireHands);
+        }
+
+        public void InjectInteractionOVRCameraRig(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/OVRIntegration/Runtime/Scripts/Input/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/OVRIntegration/Runtime/Scripts/Input/OVRControllerMatchesProfileActiveState.cs

@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * Licensed under the Oculus SDK License Agreement (the "License");
+ * you may not use the Oculus SDK except in compliance with the License,
+ * which is provided at the time of installation or download, or which
+ * otherwise accompanies this software in either electronic or hard copy form.
+ *
+ * You may obtain a copy of the License at
+ *
+ * https://developer.oculus.com/licenses/oculussdk/
+ *
+ * Unless required by applicable law or agreed to in writing, the Oculus 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
+{
+    /// <summary>
+    /// An ActiveState that is active when the controller matches the interaction profile.
+    /// </summary>
+    public class OVRControllerMatchesProfileActiveState : MonoBehaviour, IActiveState
+    {
+        [SerializeField]
+        private OVRInput.Controller _controller;
+
+        [SerializeField]
+        private OVRInput.InteractionProfile _profile;
+
+        public bool Active
+        {
+            get
+            {
+                OVRInput.Hand ovrHandedness = _controller.HasFlag(OVRInput.Controller.LTouch) || _controller.HasFlag(OVRInput.Controller.LHand) ? OVRInput.Hand.HandLeft : OVRInput.Hand.HandRight;
+                OVRInput.InteractionProfile ovrProfile = OVRInput.GetCurrentInteractionProfile(ovrHandedness);
+                return ovrProfile == _profile;
+            }
+        }
+
+        #region Inject
+
+        public void InjectAllOVRControllerSupportsPressure(OVRInput.Controller controller)
+        {
+            _controller = controller;
+        }
+
+        #endregion
+    }
+}

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

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

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

@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * Licensed under the Oculus SDK License Agreement (the "License");
+ * you may not use the Oculus SDK except in compliance with the License,
+ * which is provided at the time of installation or download, or which
+ * otherwise accompanies this software in either electronic or hard copy form.
+ *
+ * You may obtain a copy of the License at
+ *
+ * https://developer.oculus.com/licenses/oculussdk/
+ *
+ * Unless required by applicable law or agreed to in writing, the Oculus 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.
+ */
+
+namespace Oculus.Interaction.Input
+{
+    public static class OVRControllerUtility
+    {
+        public static float GetPinchAmount(OVRInput.Controller ovrController)
+        {
+            float pinchAmount = OVRInput.Get(OVRInput.Axis1D.PrimaryIndexTrigger, ovrController);
+            return pinchAmount;
+        }
+
+        public static float GetIndexCurl(OVRInput.Controller ovrController)
+        {
+            float indexCurl;
+            if (SupportsAnalogIndex(ovrController))
+            {
+                indexCurl = OVRInput.Get(OVRInput.Axis1D.PrimaryIndexTriggerCurl, ovrController);
+            }
+            else
+            {
+                // Fallback to binary capsense
+                bool isPointing = !OVRInput.Get(OVRInput.NearTouch.PrimaryIndexTrigger, ovrController)
+                    && OVRInput.Get(OVRInput.Axis1D.PrimaryIndexTrigger, ovrController) == 0f;
+
+                indexCurl = isPointing ? 0 : 1;
+            }
+            return indexCurl;
+        }
+
+        public static float GetIndexSlide(OVRInput.Controller ovrController)
+        {
+            float indexSlide;
+            if (SupportsAnalogIndex(ovrController))
+            {
+                indexSlide = OVRInput.Get(OVRInput.Axis1D.PrimaryIndexTriggerSlide, ovrController);
+            }
+            else
+            {
+                indexSlide = 0;
+            }
+            return indexSlide;
+        }
+
+        private static bool SupportsAnalogIndex(OVRInput.Controller ovrController)
+        {
+            bool isTouchController = (ovrController == OVRInput.Controller.LTouch) || (ovrController == OVRInput.Controller.RTouch);
+            if (!isTouchController)
+            {
+                return false;
+            }
+
+            OVRInput.Hand ovrHandedness = (ovrController == OVRInput.Controller.LTouch) ? OVRInput.Hand.HandLeft : OVRInput.Hand.HandRight;
+            OVRInput.InteractionProfile ovrProfile = OVRInput.GetCurrentInteractionProfile(ovrHandedness);
+            return ovrProfile != OVRInput.InteractionProfile.Touch;
+        }
+    }
+}

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

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

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

@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * Licensed under the Oculus SDK License Agreement (the "License");
+ * you may not use the Oculus SDK except in compliance with the License,
+ * which is provided at the time of installation or download, or which
+ * otherwise accompanies this software in either electronic or hard copy form.
+ *
+ * You may obtain a copy of the License at
+ *
+ * https://developer.oculus.com/licenses/oculussdk/
+ *
+ * Unless required by applicable law or agreed to in writing, the Oculus 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;
+
+namespace Oculus.Interaction.Input.Visuals
+{
+    public class OVRControllerVisual : MonoBehaviour
+    {
+        [SerializeField, Interface(typeof(IController))]
+        private UnityEngine.Object _controller;
+
+        public IController Controller;
+
+        [SerializeField]
+        private OVRControllerHelper _ovrControllerHelper;
+
+        public bool ForceOffVisibility { get; set; }
+
+        private bool _started = false;
+
+        protected virtual void Awake()
+        {
+            Controller = _controller as IController;
+        }
+
+        protected virtual void Start()
+        {
+            this.BeginStart(ref _started);
+            this.AssertField(Controller, nameof(Controller));
+            this.AssertField(_ovrControllerHelper, nameof(_ovrControllerHelper));
+            switch (Controller.Handedness)
+            {
+                case Handedness.Left:
+                    _ovrControllerHelper.m_controller = OVRInput.Controller.LTouch;
+                    break;
+                case Handedness.Right:
+                    _ovrControllerHelper.m_controller = OVRInput.Controller.RTouch;
+                    break;
+            }
+            this.EndStart(ref _started);
+        }
+
+        protected virtual void OnEnable()
+        {
+            if (_started)
+            {
+                Controller.WhenUpdated += HandleUpdated;
+            }
+        }
+
+        protected virtual void OnDisable()
+        {
+            if (_started && _controller != null)
+            {
+                Controller.WhenUpdated -= HandleUpdated;
+            }
+        }
+
+        private void HandleUpdated()
+        {
+            if (!Controller.IsConnected ||
+                ForceOffVisibility ||
+                !Controller.TryGetPose(out Pose rootPose))
+            {
+                _ovrControllerHelper.gameObject.SetActive(false);
+                return;
+            }
+
+            _ovrControllerHelper.gameObject.SetActive(true);
+            transform.position = rootPose.position;
+            transform.rotation = rootPose.rotation;
+            float parentScale = transform.parent != null ? transform.parent.lossyScale.x : 1f;
+            transform.localScale = Controller.Scale / parentScale * Vector3.one;
+        }
+
+        #region Inject
+
+        public void InjectAllOVRControllerVisual(IController controller, OVRControllerHelper ovrControllerHelper)
+        {
+            InjectController(controller);
+            InjectAllOVRControllerHelper(ovrControllerHelper);
+        }
+
+        public void InjectController(IController controller)
+        {
+            _controller = controller as UnityEngine.Object;
+            Controller = controller;
+        }
+
+        public void InjectAllOVRControllerHelper(OVRControllerHelper ovrControllerHelper)
+        {
+            _ovrControllerHelper = ovrControllerHelper;
+        }
+
+        #endregion
+    }
+}

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

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

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

@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * Licensed under the Oculus SDK License Agreement (the "License");
+ * you may not use the Oculus SDK except in compliance with the License,
+ * which is provided at the time of installation or download, or which
+ * otherwise accompanies this software in either electronic or hard copy form.
+ *
+ * You may obtain a copy of the License at
+ *
+ * https://developer.oculus.com/licenses/oculussdk/
+ *
+ * Unless required by applicable law or agreed to in writing, the Oculus 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/OVRIntegration/Runtime/Scripts/Input/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/OVRIntegration/Runtime/Scripts/Input/OVRNearTouch.cs

@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * Licensed under the Oculus SDK License Agreement (the "License");
+ * you may not use the Oculus SDK except in compliance with the License,
+ * which is provided at the time of installation or download, or which
+ * otherwise accompanies this software in either electronic or hard copy form.
+ *
+ * You may obtain a copy of the License at
+ *
+ * https://developer.oculus.com/licenses/oculussdk/
+ *
+ * Unless required by applicable law or agreed to in writing, the Oculus 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 OVRNearTouch : MonoBehaviour, IButton
+    {
+        [SerializeField]
+        private OVRInput.Controller _controller;
+
+        [SerializeField]
+        private OVRInput.NearTouch _nearTouch;
+
+        public bool Value()
+        {
+            return OVRInput.Get(_nearTouch, _controller);
+        }
+    }
+}

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

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

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

@@ -0,0 +1,179 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * Licensed under the Oculus SDK License Agreement (the "License");
+ * you may not use the Oculus SDK except in compliance with the License,
+ * which is provided at the time of installation or download, or which
+ * otherwise accompanies this software in either electronic or hard copy form.
+ *
+ * You may obtain a copy of the License at
+ *
+ * https://developer.oculus.com/licenses/oculussdk/
+ *
+ * Unless required by applicable law or agreed to in writing, the Oculus 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/OVRIntegration/Runtime/Scripts/Input/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/OVRIntegration/Runtime/Scripts/Input/OVRTouch.cs

@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * Licensed under the Oculus SDK License Agreement (the "License");
+ * you may not use the Oculus SDK except in compliance with the License,
+ * which is provided at the time of installation or download, or which
+ * otherwise accompanies this software in either electronic or hard copy form.
+ *
+ * You may obtain a copy of the License at
+ *
+ * https://developer.oculus.com/licenses/oculussdk/
+ *
+ * Unless required by applicable law or agreed to in writing, the Oculus 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 OVRTouch : MonoBehaviour, IButton
+    {
+        [SerializeField]
+        private OVRInput.Controller _controller;
+
+        [SerializeField]
+        private OVRInput.Touch _touch;
+
+        public bool Value()
+        {
+            return OVRInput.Get(_touch, _controller);
+        }
+    }
+}

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

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

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

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * Licensed under the Oculus SDK License Agreement (the "License");
+ * you may not use the Oculus SDK except in compliance with the License,
+ * which is provided at the time of installation or download, or which
+ * otherwise accompanies this software in either electronic or hard copy form.
+ *
+ * You may obtain a copy of the License at
+ *
+ * https://developer.oculus.com/licenses/oculussdk/
+ *
+ * Unless required by applicable law or agreed to in writing, the Oculus 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/OVRIntegration/Runtime/Scripts/Input/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/OVRIntegration/Runtime/Scripts/Input/TrackingToWorldTransformerOVR.cs

@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * Licensed under the Oculus SDK License Agreement (the "License");
+ * you may not use the Oculus SDK except in compliance with the License,
+ * which is provided at the time of installation or download, or which
+ * otherwise accompanies this software in either electronic or hard copy form.
+ *
+ * You may obtain a copy of the License at
+ *
+ * https://developer.oculus.com/licenses/oculussdk/
+ *
+ * Unless required by applicable law or agreed to in writing, the Oculus 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 UnityEngine.Object _cameraRigRef;
+        public IOVRCameraRigRef CameraRigRef { get; private set; }
+
+        public Transform Transform => CameraRigRef.CameraRig.trackingSpace;
+
+        /// <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()
+        {
+            this.AssertField(CameraRigRef, nameof(CameraRigRef));
+        }
+
+        #region Inject
+
+        public void InjectAllTrackingToWorldTransformerOVR(IOVRCameraRigRef cameraRigRef)
+        {
+            InjectCameraRigRef(cameraRigRef);
+        }
+
+        public void InjectCameraRigRef(IOVRCameraRigRef cameraRigRef)
+        {
+            _cameraRigRef = cameraRigRef as UnityEngine.Object;
+            CameraRigRef = cameraRigRef;
+        }
+
+        #endregion
+    }
+}

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

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