Merge branch 'HTK-master' into HTK-local

Author: Stephen Hodgson

Assets/HoloToolkit/Input/Scripts/Cursor/Cursor.cs

@@ -23,11 +23,11 @@ public enum CursorStateEnum
             /// <summary>
             /// Not IsHandVisible
             /// </summary>
-            Observe, 
+            Observe,
             /// <summary>
             /// Not IsHandVisible AND not IsInputSourceDown AND TargetedObject exists
             /// </summary>
-            ObserveHover, 
+            ObserveHover,
             /// <summary>
             /// IsHandVisible AND not IsInputSourceDown AND TargetedObject is NULL
             /// </summary>
@@ -73,10 +73,13 @@ public enum CursorStateEnum
         [Tooltip("The distance from the hit surface to place the cursor")]
         public float SurfaceCursorDistance = 0.02f;
 
+        [Header("Motion")]
+        [Tooltip("When lerping, use unscaled time. This is useful for games that have a pause mechanism or otherwise adjust the game timescale.")]
+        public bool UseUnscaledTime = true;
+
         /// <summary>
         /// Blend value for surface normal to user facing lerp
         /// </summary>
-        [Header("Motion")]
         public float PositionLerpTime = 0.01f;
 
         /// <summary>
@@ -105,7 +108,7 @@ public Vector3 Position
         {
             get { return transform.position; }
         }
-        
+
         public Quaternion Rotation
         {
             get { return transform.rotation; }
@@ -153,7 +156,7 @@ public bool IsVisible
             }
         }
 
-#region MonoBehaviour Functions
+        #region MonoBehaviour Functions
 
         private void Awake()
         {
@@ -177,7 +180,7 @@ private void Update()
         /// <summary>
         /// Override for enable functions
         /// </summary>
-        protected virtual void OnEnable(){}
+        protected virtual void OnEnable() { }
 
         /// <summary>
         /// Override for disable functions
@@ -194,7 +197,7 @@ private void OnDestroy()
             UnregisterManagers();
         }
 
-#endregion
+        #endregion
 
         /// <summary>
         /// Register to events from the managers the cursor needs.
@@ -302,17 +305,21 @@ protected virtual void UpdateCursorTransform()
                 }
             }
 
+            float deltaTime = UseUnscaledTime
+                ? Time.unscaledDeltaTime
+                : Time.deltaTime;
+
             // Use the lerp times to blend the position to the target position
-            transform.position = Vector3.Lerp(transform.position, targetPosition, Time.deltaTime / PositionLerpTime);
-            transform.localScale = Vector3.Lerp(transform.localScale, targetScale, Time.deltaTime / ScaleLerpTime);
-            transform.rotation = Quaternion.Lerp(transform.rotation, targetRotation, Time.deltaTime / RotationLerpTime);
+            transform.position = Vector3.Lerp(transform.position, targetPosition, deltaTime / PositionLerpTime);
+            transform.localScale = Vector3.Lerp(transform.localScale, targetScale, deltaTime / ScaleLerpTime);
+            transform.rotation = Quaternion.Lerp(transform.rotation, targetRotation, deltaTime / RotationLerpTime);
         }
 
         /// <summary>
         /// Updates the visual representation of the cursor.
         /// </summary>
         public void SetVisiblity(bool visible)
-        { 
+        {
             if (PrimaryCursorVisual != null)
             {
                 PrimaryCursorVisual.gameObject.SetActive(visible);
@@ -414,7 +421,7 @@ public virtual CursorStateEnum CheckCursorState()
                 {
                     return CursorStateEnum.Select;
                 }
-                else if(cursorState == CursorStateEnum.Select)
+                else if (cursorState == CursorStateEnum.Select)
                 {
                     return CursorStateEnum.Release;
                 }

Assets/HoloToolkit/Input/Scripts/Cursor/ObjectCursor.cs

@@ -37,6 +37,12 @@ protected override void OnEnable()
             {
                 ParentTransform = transform;
             }
+
+            for (int i = 0; i < ParentTransform.childCount; i++)
+            {
+                ParentTransform.GetChild(i).gameObject.SetActive(false);
+            }
+
             base.OnEnable();
         }
 
@@ -48,23 +54,42 @@ protected override void OnEnable()
         public override void OnCursorStateChange(CursorStateEnum state)
         {
             base.OnCursorStateChange(state);
-
             if (state != CursorStateEnum.Contextual)
             {
-                // Hide all children first
-                for(int i = 0; i < ParentTransform.childCount; i++)
+
+                // First, try to find a cursor for the current state
+                var newActive = new ObjectCursorDatum();
+                for(int cursorIndex = 0; cursorIndex < CursorStateData.Length; cursorIndex++)
                 {
-                    ParentTransform.GetChild(i).gameObject.SetActive(false);
+                    ObjectCursorDatum cursor = CursorStateData[cursorIndex];
+                    if (cursor.CursorState == state)
+                    {
+                        newActive = cursor;
+                        break;
+                    }
+                }
+
+                // If no cursor for current state is found, let the last active cursor be
+                // (any cursor is better than an invisible cursor)
+                if (newActive.Name == null)
+                {
+                    return;
                 }
 
-                // Set active any that match the current state
-                for (int i = 0; i < CursorStateData.Length; i++)
+                // If we come here, there is a cursor for the new state, 
+                // so de-activate a possible earlier active cursor
+                for(int cursorIndex = 0; cursorIndex < CursorStateData.Length; cursorIndex++)
                 {
-                    if (CursorStateData[i].CursorState == state)
+                    ObjectCursorDatum cursor = CursorStateData[cursorIndex];
+                    if (cursor.CursorObject.activeSelf)
                     {
-                        CursorStateData[i].CursorObject.SetActive(true);
+                        cursor.CursorObject.SetActive(false);
+                        break;
                     }
                 }
+
+                // ... and set the cursor for the new state active.
+                newActive.CursorObject.SetActive(true);
             }
         }
     }

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

@@ -39,7 +39,7 @@ public EditorHandData(IInputSource inputSource, uint handId)
             public bool IsFingerDownPending;
             public bool FingerStateChanged;
             public float FingerStateUpdateTimer;
-			public float FingerDownStartTime;
+            public float FingerDownStartTime;
             public readonly InputSourceEventArgs InputSourceArgs;
         }
 
@@ -56,15 +56,15 @@ public EditorHandData(IInputSource inputSource, uint handId)
         /// </summary>
         private const float FingerPressDelay = 0.07f;
 
-		/// <summary>
-		/// The maximum interval between button down and button up that will result in a clicked event.
-		/// </summary>
-		private const float MaxClickDuration = 0.5f;
+        /// <summary>
+        /// The maximum interval between button down and button up that will result in a clicked event.
+        /// </summary>
+        private const float MaxClickDuration = 0.5f;
 
-		/// <summary>
-		/// Number of fake hands supported in the editor.
-		/// </summary>
-		private const int EditorHandsCount = 2;
+        /// <summary>
+        /// Number of fake hands supported in the editor.
+        /// </summary>
+        private const int EditorHandsCount = 2;
 
         /// <summary>
         /// Array containing the hands data for the two fake hands
@@ -205,19 +205,33 @@ private void Update()
         /// </summary>
         private void UpdateHandData()
         {
+            float time;
+            float deltaTime;
+
+            if (manualHandControl.UseUnscaledTime)
+            {
+                time = Time.unscaledTime;
+                deltaTime = Time.unscaledDeltaTime;
+            }
+            else
+            {
+                time = Time.time;
+                deltaTime = Time.deltaTime;
+            }
+
             if (manualHandControl.LeftHandInView)
             {
                 GetOrAddHandData(0);
                 currentHands.Add(0);
 
-                UpdateHandState(manualHandControl.LeftHandSourceState, editorHandsData[0]);
+                UpdateHandState(manualHandControl.LeftHandSourceState, editorHandsData[0], deltaTime, time);
             }
 
             if (manualHandControl.RightHandInView)
             {
                 GetOrAddHandData(1);
                 currentHands.Add(1);
-                UpdateHandState(manualHandControl.RightHandSourceState, editorHandsData[1]);
+                UpdateHandState(manualHandControl.RightHandSourceState, editorHandsData[1], deltaTime, time);
             }
         }
 
@@ -245,7 +259,7 @@ 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>
-        private void UpdateHandState(DebugInteractionSourceState handSource, EditorHandData editorHandData)
+        private void UpdateHandState(DebugInteractionSourceState handSource, EditorHandData editorHandData, float deltaTime, float time)
         {
             // Update hand position
             Vector3 handPosition;
@@ -266,26 +280,26 @@ private void UpdateHandState(DebugInteractionSourceState handSource, EditorHandD
             editorHandData.FingerStateChanged = false;
             if (editorHandData.FingerStateUpdateTimer > 0)
             {
-                editorHandData.FingerStateUpdateTimer -= Time.deltaTime;
+                editorHandData.FingerStateUpdateTimer -= deltaTime;
                 if (editorHandData.FingerStateUpdateTimer <= 0)
                 {
                     editorHandData.IsFingerDown = editorHandData.IsFingerDownPending;
                     editorHandData.FingerStateChanged = true;
-					if (editorHandData.IsFingerDown)
-					{
-						editorHandData.FingerDownStartTime = Time.time;
-					}
+                    if (editorHandData.IsFingerDown)
+                    {
+                        editorHandData.FingerDownStartTime = time;
+                    }
                 }
             }
 
-            SendHandStateEvents(editorHandData);
+            SendHandStateEvents(editorHandData, time);
         }
 
         /// <summary>
         /// Sends the events for hand state changes.
         /// </summary>
         /// <param name="editorHandData">Hand data for which events should be sent.</param>
-        private void SendHandStateEvents(EditorHandData editorHandData)
+        private void SendHandStateEvents(EditorHandData editorHandData, float time)
         {
             // Hand moved event
             if (editorHandData.HandDelta.sqrMagnitude > 0)
@@ -305,12 +319,12 @@ private void SendHandStateEvents(EditorHandData editorHandData)
                     RaiseSourceUpEvent(editorHandData.InputSourceArgs);
 
                     // Also send click event when using this hands replacement input
-					if (Time.time - editorHandData.FingerDownStartTime < MaxClickDuration)
-					{
+                    if (time - editorHandData.FingerDownStartTime < MaxClickDuration)
+                    {
                         // We currently only support single taps in editor
                         SourceClickEventArgs args = new SourceClickEventArgs(this, editorHandData.HandId, 1);
-						RaiseSourceClickedEvent(args);
-					}
+                        RaiseSourceClickedEvent(args);
+                    }
                 }
             }
         }

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

@@ -52,6 +52,9 @@ public SourceData(IInputSource inputSource, uint sourceId)
         /// </summary>
         private const float SourcePressDelay = 0.07f;
 
+        [Tooltip("Use unscaled time. This is useful for games that have a pause mechanism or otherwise adjust the game timescale.")]
+        public bool UseUnscaledTime = true;
+
         /// <summary>
         /// Dictionary linking each source ID to its data.
         /// </summary>
@@ -106,7 +109,7 @@ public override bool TryGetOrientation(uint sourceId, out Quaternion orientation
             orientation = Quaternion.identity;
             return false;
         }
-        
+
         private void Update()
         {
             newSources.Clear();
@@ -180,7 +183,11 @@ private void UpdateSourceState(InteractionSourceState interactionSource, SourceD
             sourceData.SourceStateChanged = false;
             if (sourceData.SourceStateUpdateTimer >= 0)
             {
-                sourceData.SourceStateUpdateTimer -= Time.deltaTime;
+                float deltaTime = UseUnscaledTime
+                    ? Time.unscaledDeltaTime
+                    : Time.deltaTime;
+
+                sourceData.SourceStateUpdateTimer -= deltaTime;
                 if (sourceData.SourceStateUpdateTimer < 0)
                 {
                     sourceData.IsSourceDown = sourceData.IsSourceDownPending;