Merge branch 'mrtk_development' into vNEXT-EasyManagerAccess

# Conflicts:
#	Assets/MixedRealityToolkit/_Core/Managers/MixedRealityManager.cs

Author: StephenHodgson

.gitignore

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

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

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

@@ -0,0 +1,76 @@
+// 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 MemoryUseTracker
+    {
+        private Process currentProcess = Process.GetCurrentProcess();
+        private readonly MemoryReading[] memoryReadings;
+        private int index = 0;
+
+        private MemoryReading sumReading = new MemoryReading();
+
+        public MemoryUseTracker()
+        {
+            memoryReadings = new MemoryReading[10];
+
+            for (int i = 0; i < memoryReadings.Length; i++)
+            {
+                memoryReadings[i] = new MemoryReading();
+            }
+        }
+
+
+        public MemoryReading GetReading()
+        {
+            var reading = memoryReadings[index];
+
+            reading.VirtualMemoryInBytes = currentProcess.VirtualMemorySize64;
+            reading.WorkingSetMemoryInBytes = currentProcess.WorkingSet64;
+            reading.GCMemoryInBytes = GC.GetTotalMemory(false);
+
+            index = (index + 1) % memoryReadings.Length;
+
+            return memoryReadings.Aggregate(sumReading.Reset(), (a, b) => a + b) / memoryReadings.Length;
+        }
+
+        public struct MemoryReading
+        {
+            public long VirtualMemoryInBytes { get; set; }
+            public long WorkingSetMemoryInBytes { get; set; }
+            public long GCMemoryInBytes { get; set; }
+
+            public MemoryReading Reset()
+            {
+                VirtualMemoryInBytes = 0;
+                WorkingSetMemoryInBytes = 0;
+                GCMemoryInBytes = 0;
+
+                return this;
+            }
+
+            public static MemoryReading operator +(MemoryReading a, MemoryReading b)
+            {
+                a.VirtualMemoryInBytes += b.VirtualMemoryInBytes;
+                a.WorkingSetMemoryInBytes += b.WorkingSetMemoryInBytes;
+                a.GCMemoryInBytes += b.GCMemoryInBytes;
+
+                return a;
+            }
+
+            public static MemoryReading operator /(MemoryReading a, int b)
+            {
+                a.VirtualMemoryInBytes /= b;
+                a.WorkingSetMemoryInBytes /= b;
+                a.GCMemoryInBytes /= b;
+
+                return a;
+            }
+        }
+    }
+}