Merge pull request #1101 from Zod-/UI-Raycasts

Fix random focus change on layered canvas ui elements

Author: StephenHodgson

Assets/HoloToolkit-Examples/Input/Scenes/CanvasUiRaycasts.unity

@@ -0,0 +1,23 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+using UnityEngine;
+
+namespace HoloToolkit.Unity.Tests
+{
+    public class RotateMinMax : MonoBehaviour
+    {
+        [SerializeField] private float _minAngle;
+        [SerializeField] private float _maxAngle;
+        [SerializeField] private float _step;
+
+        private void Update()
+        {
+            transform.Rotate(Vector3.up, _step);
+            if (transform.localRotation.eulerAngles.y < _minAngle || transform.localRotation.eulerAngles.y > _maxAngle)
+            {
+                _step *= -1;
+            }
+        }
+    }
+}

Assets/HoloToolkit-Examples/Input/Scenes/CanvasUiRaycasts.unity.meta

@@ -0,0 +1,44 @@
+using System;
+using NUnit.Framework;
+
+namespace HoloToolkit.Unity.Tests
+{
+    public class EnumerableExtensionsTests
+    {
+        [Test]
+        public void TestMaxOrDefault()
+        {
+            Assert.Throws<ArgumentNullException>(() => ((int[])null).MaxOrDefault());
+        }
+
+        [Test]
+        public void TestMaxOrDefaultEmpty()
+        {
+            var items = new int[0];
+
+            Assert.That(items.MaxOrDefault(), Is.Zero);
+        }
+
+        [Test]
+        public void TestMaxOrDefaultUnordered()
+        {
+            var items = new[]
+            {
+                -5, -20, 100, 5
+            };
+
+            Assert.That(items.MaxOrDefault(), Is.EqualTo(100));
+        }
+
+        [Test]
+        public void TestMaxOrDefaultOrdered()
+        {
+            var items = new[]
+            {
+                -20, -5, 5, 100
+            };
+
+            Assert.That(items.MaxOrDefault(), Is.EqualTo(100));
+        }
+    }
+}

Assets/HoloToolkit-Examples/Input/Scripts/RotateMinMax.cs

@@ -0,0 +1,118 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+using NUnit.Framework;
+using UnityEngine;
+
+namespace HoloToolkit.Unity.Tests
+{
+    public class LayerExtensionsTests
+    {
+        [Test]
+        public void TestIsLayerInLayerMask()
+        {
+            var waterLayer = LayerMask.NameToLayer("Water");
+            var mask = Physics.AllLayers;
+            Assert.That(waterLayer.IsInLayerMask(mask), Is.True);
+        }
+
+        [Test]
+        public void TestIsLayerNotInLayerMask()
+        {
+            var waterLayer = LayerMask.NameToLayer("Water");
+            var mask = LayerMask.GetMask("Default");
+            Assert.That(waterLayer.IsInLayerMask(mask), Is.False);
+        }
+
+        [Test]
+        public void TestFindLayerListIndexFirst()
+        {
+            var waterLayer = LayerMask.NameToLayer("Water");
+            var masks = new LayerMask[]
+            {
+                LayerMask.GetMask("Water"),
+                LayerMask.GetMask("Default"),
+                LayerMask.GetMask("UI"),
+            };
+            Assert.That(waterLayer.FindLayerListIndex(masks), Is.EqualTo(0));
+        }
+
+        [Test]
+        public void TestFindLayerListIndexLast()
+        {
+            var waterLayer = LayerMask.NameToLayer("Water");
+            var masks = new LayerMask[]
+            {
+                LayerMask.GetMask("Default"),
+                LayerMask.GetMask("UI"),
+                LayerMask.GetMask("Water")
+            };
+            Assert.That(waterLayer.FindLayerListIndex(masks), Is.EqualTo(masks.Length - 1));
+        }
+
+        [Test]
+        public void TestFindLayerListIndexMiddle()
+        {
+            var waterLayer = LayerMask.NameToLayer("Water");
+            var masks = new LayerMask[]
+            {
+                LayerMask.GetMask("Default"),
+                LayerMask.GetMask("Water"),
+                LayerMask.GetMask("UI")
+            };
+            Assert.That(waterLayer.FindLayerListIndex(masks), Is.EqualTo(1));
+        }
+
+        [Test]
+        public void TestFindLayerListIndexNone()
+        {
+            var waterLayer = LayerMask.NameToLayer("Water");
+            var masks = new LayerMask[]
+            {
+                LayerMask.GetMask("Default"),
+                LayerMask.GetMask("UI")
+            };
+            Assert.That(waterLayer.FindLayerListIndex(masks), Is.EqualTo(-1));
+        }
+
+        [Test]
+        public void TestFindLayerListIndexEmpty()
+        {
+            var waterLayer = LayerMask.NameToLayer("Water");
+            var masks = new LayerMask[] { };
+            Assert.That(waterLayer.FindLayerListIndex(masks), Is.EqualTo(-1));
+        }
+
+        [Test]
+        public void TestCombineLayerMasksMultiple()
+        {
+            var masks = new LayerMask[]
+            {
+                LayerMask.GetMask("Ignore Raycast"),
+                LayerMask.GetMask("TransparentFX"),
+                LayerMask.GetMask("UI")
+            };
+            var combinedMask = LayerMask.GetMask("Ignore Raycast", "TransparentFX", "UI");
+            Assert.That(masks.Combine(), Is.EqualTo(combinedMask));
+        }
+
+        [Test]
+        public void TestCombineLayerMasksOne()
+        {
+            var masks = new LayerMask[]
+            {
+                LayerMask.GetMask("UI")
+            };
+            var combinedMask = LayerMask.GetMask("UI");
+            Assert.That(masks.Combine(), Is.EqualTo(combinedMask));
+        }
+
+        [Test]
+        public void TestCombineLayerMasksEmpty()
+        {
+            var masks = new LayerMask[] { };
+            var combinedMask = LayerMask.GetMask();
+            Assert.That(masks.Combine(), Is.EqualTo(combinedMask));
+        }
+    }
+}

Assets/HoloToolkit-Examples/Input/Scripts/RotateMinMax.cs.meta

@@ -295,5 +295,44 @@ public void BoundsColliderExcludeOrigin()
             var sut = cube.transform.GetColliderBounds();
             Assert.That(sut, Is.EqualTo(new Bounds(Vector3.one * 2, Vector3.one)));
         }
+
+        [Test]
+        public void TestUnrelatedParentChild()
+        {
+            var transform1 = new GameObject().transform;
+            var transform2 = new GameObject().transform;
+
+            Assert.That(transform1.IsParentOrChildOf(transform2), Is.False);
+            Assert.That(transform2.IsParentOrChildOf(transform1), Is.False);
+        }
+
+        [Test]
+        public void TestRelatedParentChild()
+        {
+            var transform1 = new GameObject().transform;
+            var transform2 = Object.Instantiate(empty, transform1).transform;
+
+            Assert.That(transform1.IsParentOrChildOf(transform2), Is.True);
+            Assert.That(transform2.IsParentOrChildOf(transform1), Is.True);
+        }
+
+        [Test]
+        public void TestNestedRelatedParentChild()
+        {
+            var root = new GameObject().transform;
+            var transform2 = Object.Instantiate(empty, root).transform;
+            var transform3 = Object.Instantiate(empty, transform2).transform;
+
+            Assert.That(transform2.IsParentOrChildOf(transform3), Is.True);
+            Assert.That(transform3.IsParentOrChildOf(transform2), Is.True);
+        }
+
+        [Test]
+        public void TestEqualParentChild()
+        {
+            var root = new GameObject().transform;
+
+            Assert.That(root.IsParentOrChildOf(root), Is.True);
+        }
     }
 }

Assets/HoloToolkit-UnitTests/Editor/Utilities/Extensions/EnumerableExtensionsTests.cs

@@ -92,11 +92,6 @@ public class GazeManager : Singleton<GazeManager>
         /// </summary>
         public PointerEventData UnityUIPointerEvent { get; private set; }
 
-        /// <summary>
-        /// Cached results of raycast results.
-        /// </summary>
-        private List<RaycastResult> raycastResultList = new List<RaycastResult>();
-
         protected override void Awake()
         {
             base.Awake();
@@ -225,9 +220,7 @@ private void RaycastUnityUI()
             UnityUIPointerEvent.position = cursorScreenPos;
 
             // Graphics raycast
-            raycastResultList.Clear();
-            EventSystem.current.RaycastAll(UnityUIPointerEvent, raycastResultList);
-            RaycastResult uiRaycastResult = FindClosestRaycastHitInLayerMasks(raycastResultList, RaycastLayerMasks);
+            RaycastResult uiRaycastResult = EventSystem.current.Raycast(UnityUIPointerEvent, RaycastLayerMasks);
             UnityUIPointerEvent.pointerCurrentRaycast = uiRaycastResult;
 
             // If we have a raycast result, check if we need to overwrite the 3D raycast info
@@ -240,8 +233,8 @@ private void RaycastUnityUI()
                     if (RaycastLayerMasks.Length > 1)
                     {
                         // Get the index in the prioritized layer masks
-                        int uiLayerIndex = FindLayerListIndex(uiRaycastResult.gameObject.layer, RaycastLayerMasks);
-                        int threeDLayerIndex = FindLayerListIndex(hitInfo.collider.gameObject.layer, RaycastLayerMasks);
+                        int uiLayerIndex = uiRaycastResult.gameObject.layer.FindLayerListIndex(RaycastLayerMasks);
+                        int threeDLayerIndex = hitInfo.collider.gameObject.layer.FindLayerListIndex(RaycastLayerMasks);
 
                         if (threeDLayerIndex > uiLayerIndex)
                         {
@@ -285,60 +278,6 @@ private void RaycastUnityUI()
 
         #region Helpers
 
-        /// <summary>
-        /// Find the closest raycast hit in the list of RaycastResults that is also included in the LayerMask list.  
-        /// </summary>
-        /// <param name="candidates">List of RaycastResults from a Unity UI raycast</param>
-        /// <param name="layerMaskList">List of layers to support</param>
-        /// <returns>RaycastResult if hit, or an empty RaycastResult if nothing was hit</returns>
-        private RaycastResult FindClosestRaycastHitInLayerMasks(List<RaycastResult> candidates, LayerMask[] layerMaskList)
-        {
-            int combinedLayerMask = 0;
-            for (int i = 0; i < layerMaskList.Length; i++)
-            {
-                combinedLayerMask = combinedLayerMask | layerMaskList[i].value;
-            }
-
-            RaycastResult? minHit = null;
-            for (var i = 0; i < candidates.Count; ++i)
-            {
-                if (candidates[i].gameObject == null || !IsLayerInLayerMask(candidates[i].gameObject.layer, combinedLayerMask))
-                {
-                    continue;
-                }
-                if (minHit == null || candidates[i].distance < minHit.Value.distance)
-                {
-                    minHit = candidates[i];
-                }
-            }
-
-            return minHit ?? new RaycastResult();
-        }
-
-        /// <summary>
-        /// Look through the layerMaskList and find the index in that list for which the supplied layer is part of
-        /// </summary>
-        /// <param name="layer">Layer to search for</param>
-        /// <param name="layerMaskList">List of LayerMasks to search</param>
-        /// <returns>LayerMaskList index, or -1 for not found</returns>
-        private int FindLayerListIndex(int layer, LayerMask[] layerMaskList)
-        {
-            for (int i = 0; i < layerMaskList.Length; i++)
-            {
-                if (IsLayerInLayerMask(layer, layerMaskList[i].value))
-                {
-                    return i;
-                }
-            }
-
-            return -1;
-        }
-
-        private bool IsLayerInLayerMask(int layer, int layerMask)
-        {
-            return ((1 << layer) & layerMask) != 0;
-        }
-
         private RaycastHit? PrioritizeHits(RaycastHit[] hits)
         {
             if (hits.Length == 0)
@@ -355,7 +294,7 @@ private bool IsLayerInLayerMask(int layer, int layerMask)
                 for (int hitIdx = 0; hitIdx < hits.Length; hitIdx++)
                 {
                     RaycastHit hit = hits[hitIdx];
-                    if (IsLayerInLayerMask(hit.transform.gameObject.layer, RaycastLayerMasks[layerMaskIdx]) &&
+                    if (hit.transform.gameObject.layer.IsInLayerMask(RaycastLayerMasks[layerMaskIdx]) &&
                         (minHit == null || hit.distance < minHit.Value.distance))
                     {
                         minHit = hit;