Merge pull request #541 from StephenHodgson/HTK-EditorHands

Modified Editor Input

Author: StephenHodgson

Assets/HoloToolkit/Input/Scripts/InputSources/EditorHandsInput.cs

@@ -29,6 +29,9 @@ public EditorHandData(uint handId)
                 IsFingerDownPending = false;
                 FingerStateChanged = false;
                 FingerStateUpdateTimer = -1;
+                ManipulationInProgress = false;
+                HoldInProgress = false;
+                CumulativeDelta = Vector3.zero;
             }
 
             public readonly uint HandId;
@@ -38,13 +41,16 @@ public EditorHandData(uint handId)
             public bool IsFingerDownPending;
             public bool FingerStateChanged;
             public float FingerStateUpdateTimer;
-			public float FingerDownStartTime;
+            public float FingerDownStartTime;
+            public bool ManipulationInProgress;
+            public bool HoldInProgress;
+            public Vector3 CumulativeDelta;
         }
 
         private ManualHandControl manualHandControl;
 
         /// <summary>
-        /// Dispatched each frame that a hand is moving
+        /// Dispatched each frame that a hand is moving.
         /// </summary>
         public event Action<IInputSource, uint> HandMoved;
 
@@ -65,7 +71,7 @@ public EditorHandData(uint handId)
         private const int EditorHandsCount = 2;
 
         /// <summary>
-        /// Array containing the hands data for the two fake hands
+        /// Array containing the hands data for the two fake hands.
         /// </summary>
         private readonly EditorHandData[] editorHandsData = new EditorHandData[EditorHandsCount];
 
@@ -75,10 +81,14 @@ public EditorHandData(uint handId)
         private readonly Dictionary<uint, EditorHandData> handIdToData = new Dictionary<uint, EditorHandData>(4);
         private readonly List<uint> pendingHandIdDeletes = new List<uint>();
 
-        // HashSets used to be able to quickly update the hands data when hands become visible / not visible
+        // HashSets used to be able to quickly update the hands data when hands become visible / not visible.
         private readonly HashSet<uint> currentHands = new HashSet<uint>();
         private readonly HashSet<uint> newHands = new HashSet<uint>();
 
+        [SerializeField]
+        [Tooltip("The total amount of hand movement that needs to happen to signal intent to start a manipulation. This is a distance, but not a distance in any one direction.")]
+        private float manipulationStartMovementThreshold = 0.03f;
+
         public override SupportedInputInfo GetSupportedInputInfo(uint sourceId)
         {
             return SupportedInputInfo.Position;
@@ -98,7 +108,7 @@ public override bool TryGetPosition(uint sourceId, out Vector3 position)
 
         public override bool TryGetOrientation(uint sourceId, out Quaternion orientation)
         {
-            // Orientation is not supported by hands
+            // Orientation is not supported by hands.
             orientation = Quaternion.identity;
             return false;
         }
@@ -112,55 +122,55 @@ public Vector3 GetHandDelta(uint handId)
         {
             if (handId >= editorHandsData.Length)
             {
-                string message = string.Format("GetHandDelta called with invalid hand ID {0}.", handId);
+                string message = string.Format("GetHandDelta called with invalid hand ID {0}.", handId.ToString());
                 throw new ArgumentException(message, "handId");
             }
 
             return editorHandsData[handId].HandDelta;
         }
 
         /// <summary>
-        /// Gets the pressed state of the specified hand
+        /// Gets the pressed state of the specified hand.
         /// </summary>
         /// <param name="handId">ID of the hand to get.</param>
         /// <returns>True if the specified hand is currently in an airtap.</returns>
         public bool GetFingerState(uint handId)
         {
             if (handId >= editorHandsData.Length)
             {
-                var message = string.Format("GetFingerState called with invalid hand ID {0}.", handId);
+                var message = string.Format("GetFingerState called with invalid hand ID {0}.", handId.ToString());
                 throw new ArgumentException(message, "handId");
             }
 
             return editorHandsData[handId].IsFingerDown;
         }
 
         /// <summary>
-        /// Gets whether the specified hand just started an airtap this frame
+        /// Gets whether the specified hand just started an airtap this frame.
         /// </summary>
         /// <param name="handId">ID of the hand to get.</param>
         /// <returns>True for the first frame of an airtap</returns>
         public bool GetFingerDown(uint handId)
         {
             if (handId >= editorHandsData.Length)
             {
-                var message = string.Format("GetFingerDown called with invalid hand ID {0}.", handId);
+                var message = string.Format("GetFingerDown called with invalid hand ID {0}.", handId.ToString());
                 throw new ArgumentException(message, "handId");
             }
 
             return editorHandsData[handId].IsFingerDown && editorHandsData[handId].FingerStateChanged;
         }
 
         /// <summary>
-        /// Gets whether the specified hand just ended an airtap this frame
+        /// Gets whether the specified hand just ended an airtap this frame.
         /// </summary>
         /// <param name="handId">ID of the hand to get.</param>
         /// <returns>True for the first frame of the release of an airtap</returns>
         public bool GetFingerUp(uint handId)
         {
             if (handId >= editorHandsData.Length)
             {
-                var message = string.Format("GetFingerUp called with invalid hand ID {0}.", handId);
+                var message = string.Format("GetFingerUp called with invalid hand ID {0}.", handId.ToString());
                 throw new ArgumentException(message, "handId");
             }
 
@@ -171,12 +181,13 @@ private void Awake()
         {
 #if !UNITY_EDITOR
             Destroy(this);
-#endif
+#else
             manualHandControl = GetComponent<ManualHandControl>();
             for (uint i = 0; i < editorHandsData.Length; i++)
             {
                 editorHandsData[i] = new EditorHandData(i);
             }
+#endif
         }
 
 #if UNITY_EDITOR
@@ -238,7 +249,6 @@ private EditorHandData GetOrAddHandData(uint sourceId)
                 handData = new EditorHandData(sourceId);
                 handIdToData.Add(handData.HandId, handData);
                 newHands.Add(handData.HandId);
-
             }
 
             return handData;
@@ -249,24 +259,26 @@ private EditorHandData GetOrAddHandData(uint sourceId)
         /// </summary>
         /// <param name="handSource">Hand source to use to update the position.</param>
         /// <param name="editorHandData">EditorHandData structure to update.</param>
+        /// <param name="deltaTime">Unscaled delta time of last event.</param>
+        /// <param name="time">Unscaled time of last event.</param>
         private void UpdateHandState(DebugInteractionSourceState handSource, EditorHandData editorHandData, float deltaTime, float time)
         {
-            // Update hand position
+            // Update hand position.
             Vector3 handPosition;
             if (handSource.Properties.Location.TryGetPosition(out handPosition))
             {
                 editorHandData.HandDelta = handPosition - editorHandData.HandPosition;
                 editorHandData.HandPosition = handPosition;
             }
 
-            // Check for finger presses
+            // Check for finger presses.
             if (handSource.Pressed != editorHandData.IsFingerDownPending)
             {
                 editorHandData.IsFingerDownPending = handSource.Pressed;
                 editorHandData.FingerStateUpdateTimer = FingerPressDelay;
             }
 
-            // Finger presses are delayed to mitigate issue with hand position shifting during air tap
+            // Finger presses are delayed to mitigate issue with hand position shifting during air tap.
             editorHandData.FingerStateChanged = false;
             if (editorHandData.FingerStateUpdateTimer > 0)
             {
@@ -289,31 +301,79 @@ private void UpdateHandState(DebugInteractionSourceState handSource, EditorHandD
         /// Sends the events for hand state changes.
         /// </summary>
         /// <param name="editorHandData">Hand data for which events should be sent.</param>
+        /// <param name="time">Unscaled time of last event.</param>
         private void SendHandStateEvents(EditorHandData editorHandData, float time)
         {
-            // Hand moved event
+            // Hand moved event.
             if (editorHandData.HandDelta.sqrMagnitude > 0)
             {
                 HandMoved.RaiseEvent(this, editorHandData.HandId);
             }
 
-            // Finger pressed/released events
+            // If the finger state has just changed to be down vs up.
             if (editorHandData.FingerStateChanged)
             {
+                // New down presses are straightforward - fire input down and be on your way.
                 if (editorHandData.IsFingerDown)
                 {
                     inputManager.RaiseSourceDown(this, editorHandData.HandId);
+                    editorHandData.CumulativeDelta = Vector3.zero;
                 }
+                // New up presses require sending different events depending on whether it's also a click, hold, or manipulation.
                 else
                 {
+                    // A gesture is always either a click, a hold or a manipulation.
+                    if (editorHandData.ManipulationInProgress)
+                    {
+                        inputManager.RaiseManipulationCompleted(this, editorHandData.HandId, editorHandData.CumulativeDelta);
+                        editorHandData.ManipulationInProgress = false;
+                    }
+                    // Clicks and holds are based on time, and both are overruled by manipulations.
+                    else if (editorHandData.HoldInProgress)
+                    {
+                        inputManager.RaiseHoldCompleted(this, editorHandData.HandId);
+                        editorHandData.HoldInProgress = false;
+                    }
+                    else
+                    {
+                        // We currently only support single taps in editor.
+                        inputManager.RaiseInputClicked(this, editorHandData.HandId, 1);
+                    }
+
                     inputManager.RaiseSourceUp(this, editorHandData.HandId);
+                }
+            }
+            // If the finger state hasn't changed, and the finger is down, that means if calculations need to be done
+            // nothing might change, or it might trigger a hold or a manipulation (or a hold and then a manipulation).
+            else if (editorHandData.IsFingerDown)
+            {
+                editorHandData.CumulativeDelta += editorHandData.HandDelta;
 
-                    // Also send click event when using this hands replacement input
-                    if (time - editorHandData.FingerDownStartTime < MaxClickDuration)
+                if (!editorHandData.ManipulationInProgress)
+                {
+                    // Manipulations are triggered by the amount of movement since the finger was pressed down.
+                    if (editorHandData.CumulativeDelta.magnitude > manipulationStartMovementThreshold)
                     {
-                        // We currently only support single taps in editor
-                        inputManager.RaiseInputClicked(this, editorHandData.HandId, 1);
-					}
+                        // Starting a manipulation will cancel an existing hold.
+                        if (editorHandData.HoldInProgress)
+                        {
+                            inputManager.RaiseHoldCanceled(this, editorHandData.HandId);
+                            editorHandData.HoldInProgress = false;
+                        }
+
+                        inputManager.RaiseManipulationStarted(this, editorHandData.HandId, editorHandData.CumulativeDelta);
+                        editorHandData.ManipulationInProgress = true;
+                    }
+                    // Holds are triggered by time.
+                    else if (!editorHandData.HoldInProgress && (time - editorHandData.FingerDownStartTime >= MaxClickDuration))
+                    {
+                        inputManager.RaiseHoldStarted(this, editorHandData.HandId);
+                        editorHandData.HoldInProgress = true;
+                    }
+                }
+                else
+                {
+                    inputManager.RaiseManipulationUpdated(this, editorHandData.HandId, editorHandData.CumulativeDelta);
                 }
             }
         }
@@ -323,13 +383,13 @@ private void SendHandStateEvents(EditorHandData editorHandData, float time)
         /// </summary>
         private void SendHandVisibilityEvents()
         {
-            // Send event for new hands that were added
+            // Send event for new hands that were added.
             foreach (uint newHand in newHands)
             {
                 inputManager.RaiseSourceDetected(this, newHand);
             }
 
-            // Send event for hands that are no longer visible and remove them from our dictionary
+            // Send event for hands that are no longer visible and remove them from our dictionary.
             foreach (uint existingHand in handIdToData.Keys)
             {
                 if (!currentHands.Contains(existingHand))
@@ -339,12 +399,12 @@ private void SendHandVisibilityEvents()
                 }
             }
 
-            // Remove pending hand IDs
+            // Remove pending hand IDs.
             for (int i = 0; i < pendingHandIdDeletes.Count; ++i)
             {
                 handIdToData.Remove(pendingHandIdDeletes[i]);
             }
             pendingHandIdDeletes.Clear();
         }
     }
-}
+}