Merge branch 'mrtk_development' into vNEXT-MouseNotifications

# Conflicts:
#	Assets/MixedRealityToolkit-SDK/Features/UX/Scripts/Pointers/BaseControllerPointer.cs

Author: StephenHodgson

.gitignore

@@ -54,3 +54,4 @@ Assets/ThirdParty/
 Assets/ThirdParty.meta
 Assets/TextMesh Pro.meta
 Assets/TextMesh Pro/
+--Version/

Assets/MixedRealityToolkit-Examples/Demos/Boundary/Scripts/BoundaryVisualizationDemo.cs

@@ -7,6 +7,7 @@
 using Microsoft.MixedReality.Toolkit.Core.Managers;
 using Microsoft.MixedReality.Toolkit.Core.Utilities;
 using System.Collections.Generic;
+using Microsoft.MixedReality.Toolkit.Core.Utilities.Async;
 using UnityEngine;
 using UnityEngine.Experimental.XR;
 
@@ -17,9 +18,6 @@ namespace Microsoft.MixedReality.Toolkit.Examples.Demos
     /// </summary>
     public class BoundaryVisualizationDemo : MonoBehaviour, IMixedRealityBoundaryHandler
     {
-        private IMixedRealityBoundarySystem BoundaryManager => boundaryManager ?? (boundaryManager = MixedRealityManager.Instance.GetManager<IMixedRealityBoundarySystem>());
-        private IMixedRealityBoundarySystem boundaryManager = null;
-
         private GameObject markerParent;
         private readonly List<GameObject> markers = new List<GameObject>();
 
@@ -50,7 +48,7 @@ private void Awake()
         private void Start()
         {
 
-            if (BoundaryManager != null)
+            if (MixedRealityManager.BoundarySystem != null)
             {
                 if (markers.Count == 0)
                 {
@@ -61,24 +59,25 @@ private void Start()
 
         private void Update()
         {
-            if (BoundaryManager != null)
+            if (MixedRealityManager.BoundarySystem != null)
             {
-                BoundaryManager.ShowFloor = showFloor;
-                BoundaryManager.ShowPlayArea = showPlayArea;
-                BoundaryManager.ShowTrackedArea = showTrackedArea;
-                BoundaryManager.ShowBoundaryWalls = showBoundaryWalls;
-                BoundaryManager.ShowBoundaryCeiling = showBoundaryCeiling;
+                MixedRealityManager.BoundarySystem.ShowFloor = showFloor;
+                MixedRealityManager.BoundarySystem.ShowPlayArea = showPlayArea;
+                MixedRealityManager.BoundarySystem.ShowTrackedArea = showTrackedArea;
+                MixedRealityManager.BoundarySystem.ShowBoundaryWalls = showBoundaryWalls;
+                MixedRealityManager.BoundarySystem.ShowBoundaryCeiling = showBoundaryCeiling;
             }
         }
 
-        private void OnEnable()
+        private async void OnEnable()
         {
-            BoundaryManager.Register(gameObject);
+            await new WaitUntil(() => MixedRealityManager.BoundarySystem != null);
+            MixedRealityManager.BoundarySystem.Register(gameObject);
         }
 
         private void OnDisable()
         {
-            BoundaryManager.Unregister(gameObject);
+            MixedRealityManager.BoundarySystem?.Unregister(gameObject);
         }
 
         #endregion MonoBehaviour Implementation
@@ -105,7 +104,7 @@ private void AddMarkers()
             float widthRect;
             float heightRect;
 
-            if (!BoundaryManager.TryGetRectangularBoundsParams(out centerRect, out angleRect, out widthRect, out heightRect))
+            if (!MixedRealityManager.BoundarySystem.TryGetRectangularBoundsParams(out centerRect, out angleRect, out widthRect, out heightRect))
             {
                 // If we have no boundary manager or rectangular bounds we will show no indicators
                 return;
@@ -136,12 +135,12 @@ private void AddMarkers()
 
                     Material material = null;
                     // Check inscribed rectangle first
-                    if (BoundaryManager.Contains(position, Boundary.Type.PlayArea))
+                    if (MixedRealityManager.BoundarySystem.Contains(position, Boundary.Type.PlayArea))
                     {
                         material = visualizationProfile.PlayAreaMaterial;
                     }
                     // Then check geometry
-                    else if (BoundaryManager.Contains(position, Boundary.Type.TrackedArea))
+                    else if (MixedRealityManager.BoundarySystem.Contains(position, Boundary.Type.TrackedArea))
                     {
                         material = visualizationProfile.TrackedAreaMaterial;
                     }

Assets/MixedRealityToolkit-SDK/Features/Diagnostics.meta

@@ -0,0 +1,40 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+using System;
+using System.Linq;
+using System.Diagnostics;
+
+namespace Microsoft.MixedReality.Toolkit.SDK.DiagnosticsSystem
+{
+    internal class CpuUseTracker
+    {
+        private TimeSpan? processorTime;
+        private Process currentProcess = Process.GetCurrentProcess();
+        private TimeSpan[] readings = new TimeSpan[20];
+        int index = 0;
+
+        public void Reset()
+        {
+            processorTime = null;
+        }
+
+        public double GetReadingInMs()
+        {
+            if (!processorTime.HasValue)
+            {
+                processorTime = currentProcess.TotalProcessorTime;
+                return 0;
+            }
+
+            var currentTime = currentProcess.TotalProcessorTime;
+            var diff = currentTime - processorTime.Value;
+            processorTime = currentTime;
+
+            readings[index] = diff;
+            index = (index + 1) % readings.Length;
+
+            return Math.Round(readings.Average(t => t.TotalMilliseconds), 2);
+        }
+    }
+}

Assets/MixedRealityToolkit-SDK/Features/Diagnostics/CpuUseTracker.cs

@@ -0,0 +1,126 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+using Microsoft.MixedReality.Toolkit.Core.EventDatum.Diagnostics;
+using Microsoft.MixedReality.Toolkit.Core.Interfaces.Diagnostics;
+using System;
+using System.Text;
+using UnityEngine;
+
+namespace Microsoft.MixedReality.Toolkit.SDK.DiagnosticsSystem
+{
+    /// <summary>
+    /// Behavior class for showing Diagnostic information. Implements <see cref="IMixedRealityDiagnosticsHandler"/>
+    /// to manage setting updates. 
+    /// </summary>
+    public class DiagnosticsHandler : MonoBehaviour, IMixedRealityDiagnosticsHandler
+    {
+        private bool showCpu;
+        private bool ShowCpu
+        {
+            get { return showCpu; }
+            set
+            {
+                if (showCpu != value)
+                {
+                    showCpu = value;
+                    if (!showCpu)
+                    {
+                        cpuUseTracker.Reset();
+                    }
+                }
+            }
+        }
+
+        private bool ShowFps { get; set; }
+        private bool ShowMemory { get; set; }
+
+        private bool isShowingInformation;
+
+        private CpuUseTracker cpuUseTracker = new CpuUseTracker();
+        private MemoryUseTracker memoryUseTracker = new MemoryUseTracker();
+        private FpsUseTracker fpsUseTracker = new FpsUseTracker();
+        StringBuilder displayText = new StringBuilder();
+
+        private GUIStyle style = new GUIStyle()
+        {
+            alignment = TextAnchor.UpperLeft,
+            normal = new GUIStyleState()
+            {
+                textColor = new Color(0, 0, 0.5f, 1)
+            }
+        };
+
+        private Rect rect = new Rect();
+
+        /// <summary>
+        /// Updates the diagnostic settings
+        /// </summary>
+        /// <param name="eventData"><see cref="DiagnosticsEventData"/> coming in</param>
+        public void OnDiagnosticSettingsChanged(DiagnosticsEventData eventData)
+        {
+            this.ShowCpu = eventData.ShowCpu;
+            this.ShowMemory = eventData.ShowMemory;
+            this.ShowFps = eventData.ShowFps;
+            this.enabled = eventData.Visible;
+        }
+
+        private void UpdateIsShowingInformation()
+        {
+            isShowingInformation = ShowCpu ||
+                                   ShowFps ||
+                                   ShowMemory;
+        }
+        
+        private void Update()
+        {
+            UpdateIsShowingInformation();
+
+            if (!isShowingInformation)
+            {
+                return;
+            }
+
+            displayText.Clear();
+
+            if (ShowFps)
+            {
+                var timeInSeconds = fpsUseTracker.GetFpsInSeconds();
+                displayText.AppendLine($"Fps: {Math.Round(1.0f / timeInSeconds, 2)}");
+                displayText.AppendLine($"Frame Time: {Math.Round(timeInSeconds * 1000, 2)} ms");
+            }
+
+            if (ShowCpu)
+            {
+                var reading = cpuUseTracker.GetReadingInMs();
+                displayText.AppendLine($"CPU Time: {reading} ms");
+            }
+
+            if (ShowMemory)
+            {
+                var reading = memoryUseTracker.GetReading();
+                displayText.AppendLine($"Memory: {Math.Round(BytesToMB(reading.GCMemoryInBytes), 2)} MB");
+            }
+        }
+
+        private void OnGUI()
+        {
+            if (!isShowingInformation || displayText.Length == 0)
+            {
+                return;
+            }
+
+            int w = Screen.width, h = Screen.height;
+
+            rect.Set(0, 0, w, h * 2 / 100);
+
+            style.fontSize = h * 2 / 100;
+            GUI.Label(rect, displayText.ToString(), style); 
+        }
+
+        private static float BytesToMB(long bytes)
+        {
+            return bytes / (float)(1024 * 1024);
+        }
+    }
+}

Assets/MixedRealityToolkit-SDK/Features/Diagnostics/CpuUseTracker.cs.meta

@@ -0,0 +1,22 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+using System.Linq;
+using UnityEngine;
+
+namespace Microsoft.MixedReality.Toolkit.SDK.DiagnosticsSystem
+{
+    internal class FpsUseTracker
+    {
+        private int index = 0;
+        private float[] timings = new float[10];
+
+        public float GetFpsInSeconds()
+        {
+            timings[index] = Time.unscaledDeltaTime;
+            index = (index + 1) % timings.Length;
+
+            return timings.Average();
+        }
+    }
+}