Utils.cs

Go to the documentation of this file.

// 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
{
    public static class Utils
    {
        [System.Obsolete("Use GameObjectExtensions.SetLayerRecursively(gameObject, layer) instead;")]
        public static void SetLayerRecursively(GameObject gameObject, int layer)
        {
            gameObject.SetLayerRecursively(layer);
        }

        public static float Map(float minA, float maxA, float minB, float maxB, float value)
        {
            return (value - minA) * (maxB / maxA) + minB;
        }

        public static float MapAndClamp(float minA, float maxA, float minB, float maxB, float value)
        {
            return Mathf.Clamp(Map(minA, maxA, minB, maxB, value), minB, maxB);
        }

        public static void MoveObjectInFrontOfUser(Transform stageTransform, Transform tran, Vector3 offset, float yawOffset)
        {
            // have obj track head position with translation offset
            Vector3 stageHeadPos = MathUtils.TransformPointFromTo(null, stageTransform, CameraCache.Main.transform.position);
            Vector3 stageHeadDir = MathUtils.TransformDirectionFromTo(null, stageTransform, CameraCache.Main.transform.forward);
            stageHeadDir.y = 0.0f; // ignore head pitch - use head position to set height
            stageHeadDir.Normalize();
            Vector3 sideDir = Vector3.Cross(stageHeadDir, Vector3.up).normalized;
            Vector3 stageNewPos = stageHeadPos + stageHeadDir * offset.z + Vector3.up * offset.y + sideDir * offset.x;
            tran.localPosition = MathUtils.TransformPointFromTo(stageTransform, tran.parent, stageNewPos);

            // also track head yaw
            Vector3 toDir = MathUtils.TransformDirectionFromTo(stageTransform, tran.parent, stageHeadDir);
            Quaternion rot = Quaternion.FromToRotation(Vector3.forward, toDir.normalized) * Quaternion.Euler(0.0f, yawOffset, 0.0f);
            tran.localRotation = rot;
        }

        public static void ConnectCylinderBetweenPoints(Transform endPointSpace, Vector3 a, Vector3 b, Transform cylTransform)
        {
            cylTransform.localPosition = MathUtils.TransformPointFromTo(endPointSpace, cylTransform.parent, 0.5f * (a + b));
            Vector3 dir = MathUtils.TransformDirectionFromTo(endPointSpace, cylTransform.parent, (b - a).normalized);
            cylTransform.localRotation = Quaternion.LookRotation(dir) * Quaternion.FromToRotation(Vector3.up, Vector3.forward);
            Vector3 scale = cylTransform.localScale;
            scale.y = (a - b).magnitude * 0.5f;
            cylTransform.localScale = scale;
        }

        public static void SetMaterialRecursive(Transform t, Material mat)
        {
            if (t.gameObject && t.gameObject.GetComponent<Renderer>())
            {
                t.gameObject.GetComponent<Renderer>().material = mat;
            }

            for (int ii = 0; ii < t.childCount; ++ii)
            {
                SetMaterialRecursive(t.GetChild(ii), mat);
            }
        }

        public static void SetMaterialRecursiveForName(Transform t, Material mat, string nameToTest)
        {
            if (t.gameObject && t.gameObject.GetComponent<Renderer>() && t.gameObject.name == nameToTest)
            {
                t.gameObject.GetComponent<Renderer>().material = mat;
            }

            for (int ii = 0; ii < t.childCount; ++ii)
            {
                SetMaterialRecursiveForName(t.GetChild(ii), mat, nameToTest);
            }

            Resources.UnloadUnusedAssets();
        }

        public static bool IsInEditor()
        {
#if UNITY_WSA && !UNITY_EDITOR
            return false;
#else
            return true;
#endif
        }

        public static Transform GetChildRecursive(Transform t, string name)
        {
            int numChildren = t.childCount;
            for (int ii = 0; ii < numChildren; ++ii)
            {
                Transform child = t.GetChild(ii);
                if (child.name == name)
                {
                    return child;
                }
                Transform foundIt = GetChildRecursive(child, name);
                if (foundIt != null)
                {
                    return foundIt;
                }
            }
            return null;
        }
    }
}