Merge branch 'HTK-master' into HTK-local

Author: StephenHodgson

Assets/HoloToolkit-Examples/SavingSpatialMeshes/README.md

@@ -16,7 +16,7 @@ Process: Scan, save, download, and load.
 
 1. Install the app on a device.
 2. Scan room.
-3. When your ready to save the mesh say, "Capture Mesh". Text will display to acknowledge the completion of the action.
+3. When you're ready to save the mesh say, "Capture Mesh". Text will display to acknowledge the completion of the action.
 4. Pull the saved mesh off of the device by going to the Device Portal. Navigate to System > File Explorer > User Files > LocalAppData > [Your App Name] > RoamingState. This is where .room files are saved.
 5. Download the .room file to your computer in the location opened by FileSurfaceObserver's "Open File Location" button.
 6. Press the Play button.

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();
         }
     }
-}
+}