more meshdimension script changes

AVVR/Assets/_Scripts/MeshDimensionCalculator.cs

-using UnityEngine;
-using System.Collections.Generic;
 #if UNITY_EDITOR
+using UnityEngine;
 using UnityEditor;
-#endif
+using System.Collections.Generic;
 
-public class MeshDimensionCalculator : MonoBehaviour
+// Shared data structure for dimension results
+public class DimensionResults
 {
-    public GameObject targetObject;
-    private Vector3 totalMin = Vector3.positiveInfinity;
-    private Vector3 totalMax = Vector3.negativeInfinity;
-    private Vector3 dimensions;
-    private Vector3 center;
+    public Vector3 totalMin = Vector3.positiveInfinity;
+    public Vector3 totalMax = Vector3.negativeInfinity;
+    public Vector3 dimensions;
+    public Vector3 center;
+}
 
-    [SerializeField] private Vector3 scaleFactors = Vector3.one;
-    [SerializeField] private float uniformScaleFactor = 1f;
-    public void CalculateDimensions()
+// Shared logic class
+public static class MeshDimensionCalculatorLogic
+{
+    public static DimensionResults CalculateDimensions(GameObject targetObject)
     {
         if (targetObject == null)
         {
             Debug.LogError("Target object is not assigned!");
-            return;
+            return null;
         }
 
-        totalMin = Vector3.positiveInfinity;
-        totalMax = Vector3.negativeInfinity;
-
+        DimensionResults results = new DimensionResults();
         List<MeshFilter> meshFilters = new List<MeshFilter>();
         CollectMeshFilters(targetObject.transform, meshFilters);
 
         if (meshFilters.Count == 0)
         {
             Debug.LogError("No meshes found in the target object's hierarchy!");
-            return;
+            return null;
         }
 
         foreach (MeshFilter meshFilter in meshFilters)
@@ -43,20 +42,22 @@ public class MeshDimensionCalculator : MonoBehaviour
             for (int i = 0; i < vertices.Length; i++)
             {
                 Vector3 worldVertex = meshFilter.transform.TransformPoint(vertices[i]);
-                totalMin = Vector3.Min(totalMin, worldVertex);
-                totalMax = Vector3.Max(totalMax, worldVertex);
+                results.totalMin = Vector3.Min(results.totalMin, worldVertex);
+                results.totalMax = Vector3.Max(results.totalMax, worldVertex);
             }
         }
 
-        dimensions = totalMax - totalMin;
-        center = (totalMin + totalMax) / 2;
+        results.dimensions = results.totalMax - results.totalMin;
+        results.center = (results.totalMin + results.totalMax) / 2;
+
+        Debug.Log($"Total Dimensions: {results.dimensions}");
+        Debug.Log($"Center: {results.center}");
+        Debug.Log($"Floor Y position: {results.totalMin.y}");
 
-        Debug.Log($"Total Dimensions: {dimensions}");
-        Debug.Log($"Center: {center}");
-        Debug.Log($"Floor Y position: {totalMin.y}");
+        return results;
     }
 
-    private void CollectMeshFilters(Transform parent, List<MeshFilter> meshFilters)
+    private static void CollectMeshFilters(Transform parent, List<MeshFilter> meshFilters)
     {
         MeshFilter meshFilter = parent.GetComponent<MeshFilter>();
         if (meshFilter != null)
@@ -70,7 +71,7 @@ public class MeshDimensionCalculator : MonoBehaviour
         }
     }
 
-    public void ResetToOrigin()
+    public static void ResetToOrigin(GameObject targetObject)
     {
         if (targetObject == null)
         {
@@ -78,11 +79,12 @@ public class MeshDimensionCalculator : MonoBehaviour
             return;
         }
 
+        Undo.RecordObject(targetObject.transform, "Reset To Origin");
         targetObject.transform.position = Vector3.zero;
         Debug.Log("Target object has been reset to (0,0,0).");
     }
 
-    public void ResetFloorToZero()
+    public static void ResetFloorToZero(GameObject targetObject, float floorY)
     {
         if (targetObject == null)
         {
@@ -90,18 +92,14 @@ public class MeshDimensionCalculator : MonoBehaviour
             return;
         }
 
-        if (totalMin.y == Mathf.Infinity)
-        {
-            Debug.LogWarning("Please calculate dimensions first!");
-            return;
-        }
-
+        Undo.RecordObject(targetObject.transform, "Reset Floor To Zero");
         Vector3 currentPosition = targetObject.transform.position;
-        targetObject.transform.position = new Vector3(currentPosition.x, -totalMin.y, currentPosition.z);
-        Debug.Log($"Target object floor has been reset to Y = 0. New position: {targetObject.transform.position}");
+        Vector3 newPosition = new Vector3(currentPosition.x, -floorY, currentPosition.z);
+        targetObject.transform.position = newPosition;
+        Debug.Log($"Target object floor has been reset to Y = 0. New position: {newPosition}");
     }
 
-    public void ScaleObject()
+    public static void ScaleObject(GameObject targetObject, Vector3 scaleFactors)
     {
         if (targetObject == null)
         {
@@ -109,18 +107,14 @@ public class MeshDimensionCalculator : MonoBehaviour
             return;
         }
 
+        Undo.RecordObject(targetObject.transform, "Scale Object");
         Vector3 currentScale = targetObject.transform.localScale;
-        Vector3 newScale = new Vector3(
-            currentScale.x * scaleFactors.x,
-            currentScale.y * scaleFactors.y,
-            currentScale.z * scaleFactors.z
-        );
-
+        Vector3 newScale = Vector3.Scale(currentScale, scaleFactors);
         targetObject.transform.localScale = newScale;
         Debug.Log($"Target object scaled. New scale: {newScale}");
     }
 
-    public void ScaleObjectUniform()
+    public static void ScaleObjectUniform(GameObject targetObject, float uniformScaleFactor)
     {
         if (targetObject == null)
         {
@@ -128,14 +122,14 @@ public class MeshDimensionCalculator : MonoBehaviour
             return;
         }
 
+        Undo.RecordObject(targetObject.transform, "Scale Object Uniform");
         Vector3 currentScale = targetObject.transform.localScale;
         Vector3 newScale = currentScale * uniformScaleFactor;
-
         targetObject.transform.localScale = newScale;
         Debug.Log($"Target object scaled uniformly. New scale: {newScale}");
     }
 
-    public void ResetScale()
+    public static void ResetScale(GameObject targetObject)
     {
         if (targetObject == null)
         {
@@ -143,12 +137,58 @@ public class MeshDimensionCalculator : MonoBehaviour
             return;
         }
 
+        Undo.RecordObject(targetObject.transform, "Reset Scale");
         targetObject.transform.localScale = Vector3.one;
         Debug.Log("Target object scale has been reset to (1, 1, 1).");
     }
 }
 
-#if UNITY_EDITOR
+// MonoBehaviour Component
+public class MeshDimensionCalculator : MonoBehaviour
+{
+    public GameObject targetObject;
+    private DimensionResults results;
+
+    [SerializeField] private Vector3 scaleFactors = Vector3.one;
+    [SerializeField] private float uniformScaleFactor = 1f;
+
+    public void CalculateDimensions()
+    {
+        results = MeshDimensionCalculatorLogic.CalculateDimensions(targetObject);
+    }
+
+    public void ResetToOrigin()
+    {
+        MeshDimensionCalculatorLogic.ResetToOrigin(targetObject);
+    }
+
+    public void ResetFloorToZero()
+    {
+        if (results == null || results.totalMin.y == Mathf.Infinity)
+        {
+            Debug.LogWarning("Please calculate dimensions first!");
+            return;
+        }
+        MeshDimensionCalculatorLogic.ResetFloorToZero(targetObject, results.totalMin.y);
+    }
+
+    public void ScaleObject()
+    {
+        MeshDimensionCalculatorLogic.ScaleObject(targetObject, scaleFactors);
+    }
+
+    public void ScaleObjectUniform()
+    {
+        MeshDimensionCalculatorLogic.ScaleObjectUniform(targetObject, uniformScaleFactor);
+    }
+
+    public void ResetScale()
+    {
+        MeshDimensionCalculatorLogic.ResetScale(targetObject);
+    }
+}
+
+// Inspector UI for the MonoBehaviour component
 [CustomEditor(typeof(MeshDimensionCalculator))]
 public class MeshDimensionCalculatorEditor : Editor
 {
@@ -167,7 +207,7 @@ public class MeshDimensionCalculatorEditor : Editor
     {
         serializedObject.Update();
 
-        EditorGUILayout.PropertyField(targetObjectProperty);
+        EditorGUILayout.PropertyField(targetObjectProperty, new GUIContent("ModelWrapper"));
 
         MeshDimensionCalculator calculator = (MeshDimensionCalculator)target;
 
@@ -214,13 +254,11 @@ public class MeshDimensionCalculatorEditor : Editor
     }
 }
 
+// Editor Window
 public class MeshDimensionCalculatorWindow : EditorWindow
 {
     private GameObject targetObject;
-    private Vector3 dimensions;
-    private Vector3 center;
-    private Vector3 totalMin;
-    private Vector3 totalMax;
+    private DimensionResults results;
     private Vector3 scaleFactors = Vector3.one;
     private float uniformScaleFactor = 1f;
 
@@ -241,17 +279,25 @@ public class MeshDimensionCalculatorWindow : EditorWindow
 
         if (GUILayout.Button("Calculate Dimensions"))
         {
-            CalculateDimensions();
+            results = MeshDimensionCalculatorLogic.CalculateDimensions(targetObject);
+            Repaint();
         }
 
         if (GUILayout.Button("Reset to Origin (0,0,0)"))
         {
-            ResetToOrigin();
+            MeshDimensionCalculatorLogic.ResetToOrigin(targetObject);
         }
 
         if (GUILayout.Button("Reset Floor to Y = 0"))
         {
-            ResetFloorToZero();
+            if (results != null)
+            {
+                MeshDimensionCalculatorLogic.ResetFloorToZero(targetObject, results.totalMin.y);
+            }
+            else
+            {
+                EditorUtility.DisplayDialog("Error", "Please calculate dimensions first!", "OK");
+            }
         }
 
         EditorGUILayout.Space();
@@ -260,7 +306,7 @@ public class MeshDimensionCalculatorWindow : EditorWindow
         scaleFactors = EditorGUILayout.Vector3Field("Scale Factors (X, Y, Z)", scaleFactors);
         if (GUILayout.Button("Apply Scale (X, Y, Z)"))
         {
-            ScaleObject();
+            MeshDimensionCalculatorLogic.ScaleObject(targetObject, scaleFactors);
         }
 
         EditorGUILayout.Space();
@@ -268,112 +314,25 @@ public class MeshDimensionCalculatorWindow : EditorWindow
         uniformScaleFactor = EditorGUILayout.FloatField("Uniform Scale Factor", uniformScaleFactor);
         if (GUILayout.Button("Apply Uniform Scale"))
         {
-            ScaleObjectUniform();
+            MeshDimensionCalculatorLogic.ScaleObjectUniform(targetObject, uniformScaleFactor);
         }
 
         EditorGUILayout.Space();
 
         if (GUILayout.Button("Reset Scale to (1, 1, 1)"))
         {
-            ResetScale();
+            MeshDimensionCalculatorLogic.ResetScale(targetObject);
         }
 
         EditorGUI.EndDisabledGroup();
 
-        if (targetObject != null && dimensions != Vector3.zero)
+        if (results != null && results.dimensions != Vector3.zero)
         {
             EditorGUILayout.Space();
             EditorGUILayout.LabelField("Results:", EditorStyles.boldLabel);
-            EditorGUILayout.Vector3Field("Dimensions", dimensions);
-            EditorGUILayout.Vector3Field("Center", center);
-            EditorGUILayout.FloatField("Floor Y Position", totalMin.y);
-        }
-    }
-
-    private void CalculateDimensions()
-    {
-        if (targetObject == null) return;
-
-        totalMin = Vector3.positiveInfinity;
-        totalMax = Vector3.negativeInfinity;
-
-        List<MeshFilter> meshFilters = new List<MeshFilter>();
-        CollectMeshFilters(targetObject.transform, meshFilters);
-
-        if (meshFilters.Count == 0)
-        {
-            EditorUtility.DisplayDialog("Error", "No meshes found in the target object's hierarchy!", "OK");
-            return;
-        }
-
-        foreach (MeshFilter meshFilter in meshFilters)
-        {
-            Mesh mesh = meshFilter.sharedMesh;
-            if (mesh == null) continue;
-
-            Vector3[] vertices = mesh.vertices;
-            for (int i = 0; i < vertices.Length; i++)
-            {
-                Vector3 worldVertex = meshFilter.transform.TransformPoint(vertices[i]);
-                totalMin = Vector3.Min(totalMin, worldVertex);
-                totalMax = Vector3.Max(totalMax, worldVertex);
-            }
-        }
-
-        dimensions = totalMax - totalMin;
-        center = (totalMin + totalMax) / 2;
-        Repaint();
-    }
-
-    private void ScaleObject()
-    {
-        if (targetObject == null) return;
-        Undo.RecordObject(targetObject.transform, "Scale Object");
-        targetObject.transform.localScale = Vector3.Scale(targetObject.transform.localScale, scaleFactors);
-    }
-
-    private void ScaleObjectUniform()
-    {
-        if (targetObject == null) return;
-        Undo.RecordObject(targetObject.transform, "Scale Object Uniform");
-        targetObject.transform.localScale *= uniformScaleFactor;
-    }
-
-    private void ResetScale()
-    {
-        if (targetObject == null) return;
-        Undo.RecordObject(targetObject.transform, "Reset Scale");
-        targetObject.transform.localScale = Vector3.one;
-    }
-
-    private void ResetToOrigin()
-    {
-        if (targetObject == null) return;
-        Undo.RecordObject(targetObject.transform, "Reset To Origin");
-        targetObject.transform.position = Vector3.zero;
-    }
-
-    private void ResetFloorToZero()
-    {
-        if (targetObject == null) return;
-        CalculateDimensions();
-        Undo.RecordObject(targetObject.transform, "Reset Floor To Zero");
-        Vector3 newPosition = targetObject.transform.position;
-        newPosition.y -= totalMin.y;
-        targetObject.transform.position = newPosition;
-    }
-
-    private void CollectMeshFilters(Transform parent, List<MeshFilter> meshFilters)
-    {
-        MeshFilter meshFilter = parent.GetComponent<MeshFilter>();
-        if (meshFilter != null)
-        {
-            meshFilters.Add(meshFilter);
-        }
-
-        for (int i = 0; i < parent.childCount; i++)
-        {
-            CollectMeshFilters(parent.GetChild(i), meshFilters);
+            EditorGUILayout.Vector3Field("Dimensions", results.dimensions);
+            EditorGUILayout.Vector3Field("Center", results.center);
+            EditorGUILayout.FloatField("Floor Y Position", results.totalMin.y);
         }
     }
 }