private static void CalculateBounds(Renderer renderer, CalculateBoundsResult result)
        {
            if (renderer is ParticleSystemRenderer)
            {
                return;
            }

            Bounds bounds = renderer.bounds;

            if (bounds.size == Vector3.zero && bounds.center != renderer.transform.position)
            {
                bounds = TransformBounds(renderer.transform.localToWorldMatrix, bounds);
            }

            if (!result.Initialized)
            {
                result.Bounds      = bounds;
                result.Initialized = true;
            }
            else
            {
                result.Bounds.Encapsulate(bounds.min);
                result.Bounds.Encapsulate(bounds.max);
            }
        }
        private void CalculateBounds(Transform t, CalculateBoundsResult result)
        {
            Renderer renderer = t.GetComponent <Renderer>();

            if (renderer != null)
            {
                CalculateBounds(renderer, result);
            }

            foreach (Transform child in t)
            {
                CalculateBounds(child, result);
            }
        }
        private Bounds CalculateBounds(Transform[] transforms)
        {
            CalculateBoundsResult result = new CalculateBoundsResult();

            for (int i = 0; i < transforms.Length; ++i)
            {
                Transform t = transforms[i];
                CalculateBounds(t, result);
            }

            if (result.Initialized)
            {
                return(result.Bounds);
            }

            Vector3 center = CenterPoint(transforms.Select(t => t.position).ToArray());

            return(new Bounds(center, Vector3.zero));
        }