diff --git a/AVVR/Assets/_Scripts/MeshDimensionCalculator.cs b/AVVR/Assets/_Scripts/MeshDimensionCalculator.cs
index 67bbaad32fd62e8232415debcaec181dfc71adc1..ba15c24e2c29769ec3dabc4325d5da365fec7a9f 100644
--- a/AVVR/Assets/_Scripts/MeshDimensionCalculator.cs
+++ b/AVVR/Assets/_Scripts/MeshDimensionCalculator.cs
@@ -1,37 +1,36 @@
-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);
}
}
}