Universe.Region.SceneObjectGroup.GroupScale C# (CSharp) Метод

        public Vector3 GroupScale()
        {
            if (m_partsList.Count == 1)
                return RootPart.Scale;

            Vector3 minScale = new Vector3(float.MaxValue, float.MaxValue, float.MaxValue);
            Vector3 maxScale = new Vector3(float.MinValue, float.MinValue, float.MinValue);
            Vector3 finalScale;

            foreach (SceneObjectPart part in m_partsList)
            {
                Vector3 partscale = part.Scale*0.5f;

                // not assuming root is at index 0
                if (part.ParentID == 0) // root is in local frame of reference, partscale.? are positive, no rotations
                {
                    // if root is always at index 0 this can be just assigns

                    if (partscale.X > maxScale.X)
                        maxScale.X = partscale.X;
                    if (partscale.Y > maxScale.Y)
                        maxScale.Y = partscale.Y;
                    if (partscale.Z > maxScale.Z)
                        maxScale.Z = partscale.Z;

                    partscale = -partscale;
                    if (partscale.X < minScale.X)
                        minScale.X = partscale.X;
                    if (partscale.Y < minScale.Y)
                        minScale.Y = partscale.Y;
                    if (partscale.Z < minScale.Z)
                        minScale.Z = partscale.Z;
                }

                else // prims are in their local frame of reference
                {
                    Vector3 partoffset = part.OffsetPosition;
                    Quaternion partrot = part.GetRotationOffset();

                    // bring into this frame

                    partscale *= partrot;
                    partoffset *= partrot;
                    partoffset += part.OffsetPosition;

                    // now just 2 vertices in a diagonal 
                    Vector3 deltam = partoffset - partscale;
                    Vector3 deltaM = partoffset + partscale;

                    if (deltaM.X > deltam.X) // right vertices order for extrem X
                    {
                        if (deltam.X < minScale.X)
                            minScale.X = deltam.X;
                        if (deltaM.X > maxScale.X)
                            maxScale.X = deltaM.X;
                    }
                    else // nopes inverse one
                    {
                        if (deltaM.X < minScale.X)
                            minScale.X = deltaM.X;
                        if (deltam.X > maxScale.X)
                            maxScale.X = deltam.X;
                    }

                    if (deltaM.Y > deltam.Y)
                    {
                        if (deltam.Y < minScale.Y)
                            minScale.Y = deltam.Y;
                        if (deltaM.Y > maxScale.Y)
                            maxScale.Y = deltaM.Y;
                    }
                    else
                    {
                        if (deltaM.Y < minScale.Y)
                            minScale.Y = deltaM.Y;
                        if (deltam.Y > maxScale.Y)
                            maxScale.Y = deltam.Y;
                    }

                    if (deltaM.Z > deltam.Z)
                    {
                        if (deltam.Z < minScale.Z)
                            minScale.Z = deltam.Z;
                        if (deltaM.Z > maxScale.Z)
                            maxScale.Z = deltaM.Z;
                    }
                    else
                    {
                        if (deltaM.Z < minScale.Z)
                            minScale.Z = deltaM.Z;
                        if (deltam.Z > maxScale.Z)
                            maxScale.Z = deltam.Z;
                    }
                }
            }

            finalScale.X = Math.Abs(maxScale.X - minScale.X);
            finalScale.Y = Math.Abs(maxScale.Y - minScale.Y);
            finalScale.Z = Math.Abs(maxScale.Z - minScale.Z);
            return finalScale;
        }