ylsj/Assets/ADON/Plugs/Octave3D World Builder/Scripts/Extensions/GameObjectExtensions.cs

#if UNITY_EDITOR
using UnityEngine;
using UnityEditor;
using System;
using System.Collections.Generic;

namespace O3DWB
{
    public static class GameObjectExtensions
    {
        #region Extension Methods
        public static bool IsSceneObject(this GameObject gameObject)
        {
            var prefabAssetType = PrefabUtility.GetPrefabAssetType(gameObject);
            return prefabAssetType == PrefabAssetType.NotAPrefab;
        }

        public static Octave3DMesh GetOctave3DMesh(this GameObject gameObject)
        {
            Mesh mesh = gameObject.GetMeshFromFilterOrSkinnedMeshRenderer();
            if (mesh == null) return null;

            return Octave3DMeshDatabase.Get().GetOctave3DMesh(mesh);
        }

        public static void SetMeshPivotPoint(this GameObject gameObject, Vector3 pivotPoint)
        {
            Mesh mesh = gameObject.GetMeshFromMeshFilter();
            if (mesh == null) return;

            Vector3[] vertexPositions = mesh.vertices;
            for(int vIndex = 0; vIndex < vertexPositions.Length; ++vIndex)
            {
                vertexPositions[vIndex] = vertexPositions[vIndex] - pivotPoint;
            }
            mesh.vertices = vertexPositions;
            mesh.RecalculateBounds();

            gameObject.transform.position = pivotPoint;
        }

        public static void SetWorldPosDontAffectChildren(this GameObject gameObject, Vector3 worldPos)
        {
            Transform objectTransform = gameObject.transform;
            Dictionary<Transform, Vector3> childToPos = new Dictionary<Transform, Vector3>();
            for (int childIndex = 0; childIndex < objectTransform.childCount; ++childIndex )
            {
                Transform childTransform = objectTransform.GetChild(childIndex);
                childToPos.Add(childTransform, childTransform.position);
            }

            objectTransform.position = worldPos;
            for (int childIndex = 0; childIndex < objectTransform.childCount; ++childIndex)
            {
                Transform childTransform = objectTransform.GetChild(childIndex);
                childTransform.position = childToPos[childTransform];
            }
        }

        public static List<GameObject> GetAllMeshObjectsInHierarchy(this GameObject root)
        {
            var meshFilters = root.GetComponentsInChildren<MeshFilter>();
            if (meshFilters.Length == 0) return new List<GameObject>();

            var meshObjects = new List<GameObject>(meshFilters.Length);
            foreach(var meshFilter in meshFilters)
            {
                if(meshFilter.sharedMesh != null) meshObjects.Add(meshFilter.gameObject);
            }

            return meshObjects;
        }

        public static List<Vector3> GetOverlappedVertsInHierarchy(this GameObject root, OrientedBox overlapBox)
        {
            List<GameObject> allObjects = root.GetAllChildrenIncludingSelf();
            if (allObjects.Count == 0) return new List<Vector3>();

            var overlappedVerts = new List<Vector3>(allObjects.Count * 50);
            foreach (var gameObject in allObjects)
            {
                Mesh mesh = gameObject.GetMeshFromFilterOrSkinnedMeshRenderer();
                if (mesh != null)
                {
                    Octave3DMesh octave3DMesh = Octave3DMeshDatabase.Get().GetOctave3DMesh(mesh);
                    if (octave3DMesh != null) overlappedVerts.AddRange(octave3DMesh.GetOverlappedWorldVerts(overlapBox, new TransformMatrix(gameObject.transform.localToWorldMatrix)));
                }
            }

            return overlappedVerts;
        }

        public static List<Octave3DMesh> GetAllOctave3DMeshesInHierarchy(this GameObject root)
        {
            List<GameObject> allObjects = root.GetAllChildrenIncludingSelf();
            if (allObjects.Count == 0) return new List<Octave3DMesh>();

            var allOctave3DMeshes = new List<Octave3DMesh>(allObjects.Count);
            foreach(var gameObject in allObjects)
            {
                Mesh mesh = gameObject.GetMeshFromFilterOrSkinnedMeshRenderer();
                if(mesh != null)
                {
                    Octave3DMesh octave3DMesh = Octave3DMeshDatabase.Get().GetOctave3DMesh(mesh);
                    if (octave3DMesh != null) allOctave3DMeshes.Add(octave3DMesh);
                }
            }

            return allOctave3DMeshes;
        }

        public static void EmbedInSurfaceByVertex(this GameObject root, Vector3 embedDirection, GameObject embedSurface)
        {
            if (!root.DoesHierarchyContainMesh()) return;
            OrientedBox worldOOBB = root.GetHierarchyWorldOrientedBox();
            if (worldOOBB.IsValid())
            {
                Vector3 worldOOBBScaledSize = worldOOBB.ScaledSize;

                embedDirection.Normalize();
                BoxFace boxFace = worldOOBB.GetBoxFaceMostAlignedWithNormal(embedDirection);
                Vector3 faceCenter = worldOOBB.GetBoxFaceCenter(boxFace);
                Plane facePlane = worldOOBB.GetBoxFacePlane(boxFace);

                int sizeComponentIndex = -1;
                if (boxFace == BoxFace.Back || boxFace == BoxFace.Front) sizeComponentIndex = 2;
                else if (boxFace == BoxFace.Left || boxFace == BoxFace.Right) sizeComponentIndex = 0;
                else if (boxFace == BoxFace.Top || boxFace == BoxFace.Bottom) sizeComponentIndex = 1;

                const float vCollectSizeScale = 0.01f;
                const float vCollectEps = 1e-2f;
                Vector3 vCollectBoxSize = worldOOBB.ScaledSize;
                vCollectBoxSize[sizeComponentIndex] *= vCollectSizeScale;
                vCollectBoxSize[sizeComponentIndex] += vCollectEps;
                vCollectBoxSize[(sizeComponentIndex + 1) % 3] += vCollectEps;
                vCollectBoxSize[(sizeComponentIndex + 2) % 3] += vCollectEps;

                OrientedBox vCollectBox = new OrientedBox(worldOOBB);
                vCollectBox.Scale = Vector3.one;
                vCollectBox.ModelSpaceSize = vCollectBoxSize;
                vCollectBox.Center = (faceCenter + facePlane.normal * vCollectEps) - facePlane.normal * vCollectBoxSize[sizeComponentIndex] * 0.5f;

                List<Vector3> overlappedVerts = root.GetOverlappedVertsInHierarchy(vCollectBox);
                if (overlappedVerts.Count == 0) return;

                GameObjectRayHit surfaceRayHit;
                float maxDistSq = float.MinValue;
                bool needToMove = false;
                Vector3 cameraPos = SceneViewCamera.Camera.transform.position;
                foreach (var vertex in overlappedVerts)
                {
                    // Ignore if already below the surface
                    Ray ray = new Ray(vertex, -embedDirection);
                    if (embedSurface.RaycastTerrainOrMesh(ray, out surfaceRayHit)) continue;

                    // Ignore if already on the surface
                    Vector3 fromCamToPt = vertex - cameraPos;
                    ray = new Ray(cameraPos, Vector3.Normalize(fromCamToPt));
                    if (embedSurface.RaycastTerrainOrMesh(ray, out surfaceRayHit))
                    {
                        if (Mathf.Abs(fromCamToPt.magnitude - (surfaceRayHit.HitPoint - cameraPos).magnitude) < 1e-3f) continue;
                    }

                    ray = new Ray(vertex, embedDirection);
                    if (embedSurface.RaycastTerrainOrMesh(ray, out surfaceRayHit))
                    {
                        float distSq = (vertex - surfaceRayHit.HitPoint).sqrMagnitude;
                        if (distSq > maxDistSq)
                        {
                            maxDistSq = distSq;
                            needToMove = true;
                        }
                    }
                }

                if (needToMove) root.transform.position += embedDirection * Mathf.Sqrt(maxDistSq);
            }
        }

        public static void EmbedAllObjectsInSurface(List<GameObject> gameObjects, Vector3 embedDirection, GameObject embedSurface)
        {
            foreach (GameObject gameObject in gameObjects)
            {
                if (gameObject == embedSurface) continue;
                gameObject.EmbedInSurface(embedDirection, embedSurface);
            }
        }

        public static void EmbedObjectBoxInSurface(OrientedBox objectBox, Vector3 embedDirection, GameObject embedSurface)
        {
            GameObjectRayHit rayHit;
            if (objectBox.IsValid())
            {
                BoxFace boxFace = objectBox.GetBoxFaceMostAlignedWithNormal(embedDirection);
                //Vector3 faceCenter = objectBox.GetBoxFaceCenter(boxFace);

                /*Ray ray = new Ray(faceCenter, embedDirection);
                if (embedSurface.RaycastTerrainOrMeshReverseIfFail(ray, out rayHit))
                {
                    Vector3 moveVector = rayHit.HitPoint - faceCenter;
                    objectBox.Center += moveVector;
                }*/

                float maxDistSq = float.MinValue;
                float minDistSq = float.MaxValue;
                bool hitAlongPrjDir = false;
                bool hitAlongReversePrjDir = false;
                List<Vector3> boxFaceCorners = objectBox.GetBoxFaceCornerPoints(boxFace);
                foreach (var corner in boxFaceCorners)
                {
                    Ray ray = new Ray(corner, -embedDirection);
                    if (embedSurface.RaycastTerrainOrMesh(ray, out rayHit))
                    {
                        float distSq = (corner - rayHit.HitPoint).sqrMagnitude;
                        if (distSq < minDistSq)
                        {
                            minDistSq = distSq;
                            hitAlongReversePrjDir = true;
                        }

                        continue;
                    }

                    ray = new Ray(corner, embedDirection);
                    if (embedSurface.RaycastTerrainOrMesh(ray, out rayHit))
                    {
                        float distSq = (corner - rayHit.HitPoint).sqrMagnitude;
                        if (distSq > maxDistSq)
                        {
                            maxDistSq = distSq;
                            hitAlongPrjDir = true;
                        }
                    }
                }

                if (hitAlongPrjDir) objectBox.Center += embedDirection * Mathf.Sqrt(maxDistSq);   
                else
                if (hitAlongReversePrjDir) objectBox.Center -= embedDirection * Mathf.Sqrt(minDistSq);   
            }
        }

        public static void EmbedInSurface(this GameObject gameObject, Vector3 embedDirection, GameObject embedSurface)
        {
            GameObjectRayHit rayHit;
            OrientedBox worldOOBB = gameObject.GetHierarchyWorldOrientedBox();
            if (worldOOBB.IsValid())
            {
                BoxFace boxFace = worldOOBB.GetBoxFaceMostAlignedWithNormal(embedDirection);
                //Vector3 faceCenter = worldOOBB.GetBoxFaceCenter(boxFace);

                /*Ray ray = new Ray(faceCenter, embedDirection);
                if (embedSurface.RaycastTerrainOrMeshReverseIfFail(ray, out rayHit))
                {
                    Vector3 moveVector = rayHit.HitPoint - faceCenter;
                    GameObjectExtensions.RecordObjectTransformsForUndo(new List<GameObject> { gameObject });
                    gameObject.transform.position += moveVector;
                    worldOOBB.Center += moveVector;
                }*/

                float maxDistSq = float.MinValue;
                float minDistSq = float.MaxValue;
                bool hitAlongPrjDir = false;
                bool hitAlongReversePrjDir = false;
                List<Vector3> boxFaceCorners = worldOOBB.GetBoxFaceCornerPoints(boxFace);
                foreach (var corner in boxFaceCorners)
                {
                    Ray ray = new Ray(corner, -embedDirection);
                    if (embedSurface.RaycastTerrainOrMesh(ray, out rayHit))
                    {
                        float distSq = (corner - rayHit.HitPoint).sqrMagnitude;
                        if (distSq < minDistSq)
                        {
                            minDistSq = distSq;
                            hitAlongReversePrjDir = true;
                        }

                        continue;
                    }

                    ray = new Ray(corner, embedDirection);
                    if (embedSurface.RaycastTerrainOrMesh(ray, out rayHit))
                    {
                        float distSq = (corner - rayHit.HitPoint).sqrMagnitude;
                        if (distSq > maxDistSq)
                        {
                            maxDistSq = distSq;
                            hitAlongPrjDir = true;
                        }
                    }
                }

                if (hitAlongPrjDir)
                {
                    GameObjectExtensions.RecordObjectTransformsForUndo(new List<GameObject> { gameObject });
                    gameObject.transform.position += embedDirection * Mathf.Sqrt(maxDistSq);
                }
                else
                if (hitAlongReversePrjDir)
                {
                    GameObjectExtensions.RecordObjectTransformsForUndo(new List<GameObject> { gameObject });
                    gameObject.transform.position -= embedDirection * Mathf.Sqrt(minDistSq);
                }
            }
        }

        public static void ProjectAllObjectsOnPlane(List<GameObject> gameObjects, Vector3 projectionDir, Plane plane)
        {
            List<GameObject> parents = GameObjectExtensions.GetParents(gameObjects);
            foreach (GameObject gameObject in parents)
            {
                gameObject.ProjectOnPlane(projectionDir, plane);
            }
        }

        public static void ProjectOnPlane(this GameObject gameObject, Vector3 projectionDir, Plane plane)
        {
            OrientedBox worldOOBB = gameObject.GetHierarchyWorldOrientedBox();
            if (worldOOBB.IsValid())
            {
                BoxFace boxFace = worldOOBB.GetBoxFaceMostAlignedWithNormal(projectionDir);
                //Vector3 faceCenter = worldOOBB.GetBoxFaceCenter(boxFace);

                /*Ray ray = new Ray(faceCenter, embedDirection);
                if (embedSurface.RaycastTerrainOrMeshReverseIfFail(ray, out rayHit))
                {
                    Vector3 moveVector = rayHit.HitPoint - faceCenter;
                    GameObjectExtensions.RecordObjectTransformsForUndo(new List<GameObject> { gameObject });
                    gameObject.transform.position += moveVector;
                    worldOOBB.Center += moveVector;
                }*/

                float maxDistSq = float.MinValue;
                float minDistSq = float.MaxValue;
                bool hitAlongPrjDir = false;
                bool hitAlongReversePrjDir = false;
                List<Vector3> boxFaceCorners = worldOOBB.GetBoxFaceCornerPoints(boxFace);
                foreach (var corner in boxFaceCorners)
                {
                    Ray ray = new Ray(corner, -projectionDir);
                    float t;
                    if (plane.Raycast(ray, out t))
                    {
                        float distSq = (corner - ray.GetPoint(t)).sqrMagnitude;
                        if (distSq < minDistSq)
                        {
                            minDistSq = distSq;
                            hitAlongReversePrjDir = true;
                        }

                        continue;
                    }

                    ray = new Ray(corner, projectionDir);
                    if (plane.Raycast(ray, out t))
                    {
                        float distSq = (corner - ray.GetPoint(t)).sqrMagnitude;
                        if (distSq > maxDistSq)
                        {
                            maxDistSq = distSq;
                            hitAlongPrjDir = true;
                        }
                    }
                }

                if (hitAlongPrjDir)
                {
                    GameObjectExtensions.RecordObjectTransformsForUndo(new List<GameObject> { gameObject });
                    gameObject.transform.position += projectionDir * Mathf.Sqrt(maxDistSq);
                }
                else
                    if (hitAlongReversePrjDir)
                    {
                        GameObjectExtensions.RecordObjectTransformsForUndo(new List<GameObject> { gameObject });
                        gameObject.transform.position -= projectionDir * Mathf.Sqrt(minDistSq);
                    }
            }
        }

        public static List<Vector3> GetLocalAxes(this GameObject gameObject)
        {
            Transform gameObjectTransform = gameObject.transform;
            return new List<Vector3> { gameObjectTransform.right, gameObjectTransform.up, gameObjectTransform.forward };
        }

        public static void ApplyTransformDataToRootChildren(this GameObject root, GameObject sourceRoot)
        {
            List<GameObject> destChildren = root.GetAllChildren();
            List<GameObject> sourceChildren = sourceRoot.GetAllChildren();

            if (destChildren.Count != sourceChildren.Count) return;

            // Note: Assumes there will always be a 1 to 1 mapping between the children in the hierarchy. 
            for(int childIndex = 0; childIndex < destChildren.Count; ++childIndex)
            {
                destChildren[childIndex].transform.InheritWorldTransformFrom(sourceChildren[childIndex].transform);
            }
        }

        public static GameObject CloneAsWorkingObject(this GameObject gameObject, Transform parentTransform, bool allowUndoRedo = true)
        {
            Transform gameObjectTransform = gameObject.transform;
            GameObject clone = GameObject.Instantiate(gameObject, gameObjectTransform.position, gameObjectTransform.rotation) as GameObject;
            if (allowUndoRedo) UndoEx.RegisterCreatedGameObject(clone);

            clone.transform.localScale = gameObjectTransform.transform.lossyScale;
            clone.name = gameObject.name;
            clone.isStatic = gameObject.isStatic;
            clone.layer = gameObject.layer;
            clone.transform.parent = parentTransform;

            Octave3DScene.Get().RegisterObjectHierarchy(clone);
            SceneViewCamera.Instance.SetObjectVisibilityDirty();

            return clone;
        }

        public static GameObject GetSourcePrefab(this GameObject gameObject)
        {
            return PrefabUtility.GetCorrespondingObjectFromSource(gameObject) as GameObject;
        }

        public static GameObject GetSourcePrefabRoot(this GameObject gameObject)
        {
            GameObject sourcePrefab = gameObject.GetSourcePrefab();
            if (sourcePrefab == null) return null;

            Transform sourcePrefabTransform = sourcePrefab.transform;
            if (sourcePrefabTransform.root != null) sourcePrefab = sourcePrefabTransform.root.gameObject;

            return sourcePrefab;
        }

        public static bool RaycastBox(this GameObject gameObject, Ray ray, out GameObjectRayHit objectRayHit)
        {
            objectRayHit = null;
            OrientedBox objectWorldOrientedBox = gameObject.GetWorldOrientedBox();
        
            OrientedBoxRayHit objectBoxRayHit;
            if (objectWorldOrientedBox.Raycast(ray, out objectBoxRayHit))
                objectRayHit = new GameObjectRayHit(ray, gameObject, objectBoxRayHit, null, null, null);

            return objectRayHit != null;
        }

        public static bool RaycastSprite(this GameObject gameObject, Ray ray, out GameObjectRayHit objectRayHit)
        {
            objectRayHit = null;

            SpriteRenderer spriteRenderer = gameObject.GetComponent<SpriteRenderer>();
            if (spriteRenderer == null) return false;

            OrientedBox objectWorldOrientedBox = gameObject.GetWorldOrientedBox();

            OrientedBoxRayHit objectBoxRayHit;
            if(objectWorldOrientedBox.Raycast(ray, out objectBoxRayHit))
            {
                SpriteRayHit spriteHit = new SpriteRayHit(ray, objectBoxRayHit.HitEnter, spriteRenderer, objectBoxRayHit.HitPoint, objectBoxRayHit.HitNormal);
                objectRayHit = new GameObjectRayHit(ray, gameObject, null, null, null, spriteHit);
            }

            return objectRayHit != null;
        }

        public static bool RaycastMesh(this GameObject gameObject, Ray ray, out GameObjectRayHit objectRayHit)
        {
            objectRayHit = null;
            Mesh objectMesh = gameObject.GetMeshFromFilterOrSkinnedMeshRenderer();
            if (objectMesh == null) return false;

            Octave3DMesh octaveMesh = Octave3DMeshDatabase.Get().GetOctave3DMesh(objectMesh);
            if (octaveMesh == null) return false;

            MeshRayHit meshRayHit = octaveMesh.Raycast(ray, gameObject.transform.GetWorldMatrix());
            if (meshRayHit == null) return false;

            objectRayHit = new GameObjectRayHit(ray, gameObject, null, meshRayHit, null, null);
            return true;
        }

        public static bool RaycastMeshReverseIfFail(this GameObject gameObject, Ray ray, out GameObjectRayHit objectRayHit)
        {
            if (gameObject.RaycastMesh(ray, out objectRayHit)) return true;
            return gameObject.RaycastMesh(new Ray(ray.origin, -ray.direction), out objectRayHit);
        }

        public static bool RaycastTerrain(this GameObject gameObject, Ray ray, out GameObjectRayHit objectRayHit)
        {
            objectRayHit = null;
            if (!gameObject.HasTerrain()) return false;

            TerrainCollider terrainCollider = gameObject.GetComponent<TerrainCollider>();
            if (terrainCollider == null) return false;

            RaycastHit raycastHit;
            if (terrainCollider.Raycast(ray, out raycastHit, float.MaxValue))
            {
                TerrainRayHit terrainRayHit = new TerrainRayHit(ray, raycastHit);
                objectRayHit = new GameObjectRayHit(ray, gameObject, null, null, terrainRayHit, null);
            }

            return objectRayHit != null;
        }

        public static bool RaycastTerrainReverseIfFail(this GameObject gameObject, Ray ray, out GameObjectRayHit objectRayHit)
        {
            if (gameObject.RaycastTerrain(ray, out objectRayHit)) return true;
            return gameObject.RaycastTerrain(new Ray(ray.origin, -ray.direction), out objectRayHit);
        }

        public static bool RaycastTerrainOrMeshReverseIfFail(this GameObject gameObject, Ray ray, out GameObjectRayHit objectRayHit)
        {
            objectRayHit = null;
            if(gameObject.HasTerrain() && gameObject.GetComponent<TerrainCollider>() != null) return gameObject.RaycastTerrainReverseIfFail(ray, out objectRayHit);
            else if (gameObject.HasMesh()) return gameObject.RaycastMeshReverseIfFail(ray, out objectRayHit);

            return false;
        }

        public static bool RaycastTerrainOrMesh(this GameObject gameObject, Ray ray, out GameObjectRayHit objectRayHit)
        {
            objectRayHit = null;
            if (gameObject.HasTerrain() && gameObject.GetComponent<TerrainCollider>() != null) return gameObject.RaycastTerrain(ray, out objectRayHit);
            else if (gameObject.HasMesh()) return gameObject.RaycastMesh(ray, out objectRayHit);

            return false;
        }

        public static void SetHierarchyStatic(this GameObject hierarchyRoot, bool isStatic)
        {
            List<GameObject> allChildren = hierarchyRoot.GetAllChildrenIncludingSelf();
            foreach(GameObject child in allChildren)
            {
                child.isStatic = isStatic;
            }
        }

        public static void RotateHierarchyBoxAroundPoint(this GameObject root, float rotationInDegrees, Vector3 rotationAxis, Vector3 pivotPoint)
        {
            // OLD CODE: Was not taking pivot point into account.
            /*OrientedBox hierarchyWorldOrientedBox = root.GetHierarchyWorldOrientedBox();
            Transform rootTransform = root.transform;

            Vector3 fromCenterToPosition = rootTransform.position - hierarchyWorldOrientedBox.Center;
            Quaternion oldRotation = rootTransform.rotation;

            rotationAxis.Normalize();
            rootTransform.Rotate(rotationAxis, rotationInDegrees, Space.World);

            fromCenterToPosition = oldRotation.GetRelativeRotation(rootTransform.rotation) * fromCenterToPosition;
            rootTransform.position = hierarchyWorldOrientedBox.Center + fromCenterToPosition;*/

            OrientedBox hierarchyWorldOrientedBox = root.GetHierarchyWorldOrientedBox();
            Transform rootTransform = root.transform;

            rotationAxis.Normalize();
            Quaternion rotation = Quaternion.AngleAxis(rotationInDegrees, rotationAxis);

            Vector3 fromPivotToCenter = rotation * (hierarchyWorldOrientedBox.Center - pivotPoint);
            Vector3 newCenter = pivotPoint + fromPivotToCenter;
            Vector3 fromCenterToPosition = rotation * (rootTransform.position - hierarchyWorldOrientedBox.Center);

            rootTransform.rotation = rotation * rootTransform.rotation;
            rootTransform.position = newCenter + fromCenterToPosition;
        }

        public static void SetHierarchyWorldRotationAndPreserveHierarchyCenter(this GameObject root, Quaternion rotation)
        {
            OrientedBox hierarchyWorldOrientedBox = root.GetHierarchyWorldOrientedBox();
            Transform rootTransform = root.transform;

            Vector3 fromCenterToPosition = rootTransform.position - hierarchyWorldOrientedBox.Center;
            Quaternion oldRotation = rootTransform.rotation;
            rootTransform.rotation = rotation;

            fromCenterToPosition = oldRotation.GetRelativeRotation(rootTransform.rotation) * fromCenterToPosition;
            rootTransform.position = hierarchyWorldOrientedBox.Center + fromCenterToPosition;
        }

        public static void SetHierarchyWorldScaleByPivotPoint(this GameObject root, float scale, Vector3 pivotPoint)
        {
            root.SetHierarchyWorldScaleByPivotPoint(new Vector3(scale, scale, scale), pivotPoint);
        }

        public static void SetHierarchyWorldScaleByPivotPoint(this GameObject root, Vector3 scale, Vector3 pivotPoint)
        {
            Transform rootTransform = root.transform;
            Vector3 fromPivotToPosition = rootTransform.position - pivotPoint;
            Vector3 oldScale = rootTransform.lossyScale;
            root.SetWorldScale(scale);

            Vector3 invOldScaleVector = new Vector3(1.0f / oldScale.x, 1.0f / oldScale.y, 1.0f / oldScale.z);
            Vector3 relativeScale = Vector3.Scale(scale, invOldScaleVector);
            fromPivotToPosition = Vector3.Scale(relativeScale, fromPivotToPosition);
            rootTransform.position = pivotPoint + fromPivotToPosition;
        }

        public static void PlaceHierarchyOnPlane(this GameObject root, Plane placementPlane)
        {
            OrientedBox hierarchyWorldOrientedBox = root.GetHierarchyWorldOrientedBox();
            List<Vector3> boxPts = hierarchyWorldOrientedBox.GetCornerPoints();

            int ptIndex = placementPlane.GetIndexOfFurthestPointBehind(boxPts);
            if (ptIndex < 0) ptIndex = placementPlane.GetIndexOfClosestPointInFrontOrOnPlane(boxPts);

            if(ptIndex >= 0)
            {
                float distToPt = placementPlane.GetDistanceToPoint(boxPts[ptIndex]);
                root.transform.position -= placementPlane.normal * distToPt;
            }
        }

        public static void PlaceObjectBoxOnPlane(OrientedBox oobb, Plane plane)
        {
            List<Vector3> boxPts = oobb.GetCornerPoints();

            int ptIndex = plane.GetIndexOfFurthestPointBehind(boxPts);
            if (ptIndex < 0) ptIndex = plane.GetIndexOfClosestPointInFrontOrOnPlane(boxPts);

            if (ptIndex >= 0)
            {
                float distToPt = plane.GetDistanceToPoint(boxPts[ptIndex]);
                oobb.Center -= plane.normal * distToPt;
            }
        }

        public static void SetSelectedHierarchyWireframeHidden(this GameObject hierarchyRoot, bool isWireframeHidden)
        {
            Renderer renderer = hierarchyRoot.GetComponent<Renderer>();
            if (renderer != null)
            {
                #if UNITY_2017_1_OR_NEWER
                EditorUtility.SetSelectedRenderState(renderer, isWireframeHidden ? EditorSelectedRenderState.Hidden : EditorSelectedRenderState.Highlight);
                #else
                EditorUtility.SetSelectedWireframeHidden(renderer, isWireframeHidden);
                #endif
            }

            Transform gameObjectTransform = hierarchyRoot.transform;
            for (int childIndex = 0; childIndex < gameObjectTransform.childCount; ++childIndex)
            {
                SetSelectedHierarchyWireframeHidden(gameObjectTransform.GetChild(childIndex).gameObject, isWireframeHidden);
            }
        }

        public static bool DoesHierarchyContainMesh(this GameObject root)
        {
            List<GameObject> allChildrenIncludingSelf = root.GetAllChildrenIncludingSelf();
            foreach(GameObject gameObject in allChildrenIncludingSelf)
            {
                if (gameObject.HasMesh()) return true;
            }

            return false;
        }

        public static List<GameObject> GetHierarchyObjectsWithMesh(this GameObject hierarchyRoot)
        {
            List<GameObject> allChildrenIncludingSelf = hierarchyRoot.GetAllChildrenIncludingSelf();
            allChildrenIncludingSelf.RemoveAll(item => !item.HasMesh());

            return allChildrenIncludingSelf;
        }

        public static List<GameObject> GetHierarchyObjectsWithSprites(this GameObject hierarchyRoot)
        {
            List<GameObject> allChildrenIncludingSelf = hierarchyRoot.GetAllChildrenIncludingSelf();
            allChildrenIncludingSelf.RemoveAll(item => !item.HasSpriteRendererWithSprite());

            return allChildrenIncludingSelf;
        }

        public static bool HasMesh(this GameObject gameObject)
        {
            return gameObject.HasMeshFilterWithValidMesh() || gameObject.HasSkinnedMeshRendererWithValidMesh();
        }

        public static bool HasMeshFilterWithValidMesh(this GameObject gameObject)
        {
            MeshFilter meshFilter = gameObject.GetComponent<MeshFilter>();
            return meshFilter != null && meshFilter.sharedMesh != null;
        }

        public static bool HasSkinnedMeshRendererWithValidMesh(this GameObject gameObject)
        {
            SkinnedMeshRenderer skinnedMeshRenderer = gameObject.GetComponent<SkinnedMeshRenderer>();
            return skinnedMeshRenderer != null && skinnedMeshRenderer.sharedMesh != null;
        }

        public static bool HasTerrain(this GameObject gameObject)
        {
            return gameObject.GetComponent<Terrain>() != null;
        }

        public static bool HasLight(this GameObject gameObject)
        {
            return gameObject.GetComponent<Light>() != null;
        }

        public static bool HasParticleSystem(this GameObject gameObject)
        {
            return gameObject.GetComponent<ParticleSystem>() != null;
        }

        public static bool HasSpriteRenderer(this GameObject gameObject)
        {
            return gameObject.GetComponent<SpriteRenderer>() != null;
        }

        public static bool HasSpriteRendererWithSprite(this GameObject gameObject)
        {
            SpriteRenderer spriteRenderer = gameObject.GetComponent<SpriteRenderer>();
            if (spriteRenderer == null) return false;

            return spriteRenderer.sprite != null;
        }

        public static void AttachChildren(this GameObject gameObject, List<GameObject> children, bool allowUndoRedo)
        {
            if(allowUndoRedo)
            {
                Transform objectTransform = gameObject.transform;
                UndoEx.RecordForToolAction(objectTransform);

                foreach (GameObject child in children)
                {
                    Transform childTransform = child.transform;
                    UndoEx.RecordForToolAction(childTransform);
                    childTransform.parent = objectTransform;
                }
            }
            else
            {
                Transform objectTransform = gameObject.transform;
                foreach (GameObject child in children)
                {
                    child.transform.parent = objectTransform;
                }
            }
        }

        public static List<GameObject> GetAllChildrenIncludingSelf(this GameObject gameObject)
        {
            var finalObjectList = new List<GameObject> { gameObject };

            List<GameObject> allChildren = gameObject.GetAllChildren();
            if (allChildren.Count != 0) finalObjectList.AddRange(allChildren);

            return finalObjectList;
        }

        public static List<GameObject> GetAllChildren(this GameObject gameObject)
        {
            Transform objectTransform = gameObject.transform;
            Transform[] allChildTransforms = gameObject.GetComponentsInChildren<Transform>(true);

            var allChildren = new List<GameObject>();
            foreach(Transform childTransform in allChildTransforms)
            {
                if (objectTransform != childTransform) allChildren.Add(childTransform.gameObject);
            }

            return allChildren;
        }

        public static List<GameObject> GetImmediateChildren(this GameObject gameObject)
        {
            Transform objectTransform = gameObject.transform;
            List<Transform> immediateChildTransforms = objectTransform.GetImmediateChildTransforms();

            if (immediateChildTransforms.Count != 0)
            {
                List<GameObject> immediateChildren = new List<GameObject>(immediateChildTransforms.Count);
                foreach (Transform childTransform in immediateChildTransforms)
                {
                    immediateChildren.Add(childTransform.gameObject);
                }

                return immediateChildren;
            }
            else return new List<GameObject>();
        }

        public static void MoveImmediateChildrenUpOneLevel(this GameObject gameObject, bool allowUndoRedo)
        {
            Transform objectTransform = gameObject.transform;
            Transform objectParentTransform = objectTransform.parent;

            List<Transform> immediateChildTransforms = objectTransform.GetImmediateChildTransforms();

            if(allowUndoRedo)
            {
                foreach (Transform childTransform in immediateChildTransforms)
                {
                    UndoEx.SetTransformParent(childTransform, objectParentTransform);
                }
            }
            else
            {
                foreach (Transform childTransform in immediateChildTransforms)
                {
                    childTransform.parent = objectParentTransform;
                }
            }
        }

        public static GameObject GetParentWhichIsChildOf(this GameObject gameObject, GameObject targetParent)
        {
            // Store needed data for easy access
            Transform targetParentTransform = targetParent.transform;
            Transform currentTransform = gameObject.transform;

            // Keep moving up the hierarchy until we encounter the parent whose parent is 'targetParent'
            while (currentTransform != null && currentTransform.parent != targetParentTransform)
            {
                // Move up
                currentTransform = currentTransform.parent;
            }

            // If the current transform is not null, it means we found the parent which is a child of 'targetParent'.
            // Otherwise, it means that either 'gameObject' doesn't have any parents or its top parent is not a child
            // of 'targetParent'.
            return currentTransform != null ? currentTransform.gameObject : null;
        }

        public static GameObject GetParentWhichIsChildOf(this GameObject gameObject, List<Type> possibleParentTypes)
        {
            Transform currentTransform = gameObject.transform;

            while (currentTransform != null && currentTransform.parent != null)
            {
                GameObject currentParentObject = currentTransform.parent.gameObject;
                if (currentParentObject.HasComponentsOfAnyType(possibleParentTypes)) return currentTransform.gameObject;

                currentTransform = currentTransform.parent;
            }

            return null;
        }

        public static bool HasComponentsOfAnyType(this GameObject gameObject, List<Type> possibleTypes)
        {
            foreach (var type in possibleTypes)
            {
                if (gameObject.GetComponents(type).Length != 0) return true;
            }

            return false;
        }

        public static void SetWorldScale(this GameObject gameObject, float worldScale)
        {
            gameObject.SetWorldScale(new Vector3(worldScale, worldScale, worldScale));
        }

        public static void SetWorldScale(this GameObject gameObject, Vector3 worldScale)
        {
            Transform objectTransform = gameObject.transform;
            Transform objectParent = objectTransform.parent;

            objectTransform.parent = null;
            objectTransform.localScale = worldScale;

            float minScale = 1e-4f;
            if (Mathf.Abs(objectTransform.localScale.x) < minScale) objectTransform.localScale = new Vector3(minScale, objectTransform.localScale.y, objectTransform.localScale.z);
            if (Mathf.Abs(objectTransform.localScale.y) < minScale) objectTransform.localScale = new Vector3(objectTransform.localScale.x, minScale, objectTransform.localScale.z);
            if (Mathf.Abs(objectTransform.localScale.z) < minScale) objectTransform.localScale = new Vector3(objectTransform.localScale.x, objectTransform.localScale.y, minScale);

            objectTransform.parent = objectParent;
        }

        public static Rect GetScreenRectangle(this GameObject gameObject, Camera camera)
        {
            Box worldBox = gameObject.GetWorldBox();
            if (worldBox.IsValid()) return worldBox.GetScreenRectangle(camera);

            return new Rect();
        }

        public static OrientedBox GetHierarchyWorldOrientedBox(this GameObject hierarchyRoot)
        {
            OrientedBox hierarchyWorldOrientedBox = hierarchyRoot.GetHierarchyModelSpaceOrientedBox();           
            hierarchyWorldOrientedBox.Transform(hierarchyRoot.transform);

            return hierarchyWorldOrientedBox;
        }

        public static OrientedBox GetHierarchyModelSpaceOrientedBox(this GameObject hierarchyRoot)
        {
            Box hierarchyModelSpaceBox = hierarchyRoot.GetHierarchyModelSpaceBox();
            return new OrientedBox(hierarchyModelSpaceBox);
        }

        public static Box GetHierarchyWorldBox(this GameObject hierarchyRoot)
        {
            Box hierarchyWorldBox = hierarchyRoot.GetHierarchyModelSpaceBox();
            hierarchyWorldBox = hierarchyWorldBox.Transform(hierarchyRoot.transform.GetWorldMatrix());
            return hierarchyWorldBox;
        }

        public static Box GetHierarchyModelSpaceBox(this GameObject hierarchyRoot)
        {
            Transform rootTransform = hierarchyRoot.transform;
            Transform[] allChildTransforms = hierarchyRoot.GetComponentsInChildren<Transform>();

            bool hierarchyContainsMesh = hierarchyRoot.DoesHierarchyContainMesh();
            Box hierarchyModelSpaceBox = hierarchyRoot.GetModelSpaceBox();
            foreach (Transform childTransform in allChildTransforms)
            {
                GameObject childObject = childTransform.gameObject;
                bool objectHasMesh = childObject.HasMesh();

                if(objectHasMesh)
                {
                    Renderer renderer = childObject.GetRenderer();
                    if (renderer == null || !renderer.enabled) continue;
                }

                // If the hierarchy contains mesh objects, we will only take mesh objects into account
                if (!objectHasMesh && hierarchyContainsMesh) continue;
                if (childObject != hierarchyRoot)
                {
                    /*Octave3DMesh octave3DMesh = Octave3DMeshDatabase.Get().GetOctave3DMesh(childObject.GetMeshFromFilterOrSkinnedMeshRenderer());
                    if(octave3DMesh != null)
                    {
                        TransformMatrix rootRelativeTransformMatrix = childTransform.GetRelativeTransformMatrix(rootTransform);
                        rootRelativeTransformMatrix.Scale = rootRelativeTransformMatrix.Scale.GetVectorWithPositiveComponents();

                        List<Vector3> vertexPositions = new List<Vector3>(octave3DMesh.VertexPositions);
                        vertexPositions = Vector3Extensions.GetTransformedPoints(vertexPositions, rootRelativeTransformMatrix.ToMatrix4x4x);

                        Box vertexBox = Vector3Extensions.GetPointCloudBox(vertexPositions);
                        if (hierarchyModelSpaceBox.IsValid()) hierarchyModelSpaceBox.Encapsulate(vertexBox);
                        else hierarchyModelSpaceBox = new Box(vertexBox);
                    }
                    else*/
                    {
                        Box childModelSpaceBox = childObject.GetModelSpaceBox();
                        if (childModelSpaceBox.IsValid())
                        {
                            // Note: Negative scale values are a pain to work with, so we will set the scale to a positive value.
                            //       Negative scale causes problems inside 'Box.Transform' because it modifies the translation
                            //       in an undesirable manner. However, is it a good idea to ignore negative scale ???!!!
                            TransformMatrix rootRelativeTransformMatrix = childTransform.GetRelativeTransformMatrix(rootTransform);
                            rootRelativeTransformMatrix.Scale = rootRelativeTransformMatrix.Scale.GetVectorWithPositiveComponents();

                            childModelSpaceBox = childModelSpaceBox.Transform(rootRelativeTransformMatrix);

                            if (hierarchyModelSpaceBox.IsValid()) hierarchyModelSpaceBox.Encapsulate(childModelSpaceBox);
                            else hierarchyModelSpaceBox = new Box(childModelSpaceBox);
                        }
                    }
                }
            }

            return hierarchyModelSpaceBox;
        }

        /*public static OrientedBox GetHierarchyModelSpaceOrientedBox(this GameObject hierarchyRoot)
        {
            Transform rootTransform = hierarchyRoot.transform;
            Transform[] allChildTransforms = hierarchyRoot.GetComponentsInChildren<Transform>();

            bool hierarchyContainsMesh = hierarchyRoot.DoesHierarchyContainMesh();
            OrientedBox hierarchyModelSpaceBox = hierarchyRoot.GetModelSpaceOrientedBox();
            foreach (Transform childTransform in allChildTransforms)
            {
                GameObject childObject = childTransform.gameObject;

                // If the hierarchy contains mesh objects, we will only take mesh objects into account
                if (!childObject.HasMesh() && hierarchyContainsMesh) continue;
                if (childObject != hierarchyRoot)
                {
                    OrientedBox childModelSpaceBox = childObject.GetModelSpaceOrientedBox();
                    if (childModelSpaceBox.IsValid())
                    {
                        // Note: Negative scale values are a pain to work with, so we will set the scale to a positive value.
                        //       Negative scale causes problems inside 'Box.Transform' because it modifies the translation
                        //       in an undesirable manner. However, is it a good idea to ignore negative scale ???!!!
                        TransformMatrix rootRelativeTransformMatrix = childTransform.GetRelativeTransformMatrix(rootTransform);
                        rootRelativeTransformMatrix.Scale = rootRelativeTransformMatrix.Scale.GetVectorWithPositiveComponents();

                        childModelSpaceBox.Transform(rootRelativeTransformMatrix);

                        if (hierarchyModelSpaceBox.IsValid()) hierarchyModelSpaceBox.Encapsulate(childModelSpaceBox);
                        else hierarchyModelSpaceBox = new OrientedBox(childModelSpaceBox);
                    }
                }
            }

            return hierarchyModelSpaceBox;
        }*/

        public static OrientedBox GetWorldOrientedBox(this GameObject gameObject)
        {
            OrientedBox worldOrientedBox = gameObject.GetMeshWorldOrientedBox();
            if (worldOrientedBox.IsValid()) return worldOrientedBox;

            return gameObject.GetNonMeshWorldOrientedBox();
        }

        public static Box GetWorldBox(this GameObject gameObject)
        {
            Box worldBox = gameObject.GetMeshWorldBox();
            if (worldBox.IsValid()) return worldBox;

            return gameObject.GetNonMeshWorldBox();
        }

        public static OrientedBox GetModelSpaceOrientedBox(this GameObject gameObject)
        {
            OrientedBox modelSpaceOrientedBox = gameObject.GetMeshModelSpaceOrientedBox();
            if (modelSpaceOrientedBox.IsValid()) return modelSpaceOrientedBox;

            return gameObject.GetNonMeshModelSpaceOrientedBox();
        }

        public static Box GetModelSpaceBox(this GameObject gameObject)
        {
            Box modelSpaceBox = gameObject.GetMeshModelSpaceBox();
            if (modelSpaceBox.IsValid()) return modelSpaceBox;

            return gameObject.GetNonMeshModelSpaceBox();
        }

        public static OrientedBox GetMeshWorldOrientedBox(this GameObject gameObject)
        {
            Mesh mesh = gameObject.GetMeshFromMeshFilter();
            if (mesh != null) return new OrientedBox(new Box(mesh.bounds), gameObject.transform);

            mesh = gameObject.GetMeshFromSkinnedMeshRenderer();
            if (mesh != null) return new OrientedBox(new Box(gameObject.GetComponent<SkinnedMeshRenderer>().localBounds), gameObject.transform);

            return OrientedBox.GetInvalid();
        }

        public static Box GetMeshWorldBox(this GameObject gameObject)
        {
            Mesh mesh = gameObject.GetMeshFromMeshFilter();
            if (mesh != null) return new Box(mesh.bounds).Transform(gameObject.transform.GetWorldMatrix());

            mesh = gameObject.GetMeshFromSkinnedMeshRenderer();
            if (mesh != null) return new Box(gameObject.GetComponent<SkinnedMeshRenderer>().localBounds).Transform(gameObject.transform.GetWorldMatrix());

            return Box.GetInvalid();
        }

        public static OrientedBox GetNonMeshWorldOrientedBox(this GameObject gameObject)
        {
            SpriteRenderer spriteRenderer = gameObject.GetComponent<SpriteRenderer>();
            if(spriteRenderer != null)
            {
                return new OrientedBox(spriteRenderer.GetModelSpaceBox(), gameObject.transform);
            }
            else
            {
                OrientedBox modelSpaceOrientedBox = gameObject.GetNonMeshModelSpaceOrientedBox();
                if (!modelSpaceOrientedBox.IsValid()) return modelSpaceOrientedBox;

                OrientedBox worldOrientedBox = new OrientedBox(modelSpaceOrientedBox);
                Transform objectTransform = gameObject.transform;
                worldOrientedBox.Center = objectTransform.position;
                worldOrientedBox.Rotation = objectTransform.rotation;
                worldOrientedBox.Scale = objectTransform.lossyScale;

                return worldOrientedBox;
            }
        }

        public static Box GetNonMeshWorldBox(this GameObject gameObject)
        {
            Box modelSpaceBox = gameObject.GetNonMeshModelSpaceBox();
            if (!modelSpaceBox.IsValid()) return modelSpaceBox;

            Box worldBox = modelSpaceBox.Transform(gameObject.transform.GetWorldMatrix());
            return worldBox;
        }

        public static OrientedBox GetMeshModelSpaceOrientedBox(this GameObject gameObject)
        {
            Mesh mesh = gameObject.GetMeshFromMeshFilter();
            if (mesh != null) return new OrientedBox(new Box(mesh.bounds), Quaternion.identity);

            mesh = gameObject.GetMeshFromSkinnedMeshRenderer();
            if (mesh != null) return new OrientedBox(new Box(gameObject.GetComponent<SkinnedMeshRenderer>().sharedMesh.bounds), Quaternion.identity);
          
            return OrientedBox.GetInvalid();
        }

        public static Box GetMeshModelSpaceBox(this GameObject gameObject)
        {
            Mesh mesh = gameObject.GetMeshFromMeshFilter();
            if (mesh != null) return new Box(mesh.bounds);

            mesh = gameObject.GetMeshFromSkinnedMeshRenderer();
            if (mesh != null) return new Box(gameObject.GetComponent<SkinnedMeshRenderer>().sharedMesh.bounds);

            return Box.GetInvalid();
        }

        public static OrientedBox GetNonMeshModelSpaceOrientedBox(this GameObject gameObject)
        {
            SpriteRenderer spriteRenderer = gameObject.GetComponent<SpriteRenderer>();
            if (spriteRenderer != null && spriteRenderer.sprite != null) return new OrientedBox(spriteRenderer.GetModelSpaceBox());

            if (!gameObject.HasLight() && !gameObject.HasParticleSystem()) return OrientedBox.GetInvalid();
            return new OrientedBox(gameObject.GetNonMeshModelSpaceBox());
        }

        public static Box GetNonMeshModelSpaceBox(this GameObject gameObject)
        {
            SpriteRenderer spriteRenderer = gameObject.GetComponent<SpriteRenderer>();
            if (spriteRenderer != null && spriteRenderer.sprite != null) return spriteRenderer.GetModelSpaceBox();

            if (!gameObject.HasLight() && !gameObject.HasParticleSystem()) return Box.GetInvalid();
            return new Box(Vector3.zero, Octave3DScene.VolumeSizeForNonMeshObjects);
        }

        public static Renderer GetRenderer(this GameObject gameObject)
        {
            return gameObject.GetComponent<Renderer>();
        }

        public static bool IsSprite(this GameObject gameObject)
        {
            if (gameObject.HasMesh()) return false;

            SpriteRenderer spriteRenderer = gameObject.GetComponent<SpriteRenderer>();
            return spriteRenderer != null && spriteRenderer.sprite != null;
        }

        public static Mesh GetMeshFromFilterOrSkinnedMeshRenderer(this GameObject gameObject)
        {
            Mesh mesh = gameObject.GetMeshFromMeshFilter();
            if (mesh == null) mesh = gameObject.GetMeshFromSkinnedMeshRenderer();

            return mesh;
        }

        public static Mesh GetMeshFromMeshFilter(this GameObject gameObject)
        {
            MeshFilter meshFilter = gameObject.GetComponent<MeshFilter>();
            if (meshFilter != null && meshFilter.sharedMesh != null) return meshFilter.sharedMesh;

            return null;
        }

        public static Mesh GetMeshFromSkinnedMeshRenderer(this GameObject gameObject)
        {
            SkinnedMeshRenderer skinnedMeshRenderer = gameObject.GetComponent<SkinnedMeshRenderer>();
            if (skinnedMeshRenderer != null && skinnedMeshRenderer.sharedMesh != null) return skinnedMeshRenderer.sharedMesh;

            return null;
        }
        #endregion

        #region Utilities
        public static List<GameObject> GetParents(IEnumerable<GameObject> gameObjects)
        {
            List<GameObject> topParents = new List<GameObject>();
            foreach (GameObject gameObject in gameObjects)
            {
                bool foundParentForThisObject = false;
                Transform gameObjectTransform = gameObject.transform;

                foreach (GameObject potentialParent in gameObjects)
                {
                    if (gameObject != potentialParent && 
                        gameObjectTransform.IsChildOf(potentialParent.transform))
                    {
                        foundParentForThisObject = true;
                        break;
                    }
                }

                if (!foundParentForThisObject) topParents.Add(gameObject);
            }

            return topParents;
        }

        public static List<GameObject> GetAllObjectsInHierarchyCollection(List<GameObject> hierarchyRoots)
        {
            var allGameObjects = new List<GameObject>(hierarchyRoots.Count);
            foreach(GameObject root in hierarchyRoots)
            {
                allGameObjects.AddRange(root.GetAllChildrenIncludingSelf());
            }

            return allGameObjects;
        }

        public static void RecordObjectTransformsForUndo(IEnumerable<GameObject> gameObjects)
        {
            List<Transform> objectTransforms = GetObjectTransforms(gameObjects);
            UndoEx.RecordForToolAction(objectTransforms);
        }

        public static List<Transform> GetObjectTransforms(IEnumerable<GameObject> gameObjects)
        {
            var objectTransforms = new List<Transform>();
            foreach(GameObject gameObject in gameObjects)
            {
                objectTransforms.Add(gameObject.transform);
            }

            return objectTransforms;
        }

        public static List<OrientedBox> GetHierarchyWorldOrientedBoxes(List<GameObject> hierarchyRoots)
        {
            if (hierarchyRoots.Count == 0) return new List<OrientedBox>();

            var orientedBoxes = new List<OrientedBox>(hierarchyRoots.Count);
            foreach (GameObject selectedObject in hierarchyRoots)
            {
                OrientedBox orientedBox = selectedObject.GetHierarchyWorldOrientedBox();
                if (orientedBox.IsValid()) orientedBoxes.Add(orientedBox);
            }

            return orientedBoxes;
        }

        public static void SetSelectedHierarchyWireframeHidden(List<GameObject> hierarchyRoots, bool isWireframeHidden)
        {
            foreach(GameObject root in hierarchyRoots)
            {
                root.SetSelectedHierarchyWireframeHidden(isWireframeHidden);
            }
        }

        public static void SetHierarchyLayer(this GameObject root, int layer, bool allowUndoRedo)
        {
            var allObjects = root.GetAllChildrenIncludingSelf();
            AssignGameObjectsToLayer(allObjects, layer, allowUndoRedo);
        }

        public static void AssignGameObjectsToLayer(List<GameObject> gameObjects, int objectLayer, bool allowUndoRedo)
        {
            if(allowUndoRedo)
            {
                foreach (GameObject gameObject in gameObjects)
                {
                    UndoEx.RecordForToolAction(gameObject);
                    gameObject.layer = objectLayer;
                }
            }
            else
            {
                foreach (GameObject gameObject in gameObjects)
                {
                    gameObject.layer = objectLayer;
                }
            }
        }

        public static List<GameObject> GetObjectsWithMesh(List<GameObject> gameObjects)
        {
            if (gameObjects.Count == 0) return new List<GameObject>();

            var objectsWithMesh = new List<GameObject>(gameObjects.Count);
            foreach(var gameObject in gameObjects)
            {
                if (gameObject.HasMesh()) objectsWithMesh.Add(gameObject);
            }

            return objectsWithMesh;
        }
        #endregion
    }
}
#endif