Fix jaggy hand pose transition when an interactable overrides the han…

…d pose to use (#141)

* Fix source pose not filtering for source ID

* Fix hand pose override is detected too late and causes jaggy transition

* Clean up profile

Assets~/Profiles/Input/InteractorsProfile.asset

@@ -12,7 +12,6 @@ MonoBehaviour:
   m_Script: {fileID: 11500000, guid: 5f1708952b3739a47908a0fb9a103a7e, type: 3}
   m_Name: InteractorsProfile
   m_EditorClassIdentifier: 
-  pointingExtent: 10
   pointerRaycastLayerMasks:
   - serializedVersion: 2
     m_Bits: 4294967291

Runtime/Input/Hands/Poses/IProvideHandPose.cs

@@ -0,0 +1,26 @@
+// Copyright (c) Reality Collective. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+namespace RealityToolkit.Input.Hands.Poses
+{
+    /// <summary>
+    /// Identifies and implementation that provides <see cref="HandPose"/>s to <see cref="Visualizers.BaseHandControllerVisualizer"/>s.
+    /// </summary>
+    public interface IProvideHandPose
+    {
+        /// <summary>
+        /// Optional focus <see cref="HandPose"/> override.
+        /// </summary>
+        HandPose FocusPose { get; }
+
+        /// <summary>
+        /// Optional select <see cref="HandPose"/> override.
+        /// </summary>
+        HandPose SelectPose { get; }
+
+        /// <summary>
+        /// Optional grab <see cref="HandPose"/> override.
+        /// </summary>
+        HandPose GrabPose { get; }
+    }
+}

Runtime/Input/Hands/Visualizers/BaseHandControllerVisualizer.cs

@@ -1,7 +1,10 @@
-// Copyright (c) Reality Collective. All rights reserved.
+// Copyright (c) Reality Collective. All rights reserved.
 // Licensed under the MIT License. See LICENSE in the project root for license information.
 
+using RealityCollective.Utilities.Extensions;
+using RealityToolkit.EventDatum.Input;
 using RealityToolkit.Input.Controllers;
+using RealityToolkit.Input.Hands.Poses;
 using System;
 using UnityEngine;
 
@@ -25,5 +28,46 @@ protected virtual void Awake()
                 return;
             }
         }
+
+        /// <summary>
+        /// Checks whether any of the <see cref="Interactors.IInteractor"/>s on this <see cref="BaseHandControllerVisualizer"/> is targeting
+        /// an object that has a <see cref="IProvideHandPose"/> implementation attached to it.
+        /// </summary>
+        /// <param name="eventData">The input event data received.</param>
+        /// <param name="checkFocus">Check whether there is a <see cref="IProvideHandPose"/> that provides a focus pose.</param>
+        /// <param name="checkSelect">Check whether there is a <see cref="IProvideHandPose"/> that provides a select pose.</param>
+        /// <param name="checkGrab">Check whether there is a <see cref="IProvideHandPose"/> that provides a grab pose.</param>
+        /// <returns></returns>
+        protected bool IsTargetingHandPoseProvider(InputEventData eventData, bool checkFocus, bool checkSelect, bool checkGrab)
+        {
+            for (var i = 0; i < eventData.InputSource.Pointers.Length; i++)
+            {
+                var interactor = eventData.InputSource.Pointers[i];
+                if (interactor.Result.CurrentTarget.IsNotNull())
+                {
+                    var poseProviders = interactor.Result.CurrentTarget.GetComponents<IProvideHandPose>();
+                    for (var j = 0; j < poseProviders.Length; j++)
+                    {
+                        var poseProvider = poseProviders[j];
+                        if (checkFocus && poseProvider.FocusPose.IsNotNull())
+                        {
+                            return true;
+                        }
+
+                        if (checkSelect && poseProvider.SelectPose.IsNotNull())
+                        {
+                            return true;
+                        }
+
+                        if (checkGrab && poseProvider.GrabPose.IsNotNull())
+                        {
+                            return true;
+                        }
+                    }
+                }
+            }
+
+            return false;
+        }
     }
 }

Runtime/Input/Hands/Visualizers/RiggedHandControllerVisualizer.cs

@@ -86,12 +86,14 @@ public override void OnInputDown(InputEventData eventData)
             }
 
             if (eventData.InputSource == Controller.InputSource &&
-                eventData.InputAction == selectInputAction)
+                eventData.InputAction == selectInputAction &&
+                !IsTargetingHandPoseProvider(eventData, false, true, false))
             {
                 poseAnimator.Transition(selectHandPose);
             }
             else if (eventData.InputSource == Controller.InputSource &&
-                eventData.InputAction == gripInputAction)
+                eventData.InputAction == gripInputAction &&
+                !IsTargetingHandPoseProvider(eventData, false, false, true))
             {
                 poseAnimator.Transition(gripHandPose);
             }
@@ -106,12 +108,14 @@ public override void OnInputUp(InputEventData eventData)
             }
 
             if (eventData.InputSource == Controller.InputSource &&
-                eventData.InputAction == selectInputAction)
+                eventData.InputAction == selectInputAction &&
+                !IsTargetingHandPoseProvider(eventData, false, true, false))
             {
                 poseAnimator.Transition(idlePose);
             }
             else if (eventData.InputSource == Controller.InputSource &&
-                eventData.InputAction == gripInputAction)
+                eventData.InputAction == gripInputAction &&
+                !IsTargetingHandPoseProvider(eventData, false, false, true))
             {
                 poseAnimator.Transition(idlePose);
             }
@@ -130,12 +134,14 @@ public override void OnInputChanged(InputEventData<float> eventData)
             }
 
             if (eventData.InputSource == Controller.InputSource &&
-                eventData.InputAction == selectInputAction)
+                eventData.InputAction == selectInputAction &&
+                !IsTargetingHandPoseProvider(eventData, false, true, false))
             {
                 OnSingleAxisInputChanged(eventData.InputData, selectHandPose);
             }
             else if (eventData.InputSource == Controller.InputSource &&
-                eventData.InputAction == gripInputAction)
+                eventData.InputAction == gripInputAction &&
+                !IsTargetingHandPoseProvider(eventData, false, false, true))
             {
                 OnSingleAxisInputChanged(eventData.InputData, gripHandPose);
             }

Runtime/Input/Interactables/Interactable.cs

@@ -49,7 +49,6 @@ public class Interactable : MonoBehaviour,
         [Tooltip("The action that will grab this interactable, if focused by an interactor.")]
         protected InputAction grabAction = InputAction.None;
 
-        [Space]
         [SerializeField, Tooltip("The focus mode for this interactable.")]
         private InteractableFocusMode focusMode = InteractableFocusMode.Single;
 

Runtime/Input/InteractionBehaviours/FocusHandPoseBehaviour.cs

@@ -14,13 +14,22 @@ namespace RealityToolkit.Input.InteractionBehaviours
     /// into the assigned <see cref="focusPose"/>, when the <see cref="Interactables.IInteractable"/> is focused.
     [HelpURL("https://www.realitytoolkit.io/docs/interactions/interaction-behaviours/default-behaviours/focus-hand-pose-behaviour")]
     [AddComponentMenu(RealityToolkitRuntimePreferences.Toolkit_InteractionsAddComponentMenu + "/" + nameof(FocusHandPoseBehaviour))]
-    public class FocusHandPoseBehaviour : BaseInteractionBehaviour
+    public class FocusHandPoseBehaviour : BaseInteractionBehaviour, IProvideHandPose
     {
         [SerializeField, Tooltip("Hand pose applied when focusing the interactable.")]
         private HandPose focusPose = null;
 
         /// <inheritdoc/>
-        protected override void OnFirstFocusEntered(InteractionEventArgs eventArgs)
+        public HandPose FocusPose => focusPose;
+
+        /// <inheritdoc/>
+        public HandPose SelectPose { get; } = null;
+
+        /// <inheritdoc/>
+        public HandPose GrabPose { get; } = null;
+
+        /// <inheritdoc/>
+        protected override void OnFocusEntered(InteractionEventArgs eventArgs)
         {
             if (Interactable.IsSelected || Interactable.IsGrabbed)
             {
@@ -35,7 +44,7 @@ protected override void OnFirstFocusEntered(InteractionEventArgs eventArgs)
         }
 
         /// <inheritdoc/>
-        protected override void OnLastFocusExited(InteractionExitEventArgs eventArgs)
+        protected override void OnFocusExited(InteractionExitEventArgs eventArgs)
         {
             if (Interactable.IsSelected || Interactable.IsGrabbed)
             {

Runtime/Input/InteractionBehaviours/GrabHandPoseBehaviour.cs

@@ -14,11 +14,20 @@ namespace RealityToolkit.Input.InteractionBehaviours
     /// into the assigned <see cref="grabPose"/>, when the <see cref="Interactables.IInteractable"/> is grabbed.
     [HelpURL("https://www.realitytoolkit.io/docs/interactions/interaction-behaviours/default-behaviours/grab-hand-pose-behaviour")]
     [AddComponentMenu(RealityToolkitRuntimePreferences.Toolkit_InteractionsAddComponentMenu + "/" + nameof(GrabHandPoseBehaviour))]
-    public class GrabHandPoseBehaviour : BaseInteractionBehaviour
+    public class GrabHandPoseBehaviour : BaseInteractionBehaviour, IProvideHandPose
     {
         [SerializeField, Tooltip("Hand pose applied when grabbing the interactable.")]
         private HandPose grabPose = null;
 
+        /// <inheritdoc/>
+        public HandPose FocusPose { get; } = null;
+
+        /// <inheritdoc/>
+        public HandPose SelectPose { get; } = null;
+
+        /// <inheritdoc/>
+        public HandPose GrabPose => grabPose;
+
         /// <inheritdoc/>
         protected override void OnGrabEntered(InteractionEventArgs eventArgs)
         {

Runtime/Input/InteractionBehaviours/SelectHandPoseBehaviour.cs

@@ -0,0 +1,48 @@
+using RealityToolkit.Input.Events;
+using RealityToolkit.Input.Hands.Poses;
+using RealityToolkit.Input.Hands.Visualizers;
+using RealityToolkit.Input.Interactors;
+using UnityEngine;
+
+namespace RealityToolkit.Input.InteractionBehaviours
+{
+    /// <summary>
+    /// The <see cref="SelectHandPoseBehaviour"/> will animate the <see cref="RiggedHandControllerVisualizer"/>
+    /// into the assigned <see cref="selectPose"/>, when the <see cref="Interactables.IInteractable"/> is selected.
+    [HelpURL("https://www.realitytoolkit.io/docs/interactions/interaction-behaviours/default-behaviours/select-hand-pose-behaviour")]
+    [AddComponentMenu(RealityToolkitRuntimePreferences.Toolkit_InteractionsAddComponentMenu + "/" + nameof(SelectHandPoseBehaviour))]
+    public class SelectHandPoseBehaviour : BaseInteractionBehaviour, IProvideHandPose
+    {
+        [SerializeField, Tooltip("Select pose applied when selecting the interactable.")]
+        private HandPose selectPose = null;
+
+        /// <inheritdoc/>
+        public HandPose FocusPose { get; } = null;
+
+        /// <inheritdoc/>
+        public HandPose SelectPose => selectPose;
+
+        /// <inheritdoc/>
+        public HandPose GrabPose { get; } = null;
+
+        /// <inheritdoc/>
+        protected override void OnSelectEntered(InteractionEventArgs eventArgs)
+        {
+            if (eventArgs.Interactor is IDirectInteractor directInteractor &&
+                directInteractor.Controller.Visualizer is RiggedHandControllerVisualizer riggedHandControllerVisualizer)
+            {
+                riggedHandControllerVisualizer.OverridePose = selectPose;
+            }
+        }
+
+        /// <inheritdoc/>
+        protected override void OnSelectExited(InteractionExitEventArgs eventArgs)
+        {
+            if (eventArgs.Interactor is IDirectInteractor directInteractor &&
+                directInteractor.Controller.Visualizer is RiggedHandControllerVisualizer riggedHandControllerVisualizer)
+            {
+                riggedHandControllerVisualizer.OverridePose = null;
+            }
+        }
+    }
+}