Create RectTransformCloner.cs

Author: unitycoder

Assets/Scripts/Editor/Tools/RectTransformCloner.cs

@@ -0,0 +1,151 @@
+// clones UI RectTransform values from one GameObject to another in Unity Editor (only for identical hierarchy)
+
+using UnityEngine;
+using UnityEditor;
+using TMPro;
+using UnityEngine.UI;
+
+namespace UnityLibrary.Tools
+{
+    public class RectTransformCloner : EditorWindow
+    {
+        private GameObject source;
+        private GameObject target;
+        private bool requireIdenticalNames = true;
+        private bool cloneTMPAlignment = false;
+
+        [MenuItem("Tools/RectTransform Cloner")]
+        private static void ShowWindow()
+        {
+            var window = GetWindow<RectTransformCloner>();
+            window.titleContent = new GUIContent("RectTransform Cloner");
+            window.Show();
+        }
+
+        private void OnGUI()
+        {
+            GUILayout.Label("Clone RectTransform", EditorStyles.boldLabel);
+
+            source = (GameObject)EditorGUILayout.ObjectField("Source", source, typeof(GameObject), true);
+            target = (GameObject)EditorGUILayout.ObjectField("Target", target, typeof(GameObject), true);
+            requireIdenticalNames = EditorGUILayout.Toggle("Require Identical Names", requireIdenticalNames);
+            cloneTMPAlignment = EditorGUILayout.Toggle("Clone TMP Alignment", cloneTMPAlignment);
+
+            if (GUILayout.Button("Clone RectTransforms"))
+            {
+                if (source == null || target == null)
+                {
+                    Debug.LogError("Source and Target must be assigned.");
+                    return;
+                }
+
+                string errorMessage;
+                if (!CompareHierarchies(source.transform, target.transform, out errorMessage))
+                {
+                    Debug.LogError("Source and Target hierarchies do not match!\n" + errorMessage, target);
+                    return;
+                }
+
+                Undo.RegisterFullObjectHierarchyUndo(target, "Clone RectTransform Values");
+                CopyRectTransforms(source.transform, target.transform);
+
+                Debug.Log("RectTransform values cloned successfully.", target);
+
+                if (target.transform.parent != null)
+                {
+                    RectTransform parentRect = target.transform.parent as RectTransform;
+                    if (parentRect != null)
+                    {
+                        LayoutRebuilder.ForceRebuildLayoutImmediate(parentRect);
+                    }
+                    else
+                    {
+                        Debug.LogWarning("Target's parent is not a RectTransform, cannot force layout rebuild.", target);
+                    }
+                }
+                else
+                {
+                    Debug.LogWarning("Target has no parent, cannot force layout rebuild.", target);
+                }
+                EditorUtility.SetDirty(target);
+                SceneView.RepaintAll();
+            }
+        }
+
+        private bool CompareHierarchies(Transform source, Transform target, out string errorMessage)
+        {
+            errorMessage = "";
+
+            if (source.childCount != target.childCount)
+            {
+                errorMessage = $"Child count mismatch at {GetTransformPath(source)}: Source has {source.childCount}, Target has {target.childCount}";
+                return false;
+            }
+
+            for (int i = 0; i < source.childCount; i++)
+            {
+                var sourceChild = source.GetChild(i);
+                var targetChild = target.GetChild(i);
+
+                if (requireIdenticalNames && sourceChild.name != targetChild.name)
+                {
+                    errorMessage = $"Child name mismatch at {GetTransformPath(sourceChild)}: Source has '{sourceChild.name}', Target has '{targetChild.name}'";
+                    return false;
+                }
+
+                if (!CompareHierarchies(sourceChild, targetChild, out errorMessage))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        private void CopyRectTransforms(Transform source, Transform target)
+        {
+            var sourceRect = source as RectTransform;
+            var targetRect = target as RectTransform;
+
+            if (sourceRect != null && targetRect != null)
+            {
+                CopyRectTransformValues(sourceRect, targetRect);
+
+                if (cloneTMPAlignment)
+                {
+                    var sourceTMP = source.GetComponent<TextMeshProUGUI>();
+                    var targetTMP = target.GetComponent<TextMeshProUGUI>();
+                    if (sourceTMP != null && targetTMP != null)
+                    {
+                        Undo.RecordObject(targetTMP, "Clone TMP Alignment");
+                        targetTMP.alignment = sourceTMP.alignment;
+                    }
+                }
+            }
+
+            for (int i = 0; i < source.childCount; i++)
+            {
+                CopyRectTransforms(source.GetChild(i), target.GetChild(i));
+            }
+        }
+
+        private void CopyRectTransformValues(RectTransform source, RectTransform target)
+        {
+            target.anchoredPosition = source.anchoredPosition;
+            target.sizeDelta = source.sizeDelta;
+            target.anchorMin = source.anchorMin;
+            target.anchorMax = source.anchorMax;
+            target.pivot = source.pivot;
+            target.localRotation = source.localRotation;
+            target.localScale = source.localScale;
+            target.localPosition = source.localPosition;
+        }
+
+        private string GetTransformPath(Transform t)
+        {
+            if (t.parent == null)
+                return t.name;
+            return GetTransformPath(t.parent) + "/" + t.name;
+        }
+    }
+}