Merge pull request #10316 from keveleigh/formatting

keveleigh · keveleigh · commit 08bfe950069f · 2021-11-17T15:28:56.000-08:00
Assorted formatting and minor changes accumulated in my working dir
diff --git a/Assets/MRTK/Core/Providers/Hands/HandRay/HandRay.cs b/Assets/MRTK/Core/Providers/Hands/HandRay/HandRay.cs
@@ -55,8 +55,8 @@ public bool ShouldShowRay
         private const float DynamicPivotBaseY = -0.1f, DynamicPivotMultiplierY = 0.65f, DynamicPivotMinY = -0.6f, DynamicPivotMaxY = -0.2f;
         private const float DynamicPivotBaseX = 0.03f, DynamicPivotMultiplierX = 0.65f, DynamicPivotMinX = 0.08f, DynamicPivotMaxX = 0.15f;
         private const float HeadToPivotOffsetZ = 0.08f;
-        private readonly float CursorBeamBackwardTolerance = 0.5f;
-        private readonly float CursorBeamUpTolerance = 0.8f;
+        private const float CursorBeamBackwardTolerance = 0.5f;
+        private const float CursorBeamUpTolerance = 0.8f;
 
         // Smoothing factor for ray stabilization.
         private const float StabilizedRayHalfLife = 0.01f;
diff --git a/Assets/MRTK/Core/Providers/InputSimulation/SimulatedArticulatedHandPoses.cs b/Assets/MRTK/Core/Providers/InputSimulation/SimulatedArticulatedHandPoses.cs
@@ -15,17 +15,17 @@ public static class SimulatedArticulatedHandPoses
     {
         private static readonly Dictionary<GestureId, string> GesturePoseJSONMapping = new Dictionary<GestureId, string>()
         {
-            { GestureId.Flat, ArticulatedHandPose_Flat},
-            { GestureId.Grab, ArticulatedHandPose_Grab},
-            { GestureId.Open, ArticulatedHandPose_Open},
-            { GestureId.OpenSteadyGrabPoint, ArticulatedHandPose_OpenSteadyGrabPoint},
-            { GestureId.Pinch, ArticulatedHandPose_Pinch},
-            { GestureId.PinchSteadyWrist, ArticulatedHandPose_PinchSteadyWrist},
+            { GestureId.Flat, ArticulatedHandPose_Flat },
+            { GestureId.Grab, ArticulatedHandPose_Grab },
+            { GestureId.Open, ArticulatedHandPose_Open },
+            { GestureId.OpenSteadyGrabPoint, ArticulatedHandPose_OpenSteadyGrabPoint },
+            { GestureId.Pinch, ArticulatedHandPose_Pinch },
+            { GestureId.PinchSteadyWrist, ArticulatedHandPose_PinchSteadyWrist },
             { GestureId.Poke, ArticulatedHandPose_Poke },
-            { GestureId.ThumbsUp, ArticulatedHandPose_ThumbsUp},
-            { GestureId.Victory, ArticulatedHandPose_Victory},
-            { GestureId.TeleportStart, ArticulatedHandPose_TeleportStart},
-            { GestureId.TeleportEnd, ArticulatedHandPose_TeleportEnd}
+            { GestureId.ThumbsUp, ArticulatedHandPose_ThumbsUp },
+            { GestureId.Victory, ArticulatedHandPose_Victory },
+            { GestureId.TeleportStart, ArticulatedHandPose_TeleportStart },
+            { GestureId.TeleportEnd, ArticulatedHandPose_TeleportEnd }
         };
 
         private static Dictionary<GestureId, ArticulatedHandPose> gesturePoses;
diff --git a/Assets/MRTK/Core/Utilities/CameraFOVChecker.cs b/Assets/MRTK/Core/Utilities/CameraFOVChecker.cs
@@ -13,9 +13,8 @@ namespace Microsoft.MixedReality.Toolkit
     /// </summary>
     public static class CameraFOVChecker
     {
-
         // Help to clear caches when new frame runs
-        static private int inFOVLastCalculatedFrame = -1;
+        private static int inFOVLastCalculatedFrame = -1;
         // Map from grabbable => is the grabbable in FOV for this frame. Cleared every frame
         private static Dictionary<Tuple<Collider, Camera>, bool> inFOVColliderCache = new Dictionary<Tuple<Collider, Camera>, bool>();
         // List of corners shared across all sphere pointer query instances --
@@ -39,7 +38,7 @@ public static bool IsInFOVCached(this Camera cam, Collider myCollider)
             }
 
             Tuple<Collider, Camera> cameraColliderPair = new Tuple<Collider, Camera>(myCollider, cam);
-            bool result = false;
+            bool result;
             if (inFOVLastCalculatedFrame != Time.frameCount)
             {
                 inFOVColliderCache.Clear();
@@ -53,7 +52,6 @@ public static bool IsInFOVCached(this Camera cam, Collider myCollider)
             inFOVBoundsCornerPoints.Clear();
             BoundsExtensions.GetColliderBoundsPoints(myCollider, inFOVBoundsCornerPoints, 0);
 
-
             float xMin = float.MaxValue, yMin = float.MaxValue, zMin = float.MaxValue;
             float xMax = float.MinValue, yMax = float.MinValue, zMax = float.MinValue;
             for (int i = 0; i < inFOVBoundsCornerPoints.Count; i++)
diff --git a/Assets/MRTK/Core/Utilities/Editor/Preferences/SerializableDictionary.cs b/Assets/MRTK/Core/Utilities/Editor/Preferences/SerializableDictionary.cs
@@ -22,7 +22,7 @@ public class SerializableDictionary<TKey, TValue> : Dictionary<TKey, TValue>, IS
         [SerializeField]
         private List<TValue> values = new List<TValue>();
 
-        public void OnBeforeSerialize()
+        void ISerializationCallbackReceiver.OnBeforeSerialize()
         {
             keys.Clear();
             values.Clear();
@@ -34,7 +34,7 @@ public void OnBeforeSerialize()
             }
         }
 
-        public void OnAfterDeserialize()
+        void ISerializationCallbackReceiver.OnAfterDeserialize()
         {
             this.Clear();
 
diff --git a/Assets/MRTK/Providers/WindowsMixedReality/Shared/WindowsMixedRealityHandMeshProvider.cs b/Assets/MRTK/Providers/WindowsMixedReality/Shared/WindowsMixedRealityHandMeshProvider.cs
@@ -6,7 +6,6 @@
 using System;
 
 #if WINDOWS_UWP
-using System.Threading.Tasks;
 using Unity.Profiling;
 using UnityEngine;
 using Windows.Perception.People;
diff --git a/Assets/MRTK/SDK/Features/UX/Scripts/Cursors/FingerCursor.cs b/Assets/MRTK/SDK/Features/UX/Scripts/Cursors/FingerCursor.cs
@@ -227,10 +227,10 @@ private void TranslateFromTipToPad(Transform target, Vector3 fingerPosition, Vec
 
             // Lerping an angular measurement from 0 degrees (default cursor position at tip of finger) to
             // 90 degrees (a new position on the fingertip pad) around the fingertip's X axis.
-            Quaternion degreesRelative = Quaternion.AngleAxis((1f - t) * 90f * (1f - fingerSurfaceDot), indexFingerRingRenderer.transform.right);
+            Quaternion degreesRelative = Quaternion.AngleAxis((1f - t) * 90f * (1f - fingerSurfaceDot), target.right);
 
             Vector3 tipToPadPosition = fingerPosition + degreesRelative * tipOffset;
-            indexFingerRingRenderer.transform.position = tipToPadPosition;
+            target.position = tipToPadPosition;
         }
     }
 }
diff --git a/Assets/MRTK/Services/InputSystem/FocusProvider.cs b/Assets/MRTK/Services/InputSystem/FocusProvider.cs
@@ -649,8 +649,7 @@ public bool TryGetFocusDetails(IMixedRealityPointer pointer, out FocusDetails fo
         {
             using (TryGetFocusDetailsPerfMarker.Auto())
             {
-                PointerData pointerData;
-                if (TryGetPointerData(pointer, out pointerData))
+                if (TryGetPointerData(pointer, out PointerData pointerData))
                 {
                     focusDetails = pointerData.Details;
                     return true;
@@ -766,8 +765,7 @@ private void CleanUpUiRaycastCamera()
         public bool IsPointerRegistered(IMixedRealityPointer pointer)
         {
             Debug.Assert(pointer.PointerId != 0, $"{pointer} does not have a valid pointer id!");
-            PointerData pointerData;
-            return TryGetPointerData(pointer, out pointerData);
+            return TryGetPointerData(pointer, out _);
         }
 
         private static readonly ProfilerMarker RegisterPointerPerfMarker = new ProfilerMarker("[MRTK] FocusProvider.RegisterPointer");
@@ -861,8 +859,7 @@ public bool UnregisterPointer(IMixedRealityPointer pointer)
             {
                 Debug.Assert(pointer.PointerId != 0, $"{pointer} does not have a valid pointer id!");
 
-                PointerData pointerData;
-                if (!TryGetPointerData(pointer, out pointerData)) { return false; }
+                if (!TryGetPointerData(pointer, out PointerData pointerData)) { return false; }
 
                 // Raise focus events if needed.
                 if (pointerData.CurrentPointerTarget != null)
diff --git a/Assets/MRTK/StandardAssets/Shaders/MixedRealityStandard.shader b/Assets/MRTK/StandardAssets/Shaders/MixedRealityStandard.shader
@@ -277,7 +277,7 @@ Shader "Mixed Reality Toolkit/Standard"
                 UNITY_VERTEX_INPUT_INSTANCE_ID
             };
 
-            struct v2f 
+            struct v2f
             {
                 float4 position : SV_POSITION;
 #if defined(_BORDER_LIGHT)
@@ -454,7 +454,7 @@ Shader "Mixed Reality Toolkit/Standard"
 
 #if defined(_ROUND_CORNERS)
 #if defined(_INDEPENDENT_CORNERS)
-            float4 _RoundCornersRadius; 
+            float4 _RoundCornersRadius;
 #else
             fixed _RoundCornerRadius;
 #endif
@@ -666,7 +666,7 @@ Shader "Mixed Reality Toolkit/Standard"
 
 #if defined(_BORDER_LIGHT) || defined(_ROUND_CORNERS)
                 o.uv.xy = TRANSFORM_TEX(v.uv, _MainTex);
-   
+
                 float minScale = min(min(o.scale.x, o.scale.y), o.scale.z);
 
 #if defined(_BORDER_LIGHT) 
@@ -796,8 +796,8 @@ Shader "Mixed Reality Toolkit/Standard"
                 fixed4 albedo = fixed4(1.0, 1.0, 1.0, 1.0);
 #else
 #if defined(_TRIPLANAR_MAPPING)
-                fixed4 albedo = tex2D(_MainTex, uvX) * triplanarBlend.x + 
-                                tex2D(_MainTex, uvY) * triplanarBlend.y + 
+                fixed4 albedo = tex2D(_MainTex, uvX) * triplanarBlend.x +
+                                tex2D(_MainTex, uvY) * triplanarBlend.y +
                                 tex2D(_MainTex, uvZ) * triplanarBlend.z;
 #else
 #if defined(_USE_SSAA)
@@ -1011,13 +1011,13 @@ Shader "Mixed Reality Toolkit/Standard"
 #if defined(_BORDER_LIGHT)
                 fixed borderValue;
 #if defined(_ROUND_CORNERS)
-                fixed borderMargin = _RoundCornerMargin  + _BorderWidth * 0.5;
+                fixed borderMargin = _RoundCornerMargin + _BorderWidth * 0.5;
 
                 cornerCircleRadius = saturate(max(currentCornerRadius - borderMargin, 0.01)) * i.scale.z;
 
                 cornerCircleDistance = halfScale - (borderMargin * i.scale.z) - cornerCircleRadius;
 
-                borderValue =  1.0 - RoundCornersSmooth(roundCornerPosition, cornerCircleDistance, cornerCircleRadius);
+                borderValue = 1.0 - RoundCornersSmooth(roundCornerPosition, cornerCircleDistance, cornerCircleRadius);
 #else
                 borderValue = max(smoothstep(i.uv.z - _EdgeSmoothingValue, i.uv.z + _EdgeSmoothingValue, distanceToEdge.x),
                                   smoothstep(i.uv.w - _EdgeSmoothingValue, i.uv.w + _EdgeSmoothingValue, distanceToEdge.y));
@@ -1150,7 +1150,7 @@ Shader "Mixed Reality Toolkit/Standard"
                 // Environment coloring.
 #if defined(_ENVIRONMENT_COLORING)
                 fixed3 environmentColor = incident.x * incident.x * _EnvironmentColorX +
-                                          incident.y * incident.y * _EnvironmentColorY + 
+                                          incident.y * incident.y * _EnvironmentColorY +
                                           incident.z * incident.z * _EnvironmentColorZ;
                 output.rgb += environmentColor * max(0.0, dot(incident, worldNormal) + _EnvironmentColorThreshold) * _EnvironmentColorIntensity;
 
@@ -1253,7 +1253,7 @@ Shader "Mixed Reality Toolkit/Standard"
             ENDCG
         }
     }
-    
+
     Fallback "Hidden/InternalErrorShader"
     CustomEditor "Microsoft.MixedReality.Toolkit.Editor.MixedRealityStandardShaderGUI"
 }
diff --git a/Assets/MRTK/Tests/TestUtilities/TestUtilities.cs b/Assets/MRTK/Tests/TestUtilities/TestUtilities.cs
@@ -1,31 +1,30 @@
 ﻿// Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-using System.Collections.Generic;
-using System.Linq;
-using System.Reflection;
 using UnityEngine;
-using UnityEngine.SceneManagement;
 
 #if UNITY_EDITOR
 using Microsoft.MixedReality.Toolkit.Utilities.Editor;
 using Microsoft.MixedReality.Toolkit.Editor;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
 using UnityEditor;
 using UnityEditor.SceneManagement;
-#endif
-
-#if WINDOWS_UWP
-using UnityEngine.Assertions;
+using UnityEngine.SceneManagement;
 #endif
 
 namespace Microsoft.MixedReality.Toolkit.Tests
 {
     public static class TestUtilities
     {
-        const string primaryTestSceneTemporarySavePath = "Assets/__temp_primary_test_scene.unity";
-        const string additiveTestSceneTemporarySavePath = "Assets/__temp_additive_test_scene_#.unity";
+#if UNITY_EDITOR
+        private const string PrimaryTestSceneTemporarySavePath = "Assets/__temp_primary_test_scene.unity";
+        private const string AdditiveTestSceneTemporarySavePath = "Assets/__temp_additive_test_scene_#.unity";
+
         public static Scene primaryTestScene;
         public static Scene[] additiveTestScenes = System.Array.Empty<Scene>();
+#endif // UNITY_EDITOR
 
         /// <summary>
         /// Destroys all scene assets that were created over the course of testing.
@@ -37,15 +36,15 @@ public static void EditorTearDownScenes()
             if (!EditorApplication.isPlaying)
             {
                 // If any of our scenes were saved, tear down the assets
-                SceneAsset primaryTestSceneAsset = AssetDatabase.LoadAssetAtPath<SceneAsset>(primaryTestSceneTemporarySavePath);
+                SceneAsset primaryTestSceneAsset = AssetDatabase.LoadAssetAtPath<SceneAsset>(PrimaryTestSceneTemporarySavePath);
                 if (primaryTestSceneAsset != null)
                 {
-                    AssetDatabase.DeleteAsset(primaryTestSceneTemporarySavePath);
+                    AssetDatabase.DeleteAsset(PrimaryTestSceneTemporarySavePath);
                 }
 
                 for (int i = 0; i < additiveTestScenes.Length; i++)
                 {
-                    string path = additiveTestSceneTemporarySavePath.Replace("#", i.ToString());
+                    string path = AdditiveTestSceneTemporarySavePath.Replace("#", i.ToString());
                     SceneAsset additiveTestSceneAsset = AssetDatabase.LoadAssetAtPath<SceneAsset>(path);
                     if (additiveTestSceneAsset != null)
                     {
@@ -54,7 +53,7 @@ public static void EditorTearDownScenes()
                 }
                 AssetDatabase.Refresh();
             }
-#endif
+#endif // UNITY_EDITOR
         }
 
         /// <summary>
@@ -72,20 +71,17 @@ public static void EditorCreateScenes(int numScenesToCreate = 1)
 
             List<Scene> additiveTestScenesList = new List<Scene>();
 
-            if (numScenesToCreate == 1)
-            {   // No need to save this scene, we're just creating one
-                primaryTestScene = EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects, NewSceneMode.Single);
-            }
-            else
+            // Make the first scene single so it blows away previously loaded scenes
+            primaryTestScene = EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects, NewSceneMode.Single);
+
+            if (numScenesToCreate != 1)
             {
-                // Make the first scene single so it blows away previously loaded scenes
-                primaryTestScene = EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects, NewSceneMode.Single);
                 // Save the scene (temporarily) so we can load additively on top of it
-                EditorSceneManager.SaveScene(primaryTestScene, primaryTestSceneTemporarySavePath);
+                EditorSceneManager.SaveScene(primaryTestScene, PrimaryTestSceneTemporarySavePath);
 
                 for (int i = 1; i < numScenesToCreate; i++)
                 {
-                    string path = additiveTestSceneTemporarySavePath.Replace("#", additiveTestScenesList.Count.ToString());
+                    string path = AdditiveTestSceneTemporarySavePath.Replace("#", additiveTestScenesList.Count.ToString());
                     // Create subsequent scenes additively
                     Scene additiveScene = EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects, NewSceneMode.Additive);
                     additiveTestScenesList.Add(additiveScene);
@@ -95,7 +91,7 @@ public static void EditorCreateScenes(int numScenesToCreate = 1)
             }
 
             additiveTestScenes = additiveTestScenesList.ToArray();
-#endif
+#endif // UNITY_EDITOR
         }
 
         /// <summary>
@@ -340,25 +336,25 @@ public static T GetDefaultMixedRealityProfile<T>() where T : BaseMixedRealityPro
         public static void AssertAboutEqual(Vector3 actual, Vector3 expected, string message, float tolerance = 0.01f)
         {
             var dist = (actual - expected).magnitude;
-            Debug.Assert(dist < tolerance, $"{message}, expected {expected.ToString("0.000")}, was {actual.ToString("0.000")}");
+            Debug.Assert(dist < tolerance, $"{message}, expected {expected:0.000}, was {actual:0.000}");
         }
 
         public static void AssertAboutEqual(Quaternion actual, Quaternion expected, string message, float tolerance = 0.01f)
         {
             var angle = Quaternion.Angle(actual, expected);
-            Debug.Assert(angle < tolerance, $"{message}, expected {expected.ToString("0.000")}, was {actual.ToString("0.000")}");
+            Debug.Assert(angle < tolerance, $"{message}, expected {expected:0.000}, was {actual:0.000}");
         }
 
         public static void AssertNotAboutEqual(Vector3 val1, Vector3 val2, string message, float tolerance = 0.01f)
         {
             var dist = (val1 - val2).magnitude;
-            Debug.Assert(dist >= tolerance, $"{message}, val1 {val1.ToString("0.000")} almost equals val2 {val2.ToString("0.000")}");
+            Debug.Assert(dist >= tolerance, $"{message}, val1 {val1:0.000} almost equals val2 {val2:0.000}");
         }
 
         public static void AssertNotAboutEqual(Quaternion val1, Quaternion val2, string message, float tolerance = 0.01f)
         {
             var angle = Quaternion.Angle(val1, val2);
-            Debug.Assert(angle >= tolerance, $"{message}, val1 {val1.ToString("0.000")} almost equals val2 {val2.ToString("0.000")}");
+            Debug.Assert(angle >= tolerance, $"{message}, val1 {val1:0.000} almost equals val2 {val2:0.000}");
         }
 
         /// <summary>
@@ -443,21 +439,21 @@ private static void UpdateTestScriptIcons()
 
                     MonoScript script = AssetDatabase.LoadAssetAtPath<MonoScript>(scriptPath);
 
-                    Texture2D currentIcon = getIconForObject?.Invoke(null, new object[] { script }) as Texture2D;
+                    Texture2D currentIcon = GetIconForObject?.Invoke(null, new object[] { script }) as Texture2D;
                     if (currentIcon == null || !currentIcon.Equals(icon))
                     {
-                        setIconForObject?.Invoke(null, new object[] { script, icon });
-                        copyMonoScriptIconToImporters?.Invoke(null, new object[] { script });
+                        SetIconForObject?.Invoke(null, new object[] { script, icon });
+                        CopyMonoScriptIconToImporters?.Invoke(null, new object[] { script });
                     }
                 }
             }
 
             EditorUtility.ClearProgressBar();
         }
 
-        private static readonly MethodInfo getIconForObject = typeof(EditorGUIUtility).GetMethod("GetIconForObject", BindingFlags.Static | BindingFlags.NonPublic);
-        private static readonly MethodInfo setIconForObject = typeof(EditorGUIUtility).GetMethod("SetIconForObject", BindingFlags.Static | BindingFlags.NonPublic);
-        private static readonly MethodInfo copyMonoScriptIconToImporters = typeof(MonoImporter).GetMethod("CopyMonoScriptIconToImporters", BindingFlags.Static | BindingFlags.NonPublic);
+        private static readonly MethodInfo GetIconForObject = typeof(EditorGUIUtility).GetMethod("GetIconForObject", BindingFlags.Static | BindingFlags.NonPublic);
+        private static readonly MethodInfo SetIconForObject = typeof(EditorGUIUtility).GetMethod("SetIconForObject", BindingFlags.Static | BindingFlags.NonPublic);
+        private static readonly MethodInfo CopyMonoScriptIconToImporters = typeof(MonoImporter).GetMethod("CopyMonoScriptIconToImporters", BindingFlags.Static | BindingFlags.NonPublic);
 #endif
     }
 }
diff --git a/Assets/MRTK/Tools/OptimizeWindow/MixedRealityOptimizeWindow.cs b/Assets/MRTK/Tools/OptimizeWindow/MixedRealityOptimizeWindow.cs
@@ -45,17 +45,17 @@ private long TotalPolyCount
 
         private string TotalPolyCountStr
         {
-            get => $"Total Scene PolyCount: {TotalPolyCount.ToString("N0")} ";
+            get => $"Total Scene PolyCount: {TotalPolyCount:N0} ";
         }
 
         private string TotalActivePolyCountStr
         {
-            get => $"Total PolyCount (Active): {totalActivePolyCount.ToString("N0")} ";
+            get => $"Total PolyCount (Active): {totalActivePolyCount:N0} ";
         }
 
         private string TotalInactivePolyCountStr
         {
-            get => $"Total PolyCount (Inactive): {totalInActivePolyCount.ToString("N0")} ";
+            get => $"Total PolyCount (Inactive): {totalInActivePolyCount:N0} ";
         }
 
         private MeshFilter[] MeshesOrderedByPolyCountDesc;

Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ public class SerializableDictionary<TKey, TValue> : Dictionary<TKey, TValue>, IS`
`22`	`22`	`[SerializeField]`
`23`	`23`	`private List<TValue> values = new List<TValue>();`
`24`	`24`
`25`		`- public void OnBeforeSerialize()`
	`25`	`+ void ISerializationCallbackReceiver.OnBeforeSerialize()`
`26`	`26`	`{`
`27`	`27`	`keys.Clear();`
`28`	`28`	`values.Clear();`
`@@ -34,7 +34,7 @@ public void OnBeforeSerialize()`
`34`	`34`	`}`
`35`	`35`	`}`
`36`	`36`
`37`		`- public void OnAfterDeserialize()`
	`37`	`+ void ISerializationCallbackReceiver.OnAfterDeserialize()`
`38`	`38`	`{`
`39`	`39`	`this.Clear();`
`40`	`40`
Original file line number	Diff line number	Diff line change
`@@ -227,10 +227,10 @@ private void TranslateFromTipToPad(Transform target, Vector3 fingerPosition, Vec`
`227`	`227`
`228`	`228`	`// Lerping an angular measurement from 0 degrees (default cursor position at tip of finger) to`
`229`	`229`	`// 90 degrees (a new position on the fingertip pad) around the fingertip's X axis.`
`230`		`- Quaternion degreesRelative = Quaternion.AngleAxis((1f - t) * 90f * (1f - fingerSurfaceDot), indexFingerRingRenderer.transform.right);`
	`230`	`+ Quaternion degreesRelative = Quaternion.AngleAxis((1f - t) * 90f * (1f - fingerSurfaceDot), target.right);`
`231`	`231`
`232`	`232`	`Vector3 tipToPadPosition = fingerPosition + degreesRelative * tipOffset;`
`233`		`- indexFingerRingRenderer.transform.position = tipToPadPosition;`
	`233`	`+ target.position = tipToPadPosition;`
`234`	`234`	`}`
`235`	`235`	`}`
`236`	`236`	`}`
Original file line number	Diff line number	Diff line change
`@@ -649,8 +649,7 @@ public bool TryGetFocusDetails(IMixedRealityPointer pointer, out FocusDetails fo`
`649`	`649`	`{`
`650`	`650`	`using (TryGetFocusDetailsPerfMarker.Auto())`
`651`	`651`	`{`
`652`		`- PointerData pointerData;`
`653`		`- if (TryGetPointerData(pointer, out pointerData))`
	`652`	`+ if (TryGetPointerData(pointer, out PointerData pointerData))`
`654`	`653`	`{`
`655`	`654`	`focusDetails = pointerData.Details;`
`656`	`655`	`return true;`
`@@ -766,8 +765,7 @@ private void CleanUpUiRaycastCamera()`
`766`	`765`	`public bool IsPointerRegistered(IMixedRealityPointer pointer)`
`767`	`766`	`{`
`768`	`767`	`Debug.Assert(pointer.PointerId != 0, $"{pointer} does not have a valid pointer id!");`
`769`		`- PointerData pointerData;`
`770`		`- return TryGetPointerData(pointer, out pointerData);`
	`768`	`+ return TryGetPointerData(pointer, out _);`
`771`	`769`	`}`
`772`	`770`
`773`	`771`	`private static readonly ProfilerMarker RegisterPointerPerfMarker = new ProfilerMarker("[MRTK] FocusProvider.RegisterPointer");`
`@@ -861,8 +859,7 @@ public bool UnregisterPointer(IMixedRealityPointer pointer)`
`861`	`859`	`{`
`862`	`860`	`Debug.Assert(pointer.PointerId != 0, $"{pointer} does not have a valid pointer id!");`
`863`	`861`
`864`		`- PointerData pointerData;`
`865`		`- if (!TryGetPointerData(pointer, out pointerData)) { return false; }`
	`862`	`+ if (!TryGetPointerData(pointer, out PointerData pointerData)) { return false; }`
`866`	`863`
`867`	`864`	`// Raise focus events if needed.`
`868`	`865`	`if (pointerData.CurrentPointerTarget != null)`
Original file line number	Diff line number	Diff line change
`@@ -1,31 +1,30 @@`
`1`	`1`	`// Copyright (c) Microsoft Corporation.`
`2`	`2`	`// Licensed under the MIT License.`
`3`	`3`
`4`		`-using System.Collections.Generic;`
`5`		`-using System.Linq;`
`6`		`-using System.Reflection;`
`7`	`4`	`using UnityEngine;`
`8`		`-using UnityEngine.SceneManagement;`
`9`	`5`
`10`	`6`	`#if UNITY_EDITOR`
`11`	`7`	`using Microsoft.MixedReality.Toolkit.Utilities.Editor;`
`12`	`8`	`using Microsoft.MixedReality.Toolkit.Editor;`
	`9`	`+using System.Collections.Generic;`
	`10`	`+using System.Linq;`
	`11`	`+using System.Reflection;`
`13`	`12`	`using UnityEditor;`
`14`	`13`	`using UnityEditor.SceneManagement;`
`15`		`-#endif`
`16`		`-`
`17`		`-#if WINDOWS_UWP`
`18`		`-using UnityEngine.Assertions;`
	`14`	`+using UnityEngine.SceneManagement;`
`19`	`15`	`#endif`
`20`	`16`
`21`	`17`	`namespace Microsoft.MixedReality.Toolkit.Tests`
`22`	`18`	`{`
`23`	`19`	`public static class TestUtilities`
`24`	`20`	`{`
`25`		`- const string primaryTestSceneTemporarySavePath = "Assets/__temp_primary_test_scene.unity";`
`26`		`- const string additiveTestSceneTemporarySavePath = "Assets/__temp_additive_test_scene_#.unity";`
	`21`	`+#if UNITY_EDITOR`
	`22`	`+ private const string PrimaryTestSceneTemporarySavePath = "Assets/__temp_primary_test_scene.unity";`
	`23`	`+ private const string AdditiveTestSceneTemporarySavePath = "Assets/__temp_additive_test_scene_#.unity";`
	`24`	`+`
`27`	`25`	`public static Scene primaryTestScene;`
`28`	`26`	`public static Scene[] additiveTestScenes = System.Array.Empty<Scene>();`
	`27`	`+#endif // UNITY_EDITOR`
`29`	`28`
`30`	`29`	`/// <summary>`
`31`	`30`	`/// Destroys all scene assets that were created over the course of testing.`
`@@ -37,15 +36,15 @@ public static void EditorTearDownScenes()`
`37`	`36`	`if (!EditorApplication.isPlaying)`
`38`	`37`	`{`
`39`	`38`	`// If any of our scenes were saved, tear down the assets`
`40`		`- SceneAsset primaryTestSceneAsset = AssetDatabase.LoadAssetAtPath<SceneAsset>(primaryTestSceneTemporarySavePath);`
	`39`	`+ SceneAsset primaryTestSceneAsset = AssetDatabase.LoadAssetAtPath<SceneAsset>(PrimaryTestSceneTemporarySavePath);`
`41`	`40`	`if (primaryTestSceneAsset != null)`
`42`	`41`	`{`
`43`		`- AssetDatabase.DeleteAsset(primaryTestSceneTemporarySavePath);`
	`42`	`+ AssetDatabase.DeleteAsset(PrimaryTestSceneTemporarySavePath);`
`44`	`43`	`}`
`45`	`44`
`46`	`45`	`for (int i = 0; i < additiveTestScenes.Length; i++)`
`47`	`46`	`{`
`48`		`- string path = additiveTestSceneTemporarySavePath.Replace("#", i.ToString());`
	`47`	`+ string path = AdditiveTestSceneTemporarySavePath.Replace("#", i.ToString());`
`49`	`48`	`SceneAsset additiveTestSceneAsset = AssetDatabase.LoadAssetAtPath<SceneAsset>(path);`
`50`	`49`	`if (additiveTestSceneAsset != null)`
`51`	`50`	`{`
`@@ -54,7 +53,7 @@ public static void EditorTearDownScenes()`
`54`	`53`	`}`
`55`	`54`	`AssetDatabase.Refresh();`
`56`	`55`	`}`
`57`		`-#endif`
	`56`	`+#endif // UNITY_EDITOR`
`58`	`57`	`}`
`59`	`58`
`60`	`59`	`/// <summary>`
`@@ -72,20 +71,17 @@ public static void EditorCreateScenes(int numScenesToCreate = 1)`
`72`	`71`
`73`	`72`	`List<Scene> additiveTestScenesList = new List<Scene>();`
`74`	`73`
`75`		`- if (numScenesToCreate == 1)`
`76`		`- { // No need to save this scene, we're just creating one`
`77`		`- primaryTestScene = EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects, NewSceneMode.Single);`
`78`		`- }`
`79`		`- else`
	`74`	`+ // Make the first scene single so it blows away previously loaded scenes`
	`75`	`+ primaryTestScene = EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects, NewSceneMode.Single);`
	`76`	`+`
	`77`	`+ if (numScenesToCreate != 1)`
`80`	`78`	`{`
`81`		`- // Make the first scene single so it blows away previously loaded scenes`
`82`		`- primaryTestScene = EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects, NewSceneMode.Single);`
`83`	`79`	`// Save the scene (temporarily) so we can load additively on top of it`
`84`		`- EditorSceneManager.SaveScene(primaryTestScene, primaryTestSceneTemporarySavePath);`
	`80`	`+ EditorSceneManager.SaveScene(primaryTestScene, PrimaryTestSceneTemporarySavePath);`
`85`	`81`
`86`	`82`	`for (int i = 1; i < numScenesToCreate; i++)`
`87`	`83`	`{`
`88`		`- string path = additiveTestSceneTemporarySavePath.Replace("#", additiveTestScenesList.Count.ToString());`
	`84`	`+ string path = AdditiveTestSceneTemporarySavePath.Replace("#", additiveTestScenesList.Count.ToString());`
`89`	`85`	`// Create subsequent scenes additively`
`90`	`86`	`Scene additiveScene = EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects, NewSceneMode.Additive);`
`91`	`87`	`additiveTestScenesList.Add(additiveScene);`
`@@ -95,7 +91,7 @@ public static void EditorCreateScenes(int numScenesToCreate = 1)`
`95`	`91`	`}`
`96`	`92`
`97`	`93`	`additiveTestScenes = additiveTestScenesList.ToArray();`
`98`		`-#endif`
	`94`	`+#endif // UNITY_EDITOR`
`99`	`95`	`}`
`100`	`96`
`101`	`97`	`/// <summary>`
`@@ -340,25 +336,25 @@ public static T GetDefaultMixedRealityProfile<T>() where T : BaseMixedRealityPro`
`340`	`336`	`public static void AssertAboutEqual(Vector3 actual, Vector3 expected, string message, float tolerance = 0.01f)`
`341`	`337`	`{`
`342`	`338`	`var dist = (actual - expected).magnitude;`
`343`		`- Debug.Assert(dist < tolerance, $"{message}, expected {expected.ToString("0.000")}, was {actual.ToString("0.000")}");`
	`339`	`+ Debug.Assert(dist < tolerance, $"{message}, expected {expected:0.000}, was {actual:0.000}");`
`344`	`340`	`}`
`345`	`341`
`346`	`342`	`public static void AssertAboutEqual(Quaternion actual, Quaternion expected, string message, float tolerance = 0.01f)`
`347`	`343`	`{`
`348`	`344`	`var angle = Quaternion.Angle(actual, expected);`
`349`		`- Debug.Assert(angle < tolerance, $"{message}, expected {expected.ToString("0.000")}, was {actual.ToString("0.000")}");`
	`345`	`+ Debug.Assert(angle < tolerance, $"{message}, expected {expected:0.000}, was {actual:0.000}");`
`350`	`346`	`}`
`351`	`347`
`352`	`348`	`public static void AssertNotAboutEqual(Vector3 val1, Vector3 val2, string message, float tolerance = 0.01f)`
`353`	`349`	`{`
`354`	`350`	`var dist = (val1 - val2).magnitude;`
`355`		`- Debug.Assert(dist >= tolerance, $"{message}, val1 {val1.ToString("0.000")} almost equals val2 {val2.ToString("0.000")}");`
	`351`	`+ Debug.Assert(dist >= tolerance, $"{message}, val1 {val1:0.000} almost equals val2 {val2:0.000}");`
`356`	`352`	`}`
`357`	`353`
`358`	`354`	`public static void AssertNotAboutEqual(Quaternion val1, Quaternion val2, string message, float tolerance = 0.01f)`
`359`	`355`	`{`
`360`	`356`	`var angle = Quaternion.Angle(val1, val2);`
`361`		`- Debug.Assert(angle >= tolerance, $"{message}, val1 {val1.ToString("0.000")} almost equals val2 {val2.ToString("0.000")}");`
	`357`	`+ Debug.Assert(angle >= tolerance, $"{message}, val1 {val1:0.000} almost equals val2 {val2:0.000}");`
`362`	`358`	`}`
`363`	`359`
`364`	`360`	`/// <summary>`
`@@ -443,21 +439,21 @@ private static void UpdateTestScriptIcons()`
`443`	`439`
`444`	`440`	`MonoScript script = AssetDatabase.LoadAssetAtPath<MonoScript>(scriptPath);`
`445`	`441`
`446`		`- Texture2D currentIcon = getIconForObject?.Invoke(null, new object[] { script }) as Texture2D;`
	`442`	`+ Texture2D currentIcon = GetIconForObject?.Invoke(null, new object[] { script }) as Texture2D;`
`447`	`443`	`if (currentIcon == null \|\| !currentIcon.Equals(icon))`
`448`	`444`	`{`
`449`		`- setIconForObject?.Invoke(null, new object[] { script, icon });`
`450`		`- copyMonoScriptIconToImporters?.Invoke(null, new object[] { script });`
	`445`	`+ SetIconForObject?.Invoke(null, new object[] { script, icon });`
	`446`	`+ CopyMonoScriptIconToImporters?.Invoke(null, new object[] { script });`
`451`	`447`	`}`
`452`	`448`	`}`
`453`	`449`	`}`
`454`	`450`
`455`	`451`	`EditorUtility.ClearProgressBar();`
`456`	`452`	`}`
`457`	`453`
`458`		`- private static readonly MethodInfo getIconForObject = typeof(EditorGUIUtility).GetMethod("GetIconForObject", BindingFlags.Static \| BindingFlags.NonPublic);`
`459`		`- private static readonly MethodInfo setIconForObject = typeof(EditorGUIUtility).GetMethod("SetIconForObject", BindingFlags.Static \| BindingFlags.NonPublic);`
`460`		`- private static readonly MethodInfo copyMonoScriptIconToImporters = typeof(MonoImporter).GetMethod("CopyMonoScriptIconToImporters", BindingFlags.Static \| BindingFlags.NonPublic);`
	`454`	`+ private static readonly MethodInfo GetIconForObject = typeof(EditorGUIUtility).GetMethod("GetIconForObject", BindingFlags.Static \| BindingFlags.NonPublic);`
	`455`	`+ private static readonly MethodInfo SetIconForObject = typeof(EditorGUIUtility).GetMethod("SetIconForObject", BindingFlags.Static \| BindingFlags.NonPublic);`
	`456`	`+ private static readonly MethodInfo CopyMonoScriptIconToImporters = typeof(MonoImporter).GetMethod("CopyMonoScriptIconToImporters", BindingFlags.Static \| BindingFlags.NonPublic);`
`461`	`457`	`#endif`
`462`	`458`	`}`
`463`	`459`	`}`
Original file line number	Diff line number	Diff line change
`@@ -45,17 +45,17 @@ private long TotalPolyCount`
`45`	`45`
`46`	`46`	`private string TotalPolyCountStr`
`47`	`47`	`{`
`48`		`- get => $"Total Scene PolyCount: {TotalPolyCount.ToString("N0")} ";`
	`48`	`+ get => $"Total Scene PolyCount: {TotalPolyCount:N0} ";`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	`private string TotalActivePolyCountStr`
`52`	`52`	`{`
`53`		`- get => $"Total PolyCount (Active): {totalActivePolyCount.ToString("N0")} ";`
	`53`	`+ get => $"Total PolyCount (Active): {totalActivePolyCount:N0} ";`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`private string TotalInactivePolyCountStr`
`57`	`57`	`{`
`58`		`- get => $"Total PolyCount (Inactive): {totalInActivePolyCount.ToString("N0")} ";`
	`58`	`+ get => $"Total PolyCount (Inactive): {totalInActivePolyCount:N0} ";`
`59`	`59`	`}`
`60`	`60`
`61`	`61`	`private MeshFilter[] MeshesOrderedByPolyCountDesc;`