From 936e19d819f2b47e8af96bf48f0ec9424c625618 Mon Sep 17 00:00:00 2001 From: mika Date: Thu, 29 Jan 2026 11:46:41 +0200 Subject: [PATCH 01/26] add linerenderer context menu convert linerenderer points between local to worldspace --- .../ContextMenu/LineRendererToLocalSpace.cs | 60 +++++++++++++++++++ .../ContextMenu/LineRendererToWorldSpace.cs | 54 +++++++++++++++++ 2 files changed, 114 insertions(+) create mode 100644 Assets/Scripts/Editor/ContextMenu/LineRendererToLocalSpace.cs create mode 100644 Assets/Scripts/Editor/ContextMenu/LineRendererToWorldSpace.cs diff --git a/Assets/Scripts/Editor/ContextMenu/LineRendererToLocalSpace.cs b/Assets/Scripts/Editor/ContextMenu/LineRendererToLocalSpace.cs new file mode 100644 index 0000000..6cc6cc7 --- /dev/null +++ b/Assets/Scripts/Editor/ContextMenu/LineRendererToLocalSpace.cs @@ -0,0 +1,60 @@ +// converts line renderer points from world space to local space + +using UnityEngine; +using UnityEditor; +using UnityEditor.SceneManagement; + +namespace UnityLibrary.ContextMenu +{ + public static class LineRendererToLocalSpace + { + private const string MenuPath = "CONTEXT/LineRenderer/Convert Points To Local Space"; + + [MenuItem(MenuPath, true)] + private static bool Validate(MenuCommand command) + { + return command != null && command.context is LineRenderer; + } + + [MenuItem(MenuPath)] + private static void Convert(MenuCommand command) + { + var lr = (LineRenderer)command.context; + if (lr == null) return; + + int count = lr.positionCount; + if (count == 0) return; + + Transform t = lr.transform; + + Undo.RecordObject(lr, "Convert LineRenderer To Local Space"); + + // Get current positions in world space no matter what mode it's in. + Vector3[] world = new Vector3[count]; + if (lr.useWorldSpace) + { + lr.GetPositions(world); + } + else + { + Vector3[] local = new Vector3[count]; + lr.GetPositions(local); + for (int i = 0; i < count; i++) + world[i] = t.TransformPoint(local[i]); + } + + // Convert world -> local, switch mode, write back. + Vector3[] newLocal = new Vector3[count]; + for (int i = 0; i < count; i++) + newLocal[i] = t.InverseTransformPoint(world[i]); + + lr.useWorldSpace = false; + lr.SetPositions(newLocal); + + EditorUtility.SetDirty(lr); + + if (!Application.isPlaying) + EditorSceneManager.MarkSceneDirty(lr.gameObject.scene); + } + } +} diff --git a/Assets/Scripts/Editor/ContextMenu/LineRendererToWorldSpace.cs b/Assets/Scripts/Editor/ContextMenu/LineRendererToWorldSpace.cs new file mode 100644 index 0000000..90cc2d2 --- /dev/null +++ b/Assets/Scripts/Editor/ContextMenu/LineRendererToWorldSpace.cs @@ -0,0 +1,54 @@ +// converts LineRenderer points from local space to world space via context menu in Unity Editor + +using UnityEngine; +using UnityEditor; +using UnityEditor.SceneManagement; + +namespace UnityLibrary.ContextMenu +{ + public static class LineRendererToWorldSpace + { + private const string MenuPath = "CONTEXT/LineRenderer/Convert Points To World Space"; + + [MenuItem(MenuPath, true)] + private static bool Validate(MenuCommand command) + { + return command != null && command.context is LineRenderer; + } + + [MenuItem(MenuPath)] + private static void Convert(MenuCommand command) + { + var lr = (LineRenderer)command.context; + if (lr == null) return; + + if (lr.useWorldSpace) + { + Debug.Log("LineRenderer is already using World Space."); + return; + } + + int count = lr.positionCount; + if (count == 0) return; + + Transform t = lr.transform; + + Undo.RecordObject(lr, "Convert LineRenderer To World Space"); + + Vector3[] local = new Vector3[count]; + lr.GetPositions(local); + + Vector3[] world = new Vector3[count]; + for (int i = 0; i < count; i++) + world[i] = t.TransformPoint(local[i]); + + lr.useWorldSpace = true; + lr.SetPositions(world); + + EditorUtility.SetDirty(lr); + + if (!Application.isPlaying) + EditorSceneManager.MarkSceneDirty(lr.gameObject.scene); + } + } +} From b33ae3e7d8e111e1603cb0911618f2568c3889a8 Mon Sep 17 00:00:00 2001 From: John Day Date: Fri, 6 Feb 2026 11:18:01 -0600 Subject: [PATCH 02/26] Graphics.Blit ambiguous method signature --- Assets/Scripts/Docs/Graphics/Graphics_Blit.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Assets/Scripts/Docs/Graphics/Graphics_Blit.cs b/Assets/Scripts/Docs/Graphics/Graphics_Blit.cs index 6760898..805f4ba 100644 --- a/Assets/Scripts/Docs/Graphics/Graphics_Blit.cs +++ b/Assets/Scripts/Docs/Graphics/Graphics_Blit.cs @@ -26,7 +26,7 @@ void OnPostRender() { // Copies source texture into destination render texture with a shader // Destination RenderTexture is null to blit directly to screen - Graphics.Blit(displayTexture, null, mat); + Graphics.Blit(displayTexture, null as RenderTexture, mat); } } } \ No newline at end of file From 3f2d64bd41c256c8ccc9ba8cec08147441b07a1f Mon Sep 17 00:00:00 2001 From: mika Date: Thu, 12 Feb 2026 22:08:02 +0200 Subject: [PATCH 03/26] Add Android Store Capture Tool for screenshot automation This script provides a tool for capturing Android store screenshots directly from the Unity editor. It allows users to specify output folders and capture various preset resolutions for app icons, feature graphics, and screenshots for phones and tablets. --- .../Editor/Tools/AndroidStoreCaptureTool.cs | 513 ++++++++++++++++++ 1 file changed, 513 insertions(+) create mode 100644 Assets/Scripts/Editor/Tools/AndroidStoreCaptureTool.cs diff --git a/Assets/Scripts/Editor/Tools/AndroidStoreCaptureTool.cs b/Assets/Scripts/Editor/Tools/AndroidStoreCaptureTool.cs new file mode 100644 index 0000000..8a73f3a --- /dev/null +++ b/Assets/Scripts/Editor/Tools/AndroidStoreCaptureTool.cs @@ -0,0 +1,513 @@ +// AndroidStoreCaptureTool.cs +// Put this file anywhere under an "Editor" folder. +// Usage: +// 1) Enter Play Mode. +// 2) Open: Tools/Android Store Capture +// 3) Pick output folder and click "Capture All Presets" + +using System; +using System.Collections; +using System.Collections.Generic; +using System.IO; +using System.Reflection; +using UnityEditor; +using UnityEngine; + +namespace UnityLibrary.Tools +{ + public class AndroidStoreCaptureTool : EditorWindow + { + [Serializable] + private class Preset + { + public string name; // base file name (without _WxH) + public int width; + public int height; + public CropMode cropMode; + + public Preset(string name, int w, int h, CropMode cropMode) + { + this.name = name; + width = w; + height = h; + this.cropMode = cropMode; + } + } + + private enum CropMode + { + Stretch, // no crop, just scale to target (may distort) + CropToFit // center-crop to target aspect, then scale (no distortion) + } + + private string _outputFolder = "StoreCaptures"; + private int _phoneCount = 2; // Play Console: 2-8 phone screenshots + + // Jobs + private class CaptureJob + { + public Preset preset; + public string filename; + } + + private readonly Queue _queue = new Queue(); + private bool _isRunning; + + // Hidden helper MonoBehaviour that runs coroutines in Play Mode + private CaptureHelper _helper; + + // Presets based on Play Console rules in your message. + // Phone/tablet sizes are common choices within allowed ranges. + private List BuildPresets() + { + var list = new List(); + + // App icon and feature graphic + list.Add(new Preset("appicon", 512, 512, CropMode.CropToFit)); + list.Add(new Preset("featuregraphic", 1024, 500, CropMode.CropToFit)); + + // Phone screenshots (2-8). 9:16 or 16:9. Each side 320..3840. + // We capture portrait by default; toggle to landscape if you want. + for (int i = 1; i <= Mathf.Clamp(_phoneCount, 2, 8); i++) + list.Add(new Preset("phone_" + i.ToString("00"), 1080, 1920, CropMode.CropToFit)); + + // 7-inch tablet screenshots (allowed: 320..3840 each side) + list.Add(new Preset("tablet7_01", 1920, 1200, CropMode.CropToFit)); // landscape 16:10 + list.Add(new Preset("tablet7_02", 1200, 1920, CropMode.CropToFit)); // portrait 10:16 + + // 10-inch tablet screenshots (each side 1080..7680) + list.Add(new Preset("tablet10_01", 2560, 1600, CropMode.CropToFit)); // landscape 16:10 + list.Add(new Preset("tablet10_02", 1600, 2560, CropMode.CropToFit)); // portrait 10:16 + + return list; + } + + [MenuItem("Tools/Android Store Capture")] + public static void Open() + { + var w = GetWindow("Android Store Capture"); + w.minSize = new Vector2(420, 340); + w.Show(); + } + + private void OnDisable() + { + StopRunner(); + } + + private void OnGUI() + { + EditorGUILayout.LabelField("Capture from Game View (Play Mode)", EditorStyles.boldLabel); + + using (new EditorGUILayout.VerticalScope("box")) + { + EditorGUILayout.LabelField("Output", EditorStyles.boldLabel); + + EditorGUILayout.BeginHorizontal(); + _outputFolder = EditorGUILayout.TextField("Folder", _outputFolder); + if (GUILayout.Button("Browse", GUILayout.Width(80))) + { + string picked = EditorUtility.OpenFolderPanel("Pick output folder", Application.dataPath, ""); + if (!string.IsNullOrEmpty(picked)) + { + // Make it project-relative when possible + string proj = Path.GetFullPath(Path.Combine(Application.dataPath, "..")); + string full = Path.GetFullPath(picked); + if (full.StartsWith(proj, StringComparison.OrdinalIgnoreCase)) + { + _outputFolder = full.Substring(proj.Length).TrimStart(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar); + } + else + { + _outputFolder = full; + } + } + } + EditorGUILayout.EndHorizontal(); + + _phoneCount = EditorGUILayout.IntSlider("Phone screenshots (2-8)", _phoneCount, 2, 8); + } + + using (new EditorGUILayout.VerticalScope("box")) + { + EditorGUILayout.LabelField("Actions", EditorStyles.boldLabel); + + if (!EditorApplication.isPlaying) + { + EditorGUILayout.HelpBox("Enter Play Mode first. This tool captures the rendered Game View.", MessageType.Warning); + } + + GUI.enabled = EditorApplication.isPlaying && !_isRunning; + if (GUILayout.Button("Capture All Presets")) + { + EnqueueAll(); + StartRunner(); + } + + if (GUILayout.Button("Capture Only Icon + Feature Graphic")) + { + EnqueueIconAndFeatureOnly(); + StartRunner(); + } + GUI.enabled = true; + + GUI.enabled = _isRunning; + if (GUILayout.Button("Stop")) + { + StopRunner(); + } + GUI.enabled = true; + + if (_isRunning) + { + EditorGUILayout.Space(6); + EditorGUILayout.LabelField("Running...", EditorStyles.boldLabel); + EditorGUILayout.LabelField("Remaining", _queue.Count.ToString()); + } + } + + using (new EditorGUILayout.VerticalScope("box")) + { + EditorGUILayout.LabelField("Notes", EditorStyles.boldLabel); + EditorGUILayout.LabelField("- Files are named like: appicon_512x512.png, featuregraphic_1024x500.png"); + EditorGUILayout.LabelField("- Phone screenshots are named like: phone_01_1080x1920.png"); + EditorGUILayout.LabelField("- Captures center-crop to match target aspect (no stretching)."); + } + } + + private void EnqueueAll() + { + _queue.Clear(); + + string folder = ResolveOutputFolder(); + Directory.CreateDirectory(folder); + + foreach (var p in BuildPresets()) + { + string fn = $"{p.name}_{p.width}x{p.height}.png"; + _queue.Enqueue(new CaptureJob { preset = p, filename = Path.Combine(folder, fn) }); + } + } + + private void EnqueueIconAndFeatureOnly() + { + _queue.Clear(); + + string folder = ResolveOutputFolder(); + Directory.CreateDirectory(folder); + + var icon = new Preset("appicon", 512, 512, CropMode.CropToFit); + var feature = new Preset("featuregraphic", 1024, 500, CropMode.CropToFit); + + _queue.Enqueue(new CaptureJob { preset = icon, filename = Path.Combine(folder, $"appicon_512x512.png") }); + _queue.Enqueue(new CaptureJob { preset = feature, filename = Path.Combine(folder, $"featuregraphic_1024x500.png") }); + } + + private string ResolveOutputFolder() + { + // If user gave absolute path, use it. Otherwise, place under project root. + if (Path.IsPathRooted(_outputFolder)) + return _outputFolder; + + string projectRoot = Path.GetFullPath(Path.Combine(Application.dataPath, "..")); + return Path.Combine(projectRoot, _outputFolder); + } + + private CaptureHelper EnsureHelper() + { + if (_helper != null) return _helper; + + var go = new GameObject("[AndroidStoreCaptureHelper]") + { + hideFlags = HideFlags.HideAndDontSave + }; + _helper = go.AddComponent(); + return _helper; + } + + private void StartRunner() + { + if (_isRunning) return; + if (!EditorApplication.isPlaying) return; + + _isRunning = true; + + GetMainGameView(); + + var helper = EnsureHelper(); + helper.StartCoroutine(RunCaptures()); + } + + private void StopRunner() + { + _isRunning = false; + _queue.Clear(); + + if (_helper != null) + { + _helper.StopAllCoroutines(); + DestroyImmediate(_helper.gameObject); + _helper = null; + } + } + + private IEnumerator RunCaptures() + { + while (_queue.Count > 0) + { + if (!EditorApplication.isPlaying) + { + StopRunner(); + yield break; + } + + var job = _queue.Dequeue(); + + SetGameViewSize(job.preset.width, job.preset.height); + + // Wait for the GameView to resize and re-render + for (int i = 0; i < 6; i++) + yield return null; + + // Wait for end of frame — this is required for ScreenCapture to work + yield return new WaitForEndOfFrame(); + + try + { + ProcessCaptureJob(job); + } + catch (Exception ex) + { + Debug.LogError("Capture failed: " + ex); + } + + Repaint(); + } + + _isRunning = false; + AssetDatabase.Refresh(); + Debug.Log("Android Store Capture: All captures finished."); + Repaint(); + + if (_helper != null) + { + DestroyImmediate(_helper.gameObject); + _helper = null; + } + } + + private void ProcessCaptureJob(CaptureJob job) + { + int targetW = job.preset.width; + int targetH = job.preset.height; + + Texture2D src = ScreenCapture.CaptureScreenshotAsTexture(); + if (src == null) + { + Debug.LogError($"CaptureScreenshotAsTexture returned null for {job.filename}. Skipping."); + return; + } + + Texture2D processed; + if (job.preset.cropMode == CropMode.CropToFit) + processed = CropToAspectThenScale(src, targetW, targetH); + else + processed = ScaleTexture(src, targetW, targetH); + + byte[] png = processed.EncodeToPNG(); + File.WriteAllBytes(job.filename, png); + + DestroyImmediate(src); + if (processed != src) + DestroyImmediate(processed); + + Debug.Log("Saved: " + job.filename); + } + + private static Texture2D CropToAspectThenScale(Texture2D src, int targetW, int targetH) + { + float srcAspect = (float)src.width / src.height; + float dstAspect = (float)targetW / targetH; + + int cropW = src.width; + int cropH = src.height; + + if (srcAspect > dstAspect) + { + // too wide -> crop width + cropW = Mathf.RoundToInt(src.height * dstAspect); + cropH = src.height; + } + else + { + // too tall -> crop height + cropW = src.width; + cropH = Mathf.RoundToInt(src.width / dstAspect); + } + + // Crop from top-left: x starts at 0, y starts from top + int x0 = 0; + int y0 = src.height - cropH; + + Color[] pixels = src.GetPixels(x0, y0, cropW, cropH); + Texture2D cropped = new Texture2D(cropW, cropH, TextureFormat.RGBA32, false); + cropped.SetPixels(pixels); + cropped.Apply(false, false); + + Texture2D scaled = ScaleTexture(cropped, targetW, targetH); + DestroyImmediate(cropped); + return scaled; + } + + private static Texture2D ScaleTexture(Texture2D src, int targetW, int targetH) + { + Texture2D dst = new Texture2D(targetW, targetH, TextureFormat.RGBA32, false); + + for (int y = 0; y < targetH; y++) + { + float v = (targetH == 1) ? 0f : (float)y / (targetH - 1); + for (int x = 0; x < targetW; x++) + { + float u = (targetW == 1) ? 0f : (float)x / (targetW - 1); + Color c = SampleBilinear(src, u, v); + dst.SetPixel(x, y, c); + } + } + + dst.Apply(false, false); + return dst; + } + + private static Color SampleBilinear(Texture2D tex, float u, float v) + { + float x = u * (tex.width - 1); + float y = v * (tex.height - 1); + + int x0 = Mathf.Clamp((int)Mathf.Floor(x), 0, tex.width - 1); + int y0 = Mathf.Clamp((int)Mathf.Floor(y), 0, tex.height - 1); + int x1 = Mathf.Clamp(x0 + 1, 0, tex.width - 1); + int y1 = Mathf.Clamp(y0 + 1, 0, tex.height - 1); + + float tx = x - x0; + float ty = y - y0; + + Color c00 = tex.GetPixel(x0, y0); + Color c10 = tex.GetPixel(x1, y0); + Color c01 = tex.GetPixel(x0, y1); + Color c11 = tex.GetPixel(x1, y1); + + Color a = Color.Lerp(c00, c10, tx); + Color b = Color.Lerp(c01, c11, tx); + return Color.Lerp(a, b, ty); + } + + // --------------------------- + // GameView sizing (internal) + // --------------------------- + + private static EditorWindow GetMainGameView() + { + Type t = Type.GetType("UnityEditor.GameView,UnityEditor"); + if (t == null) return null; + + // Try "GetMainGameView" first (older Unity versions) + MethodInfo getMain = t.GetMethod("GetMainGameView", BindingFlags.NonPublic | BindingFlags.Static); + if (getMain != null) + { + var result = getMain.Invoke(null, null) as EditorWindow; + if (result != null) return result; + } + + // Fallback: try "GetMainGameViewRenderRect" or just find an open GameView window + var gameView = GetWindow(t, false, null, false); + return gameView; + } + + private static void SetGameViewSize(int width, int height) + { + // Creates/uses a fixed resolution entry in the current platform group, then selects it. + // Unity does not expose this publicly; reflection is used. + + Type sizesType = Type.GetType("UnityEditor.GameViewSizes,UnityEditor"); + Type sizeType = Type.GetType("UnityEditor.GameViewSize,UnityEditor"); + Type groupType = Type.GetType("UnityEditor.GameViewSizeGroupType,UnityEditor"); + + if (sizesType == null || sizeType == null || groupType == null) + return; + + var instanceProp = sizesType.GetProperty("instance", BindingFlags.Public | BindingFlags.Static); + if (instanceProp == null) return; + object sizesInstance = instanceProp.GetValue(null, null); + if (sizesInstance == null) return; + + MethodInfo getGroup = sizesType.GetMethod("GetGroup"); + if (getGroup == null) return; + object group = getGroup.Invoke(sizesInstance, new object[] { (int)Enum.Parse(groupType, "Standalone") }); + if (group == null) return; + + // Find existing + MethodInfo getBuiltinCount = group.GetType().GetMethod("GetBuiltinCount"); + MethodInfo getCustomCount = group.GetType().GetMethod("GetCustomCount"); + MethodInfo getGameViewSize = group.GetType().GetMethod("GetGameViewSize"); + + if (getBuiltinCount == null || getCustomCount == null || getGameViewSize == null) return; + + int builtin = (int)getBuiltinCount.Invoke(group, null); + int custom = (int)getCustomCount.Invoke(group, null); + + int total = builtin + custom; + int foundIndex = -1; + + for (int i = 0; i < total; i++) + { + object gvSize = getGameViewSize.Invoke(group, new object[] { i }); + if (gvSize == null) continue; + var widthProp = gvSize.GetType().GetProperty("width"); + var heightProp = gvSize.GetType().GetProperty("height"); + if (widthProp == null || heightProp == null) continue; + + int w = (int)widthProp.GetValue(gvSize, null); + int h = (int)heightProp.GetValue(gvSize, null); + + if (w == width && h == height) + { + foundIndex = i; + break; + } + } + + if (foundIndex < 0) + { + // Add custom size + Type gvSizeType = Type.GetType("UnityEditor.GameViewSizeType,UnityEditor"); + if (gvSizeType == null) return; + object fixedRes = Enum.Parse(gvSizeType, "FixedResolution"); + + ConstructorInfo ctor = sizeType.GetConstructor(new[] { gvSizeType, typeof(int), typeof(int), typeof(string) }); + if (ctor == null) return; + object newSize = ctor.Invoke(new object[] { fixedRes, width, height, width + "x" + height }); + + MethodInfo addCustom = group.GetType().GetMethod("AddCustomSize"); + if (addCustom == null) return; + addCustom.Invoke(group, new object[] { newSize }); + + custom = (int)getCustomCount.Invoke(group, null); + foundIndex = builtin + (custom - 1); + } + + // Select size in GameView + EditorWindow gv = GetMainGameView(); + if (gv == null) return; + + Type gvType = gv.GetType(); + PropertyInfo selectedSizeIndex = gvType.GetProperty("selectedSizeIndex", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); + if (selectedSizeIndex != null) + selectedSizeIndex.SetValue(gv, foundIndex, null); + + gv.Repaint(); + } + + // Hidden MonoBehaviour to run coroutines from the editor tool + private class CaptureHelper : MonoBehaviour { } + } +} From 6a258feb3afab5a28f90aaae8818cabc4216a780 Mon Sep 17 00:00:00 2001 From: mika Date: Fri, 20 Feb 2026 11:53:48 +0200 Subject: [PATCH 04/26] Fix FindReferences scripts --- .../Tools/FindWhoReferencesThisGameObject.cs | 64 ++++++++++++++++--- 1 file changed, 54 insertions(+), 10 deletions(-) diff --git a/Assets/Scripts/Editor/Tools/FindWhoReferencesThisGameObject.cs b/Assets/Scripts/Editor/Tools/FindWhoReferencesThisGameObject.cs index dd5b2c5..b3f4b15 100644 --- a/Assets/Scripts/Editor/Tools/FindWhoReferencesThisGameObject.cs +++ b/Assets/Scripts/Editor/Tools/FindWhoReferencesThisGameObject.cs @@ -64,7 +64,7 @@ private void OnGUI() private void FindReferences(GameObject target) { - var allObjects = UnityEngine.Object.FindObjectsOfType(true); + var allObjects = Object.FindObjectsByType(findObjectsInactive: FindObjectsInactive.Include, sortMode: FindObjectsSortMode.None); foreach (var mono in allObjects) { @@ -94,20 +94,26 @@ private void FindReferences(GameObject target) } } } + + continue; } - else if (typeof(UnityEngine.Object).IsAssignableFrom(field.FieldType)) + + if (!typeof(UnityEngine.Object).IsAssignableFrom(field.FieldType)) + continue; + + var value = field.GetValue(mono) as UnityEngine.Object; + if (ReferencesTarget(value, target)) { - var value = field.GetValue(mono) as UnityEngine.Object; - if (value == target) + results.Add(new ReferenceResult { - results.Add(new ReferenceResult - { - message = $"{mono.name} ({type.Name}) -> Field '{field.Name}'", - owner = mono.gameObject - }); - } + message = $"{mono.name} ({type.Name}) -> Field '{field.Name}'", + owner = mono.gameObject + }); } } + + // Also scan serialized properties (handles public fields, [SerializeField] private, arrays/lists, etc.) + FindSerializedReferences(mono, target); } if (results.Count == 0) @@ -119,5 +125,43 @@ private void FindReferences(GameObject target) }); } } + + private void FindSerializedReferences(MonoBehaviour mono, GameObject target) + { + var so = new SerializedObject(mono); + var it = so.GetIterator(); + + // enterChildren=true on first call to include all fields + bool enterChildren = true; + while (it.NextVisible(enterChildren)) + { + enterChildren = false; + + if (it.propertyType != SerializedPropertyType.ObjectReference) + continue; + + var obj = it.objectReferenceValue; + if (!ReferencesTarget(obj, target)) + continue; + + results.Add(new ReferenceResult + { + message = $"{mono.name} ({mono.GetType().Name}) -> Serialized '{it.propertyPath}'", + owner = mono.gameObject + }); + } + } + + private static bool ReferencesTarget(UnityEngine.Object value, GameObject target) + { + if (value == null || target == null) return false; + + if (value == target) return true; + + // most common case: field is Transform/Component referencing the target GO + if (value is Component c && c.gameObject == target) return true; + + return false; + } } } From 933c6e63a4d87c6a0391d841098b5d346b4a7f85 Mon Sep 17 00:00:00 2001 From: mika Date: Sun, 22 Mar 2026 20:54:38 +0200 Subject: [PATCH 05/26] Add InspectorFilter for filtering component fields This script provides a filtering mechanism for Unity's inspector, allowing users to filter fields of components based on a string input. It includes UI elements for inputting filters and highlights matched fields. --- .../Scripts/Editor/Tools/InspectorFilter.cs | 289 ++++++++++++++++++ 1 file changed, 289 insertions(+) create mode 100644 Assets/Scripts/Editor/Tools/InspectorFilter.cs diff --git a/Assets/Scripts/Editor/Tools/InspectorFilter.cs b/Assets/Scripts/Editor/Tools/InspectorFilter.cs new file mode 100644 index 0000000..ab37407 --- /dev/null +++ b/Assets/Scripts/Editor/Tools/InspectorFilter.cs @@ -0,0 +1,289 @@ +// filters the fields of all components of a GameObject based on a user-provided string +// matching against both field names and types, with a UI to input the filter and visual highlights for matched fields. + +using System; +using System.Collections.Generic; +using UnityEditor; +using UnityEngine; + +namespace UnityLibrary.EditorTools +{ + [InitializeOnLoad] + public static class InspectorFilter + { + private static readonly Dictionary FiltersByGameObjectId = new Dictionary(); + private static readonly Dictionary> MatchedFieldsByComponentId = new Dictionary>(); + + static InspectorFilter() + { + Editor.finishedDefaultHeaderGUI += OnFinishedDefaultHeaderGUI; + Selection.selectionChanged += ApplyFilterForCurrentSelection; + Undo.undoRedoPerformed += ApplyFilterForCurrentSelection; + EditorApplication.delayCall += ApplyFilterForCurrentSelection; + } + + internal static bool TryGetFilterForGameObject(GameObject go, out string filter) + { + filter = string.Empty; + if (go == null) + { + return false; + } + + if (!FiltersByGameObjectId.TryGetValue(go.GetInstanceID(), out string value) || string.IsNullOrWhiteSpace(value)) + { + return false; + } + + filter = value.Trim(); + return filter.Length > 0; + } + + internal static bool IsPropertyMatch(SerializedProperty property, string filter) + { + if (property == null || string.IsNullOrWhiteSpace(filter)) + { + return false; + } + + if (property.propertyPath == "m_Script") + { + return false; + } + + return property.name.IndexOf(filter, StringComparison.OrdinalIgnoreCase) >= 0 + || property.displayName.IndexOf(filter, StringComparison.OrdinalIgnoreCase) >= 0; + } + + private static void OnFinishedDefaultHeaderGUI(Editor editor) + { + if (editor.target is GameObject go) + { + DrawGameObjectFilterUI(go); + return; + } + + if (!(editor.target is Component component)) + { + return; + } + + int gameObjectId = component.gameObject.GetInstanceID(); + if (!FiltersByGameObjectId.TryGetValue(gameObjectId, out string filter) || string.IsNullOrWhiteSpace(filter)) + { + return; + } + + if (!MatchedFieldsByComponentId.TryGetValue(component.GetInstanceID(), out List matchedFields) || matchedFields.Count == 0) + { + return; + } + + Color old = GUI.color; + GUI.color = new Color(1f, 0.95f, 0.55f, 1f); + EditorGUILayout.BeginVertical(EditorStyles.helpBox); + GUI.color = old; + EditorGUILayout.LabelField("Matched fields: " + string.Join(", ", matchedFields), EditorStyles.miniLabel); + EditorGUILayout.EndVertical(); + } + + private static void DrawGameObjectFilterUI(GameObject go) + { + int id = go.GetInstanceID(); + FiltersByGameObjectId.TryGetValue(id, out string currentFilter); + currentFilter ??= string.Empty; + + EditorGUILayout.BeginVertical(EditorStyles.helpBox); + + const string filterControlName = "InspectorFilter_FilterField"; + EditorGUILayout.BeginHorizontal(); + EditorGUI.BeginChangeCheck(); + GUI.SetNextControlName(filterControlName); + string newFilter = EditorGUILayout.TextField("Filter", currentFilter); + bool clearClicked = GUILayout.Button("x", EditorStyles.miniButton, GUILayout.Width(20f)); + bool changed = EditorGUI.EndChangeCheck(); + EditorGUILayout.EndHorizontal(); + + Event e = Event.current; + bool escapePressed = e.type == EventType.KeyDown + && e.keyCode == KeyCode.Escape + && GUI.GetNameOfFocusedControl() == filterControlName; + + if (clearClicked || escapePressed) + { + newFilter = string.Empty; + changed = true; + GUI.FocusControl(null); + if (escapePressed) + { + e.Use(); + } + } + + if (changed) + { + if (string.IsNullOrWhiteSpace(newFilter)) + { + FiltersByGameObjectId.Remove(id); + newFilter = string.Empty; + } + else + { + FiltersByGameObjectId[id] = newFilter; + } + + ApplyFilter(go, newFilter); + ActiveEditorTracker.sharedTracker.ForceRebuild(); + } + else + { + ApplyFilter(go, currentFilter); + } + + EditorGUILayout.EndVertical(); + } + + private static void ApplyFilterForCurrentSelection() + { + if (!(Selection.activeGameObject is GameObject go)) + { + return; + } + + int id = go.GetInstanceID(); + FiltersByGameObjectId.TryGetValue(id, out string filter); + ApplyFilter(go, filter); + ActiveEditorTracker.sharedTracker.ForceRebuild(); + } + + private static void ApplyFilter(GameObject go, string filter) + { + ActiveEditorTracker tracker = ActiveEditorTracker.sharedTracker; + Editor[] editors = tracker.activeEditors; + if (editors == null || editors.Length == 0) + { + return; + } + + bool hasFilter = !string.IsNullOrWhiteSpace(filter); + string normalizedFilter = hasFilter ? filter.Trim() : string.Empty; + + for (int i = 0; i < editors.Length; i++) + { + UnityEngine.Object target = editors[i].target; + if (!(target is Component component) || component.gameObject != go) + { + tracker.SetVisible(i, 1); + continue; + } + + int componentId = component.GetInstanceID(); + + if (!hasFilter) + { + MatchedFieldsByComponentId.Remove(componentId); + tracker.SetVisible(i, 1); + continue; + } + + bool typeMatch = component.GetType().Name.IndexOf(normalizedFilter, StringComparison.OrdinalIgnoreCase) >= 0; + List fieldMatches = GetMatchingSerializedFields(editors[i], normalizedFilter); + bool fieldMatch = fieldMatches.Count > 0; + + if (fieldMatch) + { + MatchedFieldsByComponentId[componentId] = fieldMatches; + } + else + { + MatchedFieldsByComponentId.Remove(componentId); + } + + tracker.SetVisible(i, (typeMatch || fieldMatch) ? 1 : 0); + } + } + + private static List GetMatchingSerializedFields(Editor editor, string filter) + { + List matches = new List(); + + SerializedObject serializedObject = editor.serializedObject; + if (serializedObject == null) + { + return matches; + } + + SerializedProperty iterator = serializedObject.GetIterator(); + bool enterChildren = true; + + while (iterator.NextVisible(enterChildren)) + { + enterChildren = false; + + if (!IsPropertyMatch(iterator, filter)) + { + continue; + } + + string label = iterator.displayName; + if (!matches.Contains(label)) + { + matches.Add(label); + } + } + + return matches; + } + } + + [CustomEditor(typeof(Component), true, isFallback = true)] + [CanEditMultipleObjects] + public class InspectorFilterComponentEditor : Editor + { + private static readonly Color HighlightColor = new Color(0.5058824f, 0.7058824f, 1f, 1f); + + public override void OnInspectorGUI() + { + Component component = target as Component; + if (component == null || !InspectorFilter.TryGetFilterForGameObject(component.gameObject, out string filter)) + { + DrawDefaultInspector(); + return; + } + + serializedObject.Update(); + + SerializedProperty property = serializedObject.GetIterator(); + bool enterChildren = true; + + while (property.NextVisible(enterChildren)) + { + enterChildren = false; + + using (new EditorGUI.DisabledScope(property.propertyPath == "m_Script")) + { + float height = EditorGUI.GetPropertyHeight(property, true); + Rect rect = EditorGUILayout.GetControlRect(true, height); + + if (InspectorFilter.IsPropertyMatch(property, filter)) + { + DrawBorder(rect, HighlightColor, 1f); + } + + EditorGUI.PropertyField(rect, property, true); + } + } + + serializedObject.ApplyModifiedProperties(); + } + + private static void DrawBorder(Rect rect, Color color, float thickness) + { + EditorGUI.DrawRect(new Rect(rect.xMin, rect.yMin, rect.width, thickness), color); + EditorGUI.DrawRect(new Rect(rect.xMin, rect.yMax - thickness, rect.width, thickness), color); + EditorGUI.DrawRect(new Rect(rect.xMin, rect.yMin, thickness, rect.height), color); + EditorGUI.DrawRect(new Rect(rect.xMax - thickness, rect.yMin, thickness, rect.height), color); + } + } + +} From eb10673b60e667a8b2091142b0710d1e9c77b8c6 Mon Sep 17 00:00:00 2001 From: mika Date: Wed, 22 Apr 2026 10:30:58 +0300 Subject: [PATCH 06/26] Add PivotAligner tool for model alignment in Unity This script provides a Unity Editor window for aligning 3D models by selecting a custom pivot point. It allows users to rotate and translate the source model around the chosen pivot. --- Assets/Scripts/Editor/Tools/PivotAligner.cs | 615 ++++++++++++++++++++ 1 file changed, 615 insertions(+) create mode 100644 Assets/Scripts/Editor/Tools/PivotAligner.cs diff --git a/Assets/Scripts/Editor/Tools/PivotAligner.cs b/Assets/Scripts/Editor/Tools/PivotAligner.cs new file mode 100644 index 0000000..a03ca8e --- /dev/null +++ b/Assets/Scripts/Editor/Tools/PivotAligner.cs @@ -0,0 +1,615 @@ +/// +/// PivotAligner — Unity Editor Window +/// Align two 3D models by picking a custom pivot point (vertex or face center) +/// on the source model, then rotating/translating it around that point. +/// +/// Place this file inside any Editor/ folder in your project. +/// Open via: Tools/UnityLibrary/Pivot Aligner +/// + +using UnityEngine; +using UnityEditor; + +namespace UnityLibrary.Tools +{ + public class PivotAligner : EditorWindow + { + // ────────────────────────────────────────────────────────────────────────── + // Enums & constants + // ────────────────────────────────────────────────────────────────────────── + + enum PickMode { Vertex, Face } + enum ToolState { Idle, Picking, Rotating } + + const string MENU_PATH = "Tools/UnityLibrary/Pivot Aligner"; + const float GIZMO_RADIUS = 0.06f; + const float GIZMO_CROSS = 0.25f; + + // ────────────────────────────────────────────────────────────────────────── + // Inspector / serialised fields + // ────────────────────────────────────────────────────────────────────────── + + [SerializeField] GameObject sourceObject; + [SerializeField] PickMode pickMode = PickMode.Vertex; + + // ── Rotation ────────────────────────────────────────────────────────────── + // Coarse float fields (full range, typed or dragged) + float rotX, rotY, rotZ; + + // Fine-tune additive deltas (±fineTuneRange degrees, applied on top of coarse) + bool showFinetune = false; + float fineTuneRange = 5f; + float fineX, fineY, fineZ; + + // ── Position offset ─────────────────────────────────────────────────────── + // Shifts the model in world space AND moves the pivot so subsequent + // rotations keep the same relative geometry. + bool showPosOffset = false; + float posOffsetX, posOffsetY, posOffsetZ; + float finePosRange = 0.1f; + + // ────────────────────────────────────────────────────────────────────────── + // Runtime state + // ────────────────────────────────────────────────────────────────────────── + + ToolState state = ToolState.Idle; + Vector3 pivotWorld = Vector3.zero; + bool hasPivot = false; + + // Snapshot taken when pivot is confirmed – rotation is always rebuilt from + // this base so there is no floating-point drift on repeated slider edits. + Vector3 basePosition; + Quaternion baseRotation; + + // Highlight during picking + Vector3 highlightPoint = Vector3.zero; + Vector3 highlightNormal = Vector3.up; + bool hasHighlight = false; + + // Scroll view + Vector2 scroll; + + // Style cache + GUIStyle headerStyle, sectionStyle, stateStyle, subLabelStyle; + bool stylesInit; + + // ────────────────────────────────────────────────────────────────────────── + // Window lifecycle + // ────────────────────────────────────────────────────────────────────────── + + [MenuItem(MENU_PATH)] + public static void ShowWindow() + { + var win = GetWindow("Pivot Aligner"); + win.minSize = new Vector2(440, 520); + } + + void OnEnable() + { + SceneView.duringSceneGui += OnSceneGUI; + titleContent = new GUIContent("Pivot Aligner", + EditorGUIUtility.IconContent("d_ToolHandleLocal").image); + } + + void OnDisable() + { + SceneView.duringSceneGui -= OnSceneGUI; + CancelPicking(); + } + + // ────────────────────────────────────────────────────────────────────────── + // Editor Window GUI + // ────────────────────────────────────────────────────────────────────────── + + void OnGUI() + { + InitStyles(); + scroll = EditorGUILayout.BeginScrollView(scroll); + + // ── Header ──────────────────────────────────────────────────────────── + EditorGUILayout.Space(6); + EditorGUILayout.LabelField("PIVOT ALIGNER", headerStyle); + EditorGUILayout.Space(2); + DrawHR(); + + // ── 1 · Source Model ───────────────────────────────────────────────── + EditorGUILayout.Space(6); + EditorGUILayout.LabelField("1 · Source Model", sectionStyle); + EditorGUI.BeginChangeCheck(); + sourceObject = (GameObject)EditorGUILayout.ObjectField( + "Game Object", sourceObject, typeof(GameObject), true); + if (EditorGUI.EndChangeCheck()) ResetTool(); + + if (sourceObject == null) + { + EditorGUILayout.HelpBox("Assign a GameObject to begin.", MessageType.Info); + EditorGUILayout.EndScrollView(); + return; + } + + // ── 2 · Pick Mode ───────────────────────────────────────────────────── + EditorGUILayout.Space(8); + EditorGUILayout.LabelField("2 · Pick Mode", sectionStyle); + EditorGUILayout.BeginHorizontal(); + if (DrawModeButton(" Vertex", pickMode == PickMode.Vertex)) + { pickMode = PickMode.Vertex; hasHighlight = false; } + if (DrawModeButton(" Face", pickMode == PickMode.Face)) + { pickMode = PickMode.Face; hasHighlight = false; } + EditorGUILayout.EndHorizontal(); + + // ── 3 · Pivot Point ─────────────────────────────────────────────────── + EditorGUILayout.Space(8); + EditorGUILayout.LabelField("3 · Select Pivot Point", sectionStyle); + + using (new EditorGUI.DisabledScope(state == ToolState.Rotating)) + { + if (state != ToolState.Picking) + { + if (GUILayout.Button("⊕ Select Target Point in Scene", GUILayout.Height(30))) + BeginPicking(); + } + else + { + Color prev = GUI.backgroundColor; + GUI.backgroundColor = new Color(1f, 0.55f, 0.15f); + if (GUILayout.Button("✕ Cancel Picking", GUILayout.Height(30))) + CancelPicking(); + GUI.backgroundColor = prev; + EditorGUILayout.HelpBox( + $"Hover model → {(pickMode == PickMode.Vertex ? "vertex" : "face center")} highlights. Click to confirm pivot.", + MessageType.None); + } + } + + if (hasPivot) + { + EditorGUILayout.Space(2); + using (new EditorGUILayout.HorizontalScope()) + { + EditorGUILayout.LabelField($"Pivot {pivotWorld:F4}", subLabelStyle); + if (GUILayout.Button("Re-pick", GUILayout.Width(56), GUILayout.Height(18))) + BeginPicking(); + } + } + + // ── 4 · Rotation ────────────────────────────────────────────────────── + EditorGUILayout.Space(8); + DrawHR(); + EditorGUILayout.Space(4); + EditorGUILayout.LabelField("4 · Rotation Around Pivot", sectionStyle); + + using (new EditorGUI.DisabledScope(!hasPivot)) + { + // Coarse float input rows + bool dirty = false; + EditorGUI.BeginChangeCheck(); + DrawRotRow("Pitch X", ref rotX); + DrawRotRow("Yaw Y", ref rotY); + DrawRotRow("Roll Z", ref rotZ); + if (EditorGUI.EndChangeCheck()) dirty = true; + + // Fine-tune + EditorGUILayout.Space(4); + using (new EditorGUILayout.HorizontalScope()) + { + showFinetune = EditorGUILayout.ToggleLeft("Fine-tune ±", showFinetune, GUILayout.Width(102)); + using (new EditorGUI.DisabledScope(!showFinetune)) + fineTuneRange = Mathf.Max(0.001f, EditorGUILayout.FloatField(fineTuneRange, GUILayout.Width(52))); + EditorGUILayout.LabelField("°", subLabelStyle, GUILayout.Width(14)); + } + + if (showFinetune) + { + EditorGUI.BeginChangeCheck(); + fineX = DrawFineRotSlider(" Δ Pitch X", fineX, fineTuneRange); + fineY = DrawFineRotSlider(" Δ Yaw Y", fineY, fineTuneRange); + fineZ = DrawFineRotSlider(" Δ Roll Z", fineZ, fineTuneRange); + if (EditorGUI.EndChangeCheck()) dirty = true; + } + + if (dirty && hasPivot) ApplyAll("Pivot Aligner — Rotate"); + + EditorGUILayout.Space(4); + using (new EditorGUILayout.HorizontalScope()) + { + if (GUILayout.Button("Reset All Rotation", GUILayout.Height(24))) + ResetRotation(); + if (showFinetune && GUILayout.Button("Reset Fine", GUILayout.Width(80), GUILayout.Height(24))) + { fineX = fineY = fineZ = 0f; if (hasPivot) ApplyAll("Pivot Aligner — Rotate"); } + } + } + + // ── 5 · Position Offset ─────────────────────────────────────────────── + EditorGUILayout.Space(8); + DrawHR(); + EditorGUILayout.Space(4); + + using (new EditorGUILayout.HorizontalScope()) + { + showPosOffset = EditorGUILayout.Foldout(showPosOffset, "5 · Position Offset", true, sectionStyle); + EditorGUILayout.LabelField("(moves pivot too)", subLabelStyle); + } + + if (showPosOffset) + { + using (new EditorGUI.DisabledScope(!hasPivot)) + { + // Slider range control + using (new EditorGUILayout.HorizontalScope()) + { + EditorGUILayout.LabelField("Slider range ±", subLabelStyle, GUILayout.Width(102)); + finePosRange = Mathf.Max(0.0001f, EditorGUILayout.FloatField(finePosRange, GUILayout.Width(52))); + EditorGUILayout.LabelField("m", subLabelStyle, GUILayout.Width(14)); + } + + EditorGUILayout.Space(2); + + EditorGUI.BeginChangeCheck(); + posOffsetX = DrawOffsetSliderRow("Offset X", posOffsetX, finePosRange); + posOffsetY = DrawOffsetSliderRow("Offset Y", posOffsetY, finePosRange); + posOffsetZ = DrawOffsetSliderRow("Offset Z", posOffsetZ, finePosRange); + if (EditorGUI.EndChangeCheck() && hasPivot) + ApplyAll("Pivot Aligner — Move"); + + EditorGUILayout.Space(3); + if (GUILayout.Button("Reset Position Offset", GUILayout.Height(24))) + ResetPositionOffset(); + } + } + + // ── Apply / Revert ──────────────────────────────────────────────────── + EditorGUILayout.Space(8); + DrawHR(); + EditorGUILayout.Space(4); + + using (new EditorGUI.DisabledScope(!hasPivot)) + { + Color prev = GUI.backgroundColor; + GUI.backgroundColor = new Color(0.22f, 0.80f, 0.40f); + if (GUILayout.Button("✔ Apply & Clear Pivot", GUILayout.Height(36))) + Apply(); + GUI.backgroundColor = prev; + } + + if (hasPivot) + { + if (GUILayout.Button("↺ Cancel & Revert to Original", GUILayout.Height(26))) + RevertAndReset(); + } + + // ── Status bar ──────────────────────────────────────────────────────── + EditorGUILayout.Space(4); + string totalRot = hasPivot + ? $"rot({rotX + fineX:F3}, {rotY + fineY:F3}, {rotZ + fineZ:F3})° " + + $"pos offset({posOffsetX:F4}, {posOffsetY:F4}, {posOffsetZ:F4}) m" + : ""; + string stateLabel = state switch + { + ToolState.Picking => "● PICKING", + ToolState.Rotating => $"● ROTATING {totalRot}", + _ => "○ idle" + }; + EditorGUILayout.LabelField(stateLabel, stateStyle); + EditorGUILayout.Space(4); + EditorGUILayout.EndScrollView(); + + SceneView.RepaintAll(); + } + + // ────────────────────────────────────────────────────────────────────────── + // Row helpers + // ────────────────────────────────────────────────────────────────────────── + + /// Radio-style button: highlighted when active, always clickable, returns true on click. + bool DrawModeButton(string label, bool active) + { + Color prev = GUI.backgroundColor; + if (active) GUI.backgroundColor = new Color(0.3f, 0.65f, 1f); + bool clicked = GUILayout.Button(label, GUILayout.Height(26)); + GUI.backgroundColor = prev; + return clicked; + } + + /// Coarse rotation row: label | float field | quick-snap buttons + void DrawRotRow(string label, ref float value) + { + using (new EditorGUILayout.HorizontalScope()) + { + EditorGUILayout.LabelField(label, GUILayout.Width(72)); + value = EditorGUILayout.FloatField(value, GUILayout.Width(74)); + if (GUILayout.Button("-90", GUILayout.Width(36), GUILayout.Height(18))) value -= 90f; + if (GUILayout.Button("-45", GUILayout.Width(36), GUILayout.Height(18))) value -= 45f; + if (GUILayout.Button("0", GUILayout.Width(28), GUILayout.Height(18))) value = 0f; + if (GUILayout.Button("+45", GUILayout.Width(36), GUILayout.Height(18))) value += 45f; + if (GUILayout.Button("+90", GUILayout.Width(36), GUILayout.Height(18))) value += 90f; + } + } + + /// Fine rotation slider: returns new value. + float DrawFineRotSlider(string label, float value, float range) + { + using (new EditorGUILayout.HorizontalScope()) + { + EditorGUILayout.LabelField(label, subLabelStyle, GUILayout.Width(76)); + value = GUILayout.HorizontalSlider(value, -range, range); + value = EditorGUILayout.FloatField(value, GUILayout.Width(64)); + EditorGUILayout.LabelField("°", subLabelStyle, GUILayout.Width(14)); + } + return value; + } + + /// Position offset row: slider + float field + zero button. Direct value, no delta accumulation. + float DrawOffsetSliderRow(string label, float value, float range) + { + using (new EditorGUILayout.HorizontalScope()) + { + EditorGUILayout.LabelField(label, GUILayout.Width(72)); + value = GUILayout.HorizontalSlider(value, -range, range); + value = EditorGUILayout.FloatField(value, GUILayout.Width(74)); + EditorGUILayout.LabelField("m", subLabelStyle, GUILayout.Width(14)); + if (GUILayout.Button("0", GUILayout.Width(24), GUILayout.Height(18))) value = 0f; + } + return value; + } + + // ────────────────────────────────────────────────────────────────────────── + // Scene GUI + // ────────────────────────────────────────────────────────────────────────── + + void OnSceneGUI(SceneView sv) + { + if (sourceObject == null) return; + if (hasPivot) DrawPivotGizmo(pivotWorld, Color.cyan); + if (state == ToolState.Picking) HandlePicking(sv); + } + + void HandlePicking(SceneView sv) + { + Event e = Event.current; + if (e.type == EventType.Layout) + HandleUtility.AddDefaultControl(GUIUtility.GetControlID(FocusType.Passive)); + + if (e.type == EventType.MouseMove || e.type == EventType.MouseDown) + { + Ray ray = HandleUtility.GUIPointToWorldRay(e.mousePosition); + TryRaycast(ray, out hasHighlight, out highlightPoint, out highlightNormal); + if (hasHighlight) + DrawPivotGizmo(highlightPoint, new Color(1f, 0.8f, 0.1f, 0.9f)); + if (e.type == EventType.MouseDown && e.button == 0 && hasHighlight) + { ConfirmPivot(highlightPoint); e.Use(); } + sv.Repaint(); + } + if (hasHighlight) + DrawPivotGizmo(highlightPoint, new Color(1f, 0.8f, 0.1f, 0.9f)); + } + + // ────────────────────────────────────────────────────────────────────────── + // Raycasting + // ────────────────────────────────────────────────────────────────────────── + + void TryRaycast(Ray ray, out bool hit, out Vector3 point, out Vector3 normal) + { + hit = false; point = Vector3.zero; normal = Vector3.up; + var filters = sourceObject.GetComponentsInChildren(); + float bestDist = float.MaxValue; + + foreach (var mf in filters) + { + if (mf.sharedMesh == null) continue; + Mesh mesh = mf.sharedMesh; + Transform t = mf.transform; + Ray localRay = new Ray( + t.InverseTransformPoint(ray.origin), + t.InverseTransformDirection(ray.direction).normalized); + + Vector3[] verts = mesh.vertices; + int[] tris = mesh.triangles; + Vector3[] normals = mesh.normals; + + for (int i = 0; i < tris.Length; i += 3) + { + Vector3 v0 = verts[tris[i]], v1 = verts[tris[i + 1]], v2 = verts[tris[i + 2]]; + if (!RayTriangle(localRay, v0, v1, v2, out float dist, out float u, out float v)) continue; + if (dist < 0 || dist >= bestDist) continue; + bestDist = dist; hit = true; + + if (pickMode == PickMode.Vertex) + { + float w = 1f - u - v; + int vi = FindNearestVertex(u, v, w); + point = t.TransformPoint(vi == 0 ? v0 : vi == 1 ? v1 : v2); + } + else point = t.TransformPoint((v0 + v1 + v2) / 3f); + + Vector3 n0 = normals.Length > tris[i] ? normals[tris[i]] : Vector3.up; + Vector3 n1 = normals.Length > tris[i + 1] ? normals[tris[i + 1]] : Vector3.up; + Vector3 n2 = normals.Length > tris[i + 2] ? normals[tris[i + 2]] : Vector3.up; + normal = t.TransformDirection((n0 * (1 - u - v) + n1 * u + n2 * v).normalized); + } + } + } + + static bool RayTriangle(Ray ray, Vector3 v0, Vector3 v1, Vector3 v2, + out float dist, out float u, out float v) + { + dist = u = v = 0; + Vector3 e1 = v1 - v0, e2 = v2 - v0, h = Vector3.Cross(ray.direction, e2); + float det = Vector3.Dot(e1, h); + if (Mathf.Abs(det) < 1e-6f) return false; + float f = 1f / det; + Vector3 s = ray.origin - v0; + u = f * Vector3.Dot(s, h); + if (u < 0 || u > 1) return false; + Vector3 q = Vector3.Cross(s, e1); + v = f * Vector3.Dot(ray.direction, q); + if (v < 0 || u + v > 1) return false; + dist = f * Vector3.Dot(e2, q); + return dist > 1e-5f; + } + + static int FindNearestVertex(float u, float v, float w) + { + if (w >= u && w >= v) return 0; + if (u >= w && u >= v) return 1; + return 2; + } + + // ────────────────────────────────────────────────────────────────────────── + // Gizmo drawing + // ────────────────────────────────────────────────────────────────────────── + + void DrawPivotGizmo(Vector3 pos, Color color) + { + Handles.color = color; + Handles.SphereHandleCap(0, pos, Quaternion.identity, + GIZMO_RADIUS * HandleUtility.GetHandleSize(pos), EventType.Repaint); + float sz = GIZMO_CROSS * HandleUtility.GetHandleSize(pos); + Handles.DrawLine(pos - Vector3.right * sz, pos + Vector3.right * sz); + Handles.DrawLine(pos - Vector3.up * sz, pos + Vector3.up * sz); + Handles.DrawLine(pos - Vector3.forward * sz, pos + Vector3.forward * sz); + GUIStyle s = new GUIStyle(EditorStyles.miniLabel) { normal = { textColor = color } }; + Handles.Label(pos + Vector3.up * sz * 1.5f, + (hasPivot && pos == pivotWorld) ? "PIVOT" : "○", s); + } + + // ────────────────────────────────────────────────────────────────────────── + // State transitions + // ────────────────────────────────────────────────────────────────────────── + + void BeginPicking() + { + if (sourceObject == null) return; + state = ToolState.Picking; hasHighlight = false; + SceneView.RepaintAll(); + } + + void CancelPicking() + { + if (state == ToolState.Picking) + state = hasPivot ? ToolState.Rotating : ToolState.Idle; + hasHighlight = false; SceneView.RepaintAll(); + } + + void ConfirmPivot(Vector3 worldPoint) + { + if (hasPivot && state == ToolState.Rotating) RevertTransform(); + pivotWorld = worldPoint; + hasPivot = true; + state = ToolState.Rotating; + hasHighlight = false; + basePosition = sourceObject.transform.position; + baseRotation = sourceObject.transform.rotation; + rotX = rotY = rotZ = 0f; + fineX = fineY = fineZ = 0f; + posOffsetX = posOffsetY = posOffsetZ = 0f; + Repaint(); SceneView.RepaintAll(); + } + + // ────────────────────────────────────────────────────────────────────────── + // Transform computation — single source of truth + // ────────────────────────────────────────────────────────────────────────── + + // Each continuous drag (slider or float field) collapses into a single undo + // step by using the same group name while the control is hot, then + // incrementing undoGroupIndex when the user releases (EndChangeCheck fires + // but the control is no longer hot on the next frame). + int undoGroupIndex = 0; + int lastHotControl = 0; + string lastUndoLabel = ""; + + void ApplyAll(string undoLabel = "Pivot Aligner") + { + if (sourceObject == null || !hasPivot) return; + + // Start a new undo group whenever the active control changes or the + // label changes (e.g. switching from Rotate to Move). + int hot = GUIUtility.hotControl; + if (hot != lastHotControl || undoLabel != lastUndoLabel) + { + undoGroupIndex++; + lastHotControl = hot; + lastUndoLabel = undoLabel; + } + + Undo.RecordObject(sourceObject.transform, undoLabel); + + Quaternion delta = Quaternion.Euler(rotX + fineX, rotY + fineY, rotZ + fineZ); + Vector3 posOff = new Vector3(posOffsetX, posOffsetY, posOffsetZ); + + sourceObject.transform.position = pivotWorld + delta * (basePosition - pivotWorld) + posOff; + sourceObject.transform.rotation = delta * baseRotation; + + // Collapse all RecordObject calls for this drag into one undo step + Undo.CollapseUndoOperations(Undo.GetCurrentGroup() - undoGroupIndex + 1); + } + + void ResetRotation() + { + rotX = rotY = rotZ = fineX = fineY = fineZ = 0f; + ApplyAll("Pivot Aligner — Reset Rotation"); + } + + void ResetPositionOffset() + { + posOffsetX = posOffsetY = posOffsetZ = 0f; + ApplyAll("Pivot Aligner — Reset Offset"); + } + + void Apply() + { + if (sourceObject == null) return; + Undo.SetCurrentGroupName("Pivot Aligner Apply"); + Undo.CollapseUndoOperations(Undo.GetCurrentGroup()); + ResetTool(); + } + + void RevertAndReset() { RevertTransform(); ResetTool(); } + + void RevertTransform() + { + if (sourceObject == null || !hasPivot) return; + Undo.RecordObject(sourceObject.transform, "Pivot Aligner Revert"); + sourceObject.transform.position = basePosition; + sourceObject.transform.rotation = baseRotation; + } + + void ResetTool() + { + state = ToolState.Idle; hasPivot = hasHighlight = false; + rotX = rotY = rotZ = fineX = fineY = fineZ = 0f; + posOffsetX = posOffsetY = posOffsetZ = 0f; + SceneView.RepaintAll(); Repaint(); + } + + // ────────────────────────────────────────────────────────────────────────── + // Styles & layout helpers + // ────────────────────────────────────────────────────────────────────────── + + void InitStyles() + { + if (stylesInit) return; + stylesInit = true; + headerStyle = new GUIStyle(EditorStyles.boldLabel) + { + fontSize = 13, + alignment = TextAnchor.MiddleCenter, + normal = { textColor = new Color(0.65f, 0.88f, 1f) } + }; + sectionStyle = new GUIStyle(EditorStyles.boldLabel) + { normal = { textColor = new Color(0.85f, 0.85f, 0.85f) } }; + stateStyle = new GUIStyle(EditorStyles.miniLabel) + { + alignment = TextAnchor.MiddleRight, + normal = { textColor = new Color(0.40f, 0.75f, 0.50f) } + }; + subLabelStyle = new GUIStyle(EditorStyles.miniLabel) + { normal = { textColor = new Color(0.55f, 0.55f, 0.55f) } }; + } + + void DrawHR() + { + Rect r = EditorGUILayout.GetControlRect(false, 1); + EditorGUI.DrawRect(r, new Color(0.35f, 0.35f, 0.35f, 0.6f)); + } + } +} From 895372d41eeb615278d3c1c2add9b4cd08e2a6a4 Mon Sep 17 00:00:00 2001 From: mika Date: Mon, 11 May 2026 09:26:18 +0300 Subject: [PATCH 07/26] Add UVChannelDebug shader for UV data visualization This shader provides a debug view of UV channels, allowing visualization of UV data across multiple channels with customizable colors and toggles for each channel. --- Assets/Shaders/3D/Debug/UVChannelDebug.shader | 150 ++++++++++++++++++ 1 file changed, 150 insertions(+) create mode 100644 Assets/Shaders/3D/Debug/UVChannelDebug.shader diff --git a/Assets/Shaders/3D/Debug/UVChannelDebug.shader b/Assets/Shaders/3D/Debug/UVChannelDebug.shader new file mode 100644 index 0000000..b0b2c86 --- /dev/null +++ b/Assets/Shaders/3D/Debug/UVChannelDebug.shader @@ -0,0 +1,150 @@ +// debug view what channels contain UV data + +Shader "UnityLibrary/Debug/UVChannelDebug" +{ + Properties + { + _MainTex ("Texture", 2D) = "white" {} + _ColorUV0 ("UV0 Color", Color) = (1,0,0,1) + _ColorUV1 ("UV1 Color", Color) = (0,1,0,1) + _ColorUV2 ("UV2 Color", Color) = (0,0,1,1) + _ColorUV3 ("UV3 Color", Color) = (1,1,0,1) + _ColorUV4 ("UV4 Color", Color) = (1,0,1,1) + _ColorUV5 ("UV5 Color", Color) = (0,1,1,1) + _ColorUV6 ("UV6 Color", Color) = (1,1,1,1) + _ColorUV7 ("UV7 Color", Color) = (0,0,0,1) + + [Toggle] _EnableUV0 ("Enable UV0", Float) = 1 + [Toggle] _EnableUV1 ("Enable UV1", Float) = 1 + [Toggle] _EnableUV2 ("Enable UV2", Float) = 1 + [Toggle] _EnableUV3 ("Enable UV3", Float) = 1 + [Toggle] _EnableUV4 ("Enable UV4", Float) = 1 + [Toggle] _EnableUV5 ("Enable UV5", Float) = 1 + [Toggle] _EnableUV6 ("Enable UV6", Float) = 1 + [Toggle] _EnableUV7 ("Enable UV7", Float) = 1 + } + SubShader + { + Tags { "RenderType"="Opaque" } + LOD 100 + + Pass + { + CGPROGRAM + #pragma vertex vert + #pragma fragment frag + + #include "UnityCG.cginc" + + struct appdata + { + float4 vertex : POSITION; + float2 uv0 : TEXCOORD0; + float2 uv1 : TEXCOORD1; + float2 uv2 : TEXCOORD2; + float2 uv3 : TEXCOORD3; + float2 uv4 : TEXCOORD4; + float2 uv5 : TEXCOORD5; + float2 uv6 : TEXCOORD6; + float2 uv7 : TEXCOORD7; + }; + + struct v2f + { + float2 uv0 : TEXCOORD0; + float2 uv1 : TEXCOORD1; + float2 uv2 : TEXCOORD2; + float2 uv3 : TEXCOORD3; + float2 uv4 : TEXCOORD4; + float2 uv5 : TEXCOORD5; + float2 uv6 : TEXCOORD6; + float2 uv7 : TEXCOORD7; + float4 vertex : SV_POSITION; + }; + + sampler2D _MainTex; + float4 _MainTex_ST; + float4 _ColorUV0; + float4 _ColorUV1; + float4 _ColorUV2; + float4 _ColorUV3; + float4 _ColorUV4; + float4 _ColorUV5; + float4 _ColorUV6; + float4 _ColorUV7; + + float _EnableUV0; + float _EnableUV1; + float _EnableUV2; + float _EnableUV3; + float _EnableUV4; + float _EnableUV5; + float _EnableUV6; + float _EnableUV7; + + fixed UVChecker(float2 uv) + { + float2 cell = floor(uv * 8.0); + return fmod(cell.x + cell.y, 2.0); + } + + fixed HasUVData(float2 uv) + { + float variation = fwidth(uv.x) + fwidth(uv.y); + float magnitude = abs(uv.x) + abs(uv.y); + return step(1e-5, max(variation, magnitude)); + } + + v2f vert (appdata v) + { + v2f o; + o.vertex = UnityObjectToClipPos(v.vertex); + + o.uv0 = TRANSFORM_TEX(v.uv0, _MainTex); + o.uv1 = TRANSFORM_TEX(v.uv1, _MainTex); + o.uv2 = TRANSFORM_TEX(v.uv2, _MainTex); + o.uv3 = TRANSFORM_TEX(v.uv3, _MainTex); + o.uv4 = TRANSFORM_TEX(v.uv4, _MainTex); + o.uv5 = TRANSFORM_TEX(v.uv5, _MainTex); + o.uv6 = TRANSFORM_TEX(v.uv6, _MainTex); + o.uv7 = TRANSFORM_TEX(v.uv7, _MainTex); + + return o; + } + + fixed4 frag (v2f i) : SV_Target + { + fixed4 col0 = tex2D(_MainTex, i.uv0) * _ColorUV0; + fixed4 col1 = tex2D(_MainTex, i.uv1) * _ColorUV1; + fixed4 col2 = tex2D(_MainTex, i.uv2) * _ColorUV2; + fixed4 col3 = tex2D(_MainTex, i.uv3) * _ColorUV3; + fixed4 col4 = tex2D(_MainTex, i.uv4) * _ColorUV4; + fixed4 col5 = tex2D(_MainTex, i.uv5) * _ColorUV5; + fixed4 col6 = tex2D(_MainTex, i.uv6) * _ColorUV6; + fixed4 col7 = tex2D(_MainTex, i.uv7) * _ColorUV7; + + float e0 = _EnableUV0 * HasUVData(i.uv0); + float e1 = _EnableUV1 * HasUVData(i.uv1); + float e2 = _EnableUV2 * HasUVData(i.uv2); + float e3 = _EnableUV3 * HasUVData(i.uv3); + float e4 = _EnableUV4 * HasUVData(i.uv4); + float e5 = _EnableUV5 * HasUVData(i.uv5); + float e6 = _EnableUV6 * HasUVData(i.uv6); + float e7 = _EnableUV7 * HasUVData(i.uv7); + + fixed4 col = + col0 * e0 + + col1 * e1 + + col2 * e2 + + col3 * e3 + + col4 * e4 + + col5 * e5 + + col6 * e6 + + col7 * e7; + + return saturate(col); + } + ENDCG + } + } +} From 66011d1122c178fbe461e4056700fbf017513f21 Mon Sep 17 00:00:00 2001 From: mika Date: Sat, 23 May 2026 14:15:05 +0300 Subject: [PATCH 08/26] Add custom favorites buttons to Package Manager This script adds custom buttons to the Package Manager's left panel, allowing users to manage their favorite packages directly from the editor. It includes functionality for adding packages and injecting UI elements into the Package Manager window. --- .../PackageManager/PackageManagerFavorites.cs | 326 ++++++++++++++++++ 1 file changed, 326 insertions(+) create mode 100644 Assets/Scripts/Editor/PackageManager/PackageManagerFavorites.cs diff --git a/Assets/Scripts/Editor/PackageManager/PackageManagerFavorites.cs b/Assets/Scripts/Editor/PackageManager/PackageManagerFavorites.cs new file mode 100644 index 0000000..1ccc0f1 --- /dev/null +++ b/Assets/Scripts/Editor/PackageManager/PackageManagerFavorites.cs @@ -0,0 +1,326 @@ +// adds custom buttons into PackageManager left panel (tested in 6.5) +// edit your own favorites in the code + +#if UNITY_EDITOR +using System; +using System.Collections.Generic; +using UnityEditor; +using UnityEditor.Compilation; +using UnityEditor.PackageManager; +using UnityEditor.PackageManager.Requests; +using UnityEngine; +using UnityEngine.UIElements; + +namespace UnityLibrary.Editor.Tools +{ + + [InitializeOnLoad] + public static class PackageManagerFavorites + { + private const string InjectedElementName = "kelobyte-package-manager-dummy-panel"; + private static double nextScanTime; + private static AddRequest addRequest; + private static string pendingPackageName; + + static PackageManagerFavorites() + { + EditorApplication.update += OnEditorUpdate; + } + + [MenuItem("Window/Package Management/Open Package Manager With Dummy Button")] + private static void OpenPackageManagerAndInject() + { + Type windowType = GetPackageManagerWindowType(); + + if (windowType == null) + { + Debug.LogWarning("Package Manager window type was not found."); + return; + } + + EditorWindow window = EditorWindow.GetWindow(windowType); + window.Show(); + + EditorApplication.delayCall += TryInject; + } + + private static void OnEditorUpdate() + { + if (EditorApplication.timeSinceStartup < nextScanTime) + return; + + nextScanTime = EditorApplication.timeSinceStartup + 0.5; + TryInject(); + } + + private static void TryInject() + { + Type windowType = GetPackageManagerWindowType(); + + if (windowType == null) + return; + + UnityEngine.Object[] windows = Resources.FindObjectsOfTypeAll(windowType); + + foreach (UnityEngine.Object obj in windows) + { + EditorWindow window = obj as EditorWindow; + + if (window == null) + continue; + + InjectIntoWindow(window); + } + } + + private static Type GetPackageManagerWindowType() + { + Type type = Type.GetType("UnityEditor.PackageManager.UI.PackageManagerWindow, UnityEditor.PackageManagerUIModule"); + + if (type != null) + return type; + + foreach (System.Reflection.Assembly assembly in AppDomain.CurrentDomain.GetAssemblies()) + { + type = assembly.GetType("UnityEditor.PackageManager.UI.PackageManagerWindow"); + + if (type != null) + return type; + } + + return null; + } + + private static void InjectIntoWindow(EditorWindow window) + { + VisualElement root = window.rootVisualElement; + + if (root == null) + return; + + if (root.Q(InjectedElementName) != null) + return; + + VisualElement insertParent = FindInsertParent(root); + int insertIndex = FindInsertIndex(insertParent); + + if (insertParent == null) + return; + + VisualElement panel = CreateDummyPanel(); + + if (insertIndex >= 0 && insertIndex <= insertParent.childCount) + insertParent.Insert(insertIndex, panel); + else + insertParent.Add(panel); + } + + private static VisualElement CreateDummyPanel() + { + VisualElement wrapper = new VisualElement(); + wrapper.name = InjectedElementName; + + wrapper.style.marginTop = 8; + wrapper.style.marginBottom = 8; + wrapper.style.paddingLeft = 6; + wrapper.style.paddingRight = 6; + + Foldout foldout = new Foldout(); + foldout.text = "Favorites"; + foldout.value = true; + + Button newtonsoftButton = CreatePackageButton( + "Newtonsoft Json", + "com.unity.nuget.newtonsoft-json" + ); + + Button gltfastButton = CreatePackageButton( + "Unity glTFast", + "com.unity.cloud.gltfast" + ); + + Button unityGltfButton = CreatePackageButton( + "Khronos UnityGLTF", + "https://github.com/KhronosGroup/UnityGLTF.git" + ); + + Button myEssentials = CreatePackageButton( + "Essentials", + " https://github.com/unitycoder/UnityEditorEssentials.git" + ); + + foldout.Add(newtonsoftButton); + foldout.Add(gltfastButton); + foldout.Add(unityGltfButton); + foldout.Add(myEssentials); + + wrapper.Add(foldout); + + return wrapper; + } + + private static Button CreatePackageButton(string label, string packageNameOrUrl) + { + Button button = new Button(() => + { + AddPackage(packageNameOrUrl); + }); + + button.text = label; + button.style.marginTop = 4; + button.style.height = 24; + + return button; + } + + private static void AddPackage(string packageNameOrUrl) + { + string packageToAdd = packageNameOrUrl.Trim(); + + if (addRequest != null && !addRequest.IsCompleted) + { + Debug.LogWarning("A package add request is already in progress."); + return; + } + + Debug.Log($"Adding package: {packageToAdd}"); + + pendingPackageName = packageToAdd; + addRequest = Client.Add(packageToAdd); + + EditorApplication.update -= MonitorAddPackageRequest; + EditorApplication.update += MonitorAddPackageRequest; + } + + private static void MonitorAddPackageRequest() + { + if (addRequest == null || !addRequest.IsCompleted) + return; + + EditorApplication.update -= MonitorAddPackageRequest; + + if (addRequest.Status == StatusCode.Success) + { + Debug.Log($"Package added: {pendingPackageName}"); + Client.Resolve(); + AssetDatabase.Refresh(); + CompilationPipeline.RequestScriptCompilation(); + } + else + { + string errorMessage = addRequest.Error != null ? addRequest.Error.message : "Unknown error."; + Debug.LogError($"Failed to add package '{pendingPackageName}': {errorMessage}"); + } + + addRequest = null; + pendingPackageName = null; + } + + private static VisualElement FindInsertParent(VisualElement root) + { + Label servicesLabel = FindLabel(root, "Services"); + + if (servicesLabel != null && servicesLabel.parent != null && servicesLabel.parent.parent != null) + return servicesLabel.parent.parent; + + Label cloudLabel = FindLabel(root, "Cloud"); + + if (cloudLabel != null && cloudLabel.parent != null && cloudLabel.parent.parent != null) + return cloudLabel.parent.parent; + + Label sourcesLabel = FindLabel(root, "Sources"); + + if (sourcesLabel != null && sourcesLabel.parent != null && sourcesLabel.parent.parent != null) + return sourcesLabel.parent.parent; + + return FindLikelyLeftPanel(root); + } + + private static int FindInsertIndex(VisualElement parent) + { + if (parent == null) + return -1; + + for (int i = 0; i < parent.childCount; i++) + { + VisualElement child = parent[i]; + + if (ContainsLabel(child, "Services")) + return i + 1; + } + + for (int i = 0; i < parent.childCount; i++) + { + VisualElement child = parent[i]; + + if (ContainsLabel(child, "Cloud")) + return i + 1; + } + + return -1; + } + + private static VisualElement FindLikelyLeftPanel(VisualElement root) + { + List all = new List(); + Collect(root, all); + + foreach (VisualElement element in all) + { + Rect rect = element.worldBound; + + if (rect.width > 120 && rect.width < 260 && rect.height > 250 && rect.x < 250) + return element; + } + + return null; + } + + private static Label FindLabel(VisualElement root, string text) + { + List all = new List(); + Collect(root, all); + + foreach (VisualElement element in all) + { + Label label = element as Label; + + if (label != null && label.text == text) + return label; + } + + return null; + } + + private static bool ContainsLabel(VisualElement root, string text) + { + if (root == null) + return false; + + Label label = root as Label; + + if (label != null && label.text == text) + return true; + + for (int i = 0; i < root.childCount; i++) + { + if (ContainsLabel(root[i], text)) + return true; + } + + return false; + } + + private static void Collect(VisualElement root, List elements) + { + if (root == null) + return; + + elements.Add(root); + + for (int i = 0; i < root.childCount; i++) + Collect(root[i], elements); + } + } +} +#endif From b4dacb90500646cda882ef9afae00d33a5788843 Mon Sep 17 00:00:00 2001 From: mika Date: Tue, 26 May 2026 10:18:41 +0300 Subject: [PATCH 09/26] Add ToggleEvents script for toggle state events --- Assets/Scripts/UI/ToggleEvents.cs | 44 +++++++++++++++++++++++++++++++ 1 file changed, 44 insertions(+) create mode 100644 Assets/Scripts/UI/ToggleEvents.cs diff --git a/Assets/Scripts/UI/ToggleEvents.cs b/Assets/Scripts/UI/ToggleEvents.cs new file mode 100644 index 0000000..b4f0952 --- /dev/null +++ b/Assets/Scripts/UI/ToggleEvents.cs @@ -0,0 +1,44 @@ +// easy way to get Toggle state as events (compared to the default OnChanged, which triggers on both..) + +using UnityEngine; +using UnityEngine.Events; +using UnityEngine.UI; + +namespace UnityLibrary.UI +{ + [RequireComponent(typeof(Toggle))] + public class ToggleEvents : MonoBehaviour + { + [Header("Events")] + public UnityEvent OnChecked; + public UnityEvent OnUnchecked; + + private Toggle toggle; + + private void Awake() + { + toggle = GetComponent(); + toggle.onValueChanged.AddListener(HandleToggleChanged); + } + + private void OnDestroy() + { + if (toggle != null) + { + toggle.onValueChanged.RemoveListener(HandleToggleChanged); + } + } + + private void HandleToggleChanged(bool isOn) + { + if (isOn) + { + OnChecked?.Invoke(); + } + else + { + OnUnchecked?.Invoke(); + } + } + } +} From 0f4758a2e4678c4ab64eb43768da84a42e46e486 Mon Sep 17 00:00:00 2001 From: mika Date: Sat, 30 May 2026 23:24:30 +0300 Subject: [PATCH 10/26] Create MeshThumbnailGrabberWindow.cs --- .../Tools/MeshThumbnailGrabberWindow.cs | 788 ++++++++++++++++++ 1 file changed, 788 insertions(+) create mode 100644 Assets/Scripts/Editor/Tools/MeshThumbnailGrabberWindow.cs diff --git a/Assets/Scripts/Editor/Tools/MeshThumbnailGrabberWindow.cs b/Assets/Scripts/Editor/Tools/MeshThumbnailGrabberWindow.cs new file mode 100644 index 0000000..f12e6bc --- /dev/null +++ b/Assets/Scripts/Editor/Tools/MeshThumbnailGrabberWindow.cs @@ -0,0 +1,788 @@ +// editortool to capture thumbnails of meshes, prefabs, or gameobjects with custom settings and save as PNG + +using System.Collections.Generic; +using System.IO; +using UnityEditor; +using UnityEngine; + +namespace UnityLibrary.Editor.Tools +{ + public class MeshThumbnailGrabberWindow : EditorWindow + { + private Object sourceObject; + + private PreviewRenderUtility previewUtility; + + private GameObject previewRoot; + private GameObject previewInstance; + + private Texture2D exportPreviewTexture; + + private readonly List drawables = new List(); + + private Vector2 orbit = new Vector2(135f, -20f); + + private float zoom = 1f; + private float fitDistance = 3f; + private float cameraDistanceMultiplier = 1f; + private float lightIntensity = 1.25f; + + private int outputWidth = 512; + private int outputHeight = 512; + + private Color backgroundColor = new Color(0f, 0f, 0f, 0f); + private Color ambientColor = new Color(0.35f, 0.35f, 0.35f, 1f); + private Color lightColor = Color.white; + + private bool drawGround = false; + + private struct PreviewDrawable + { + public Mesh Mesh; + public Matrix4x4 Matrix; + public Material[] Materials; + } + + [MenuItem("Tools/Thumbnail Grabber/Mesh Thumbnail Grabber")] + public static void Open() + { + var win = GetWindow("Mesh Thumbnail Grabber"); + win.minSize = new Vector2(500, 680); + } + + private void OnEnable() + { + CreatePreviewUtility(); + } + + private void OnDisable() + { + Cleanup(); + } + + private void CreatePreviewUtility() + { + if (previewUtility != null) + { + previewUtility.Cleanup(); + } + + previewUtility = new PreviewRenderUtility(true); + previewUtility.cameraFieldOfView = 30f; + + ApplyLightSettings(); + } + + private void Cleanup() + { + DestroyPreviewObjects(); + + if (previewUtility != null) + { + previewUtility.Cleanup(); + previewUtility = null; + } + + ClearExportPreview(); + } + + private void DestroyPreviewObjects() + { + drawables.Clear(); + + if (previewRoot != null) + { + DestroyImmediate(previewRoot); + previewRoot = null; + previewInstance = null; + } + } + + private void ClearExportPreview() + { + if (exportPreviewTexture != null) + { + DestroyImmediate(exportPreviewTexture); + exportPreviewTexture = null; + } + } + + private void OnGUI() + { + EditorGUILayout.Space(); + + using (new EditorGUILayout.VerticalScope(EditorStyles.helpBox)) + { + EditorGUI.BeginChangeCheck(); + + sourceObject = EditorGUILayout.ObjectField( + "Source", + sourceObject, + typeof(Object), + false + ); + + if (EditorGUI.EndChangeCheck()) + { + ClearExportPreview(); + CreatePreviewInstance(); + FitToView(); + Repaint(); + } + } + + using (new EditorGUILayout.VerticalScope(EditorStyles.helpBox)) + { + EditorGUI.BeginChangeCheck(); + + outputWidth = Mathf.Clamp(EditorGUILayout.IntField("Output Width", outputWidth), 16, 8192); + outputHeight = Mathf.Clamp(EditorGUILayout.IntField("Output Height", outputHeight), 16, 8192); + + if (EditorGUI.EndChangeCheck()) + { + ClearExportPreview(); + } + + zoom = EditorGUILayout.Slider("Zoom", zoom, 0.05f, 100f); + cameraDistanceMultiplier = EditorGUILayout.Slider("Distance Multiplier", cameraDistanceMultiplier, 0.1f, 5f); + + EditorGUI.BeginChangeCheck(); + + lightIntensity = EditorGUILayout.Slider("Light Intensity", lightIntensity, 0f, 5f); + ambientColor = EditorGUILayout.ColorField("Ambient Color", ambientColor); + lightColor = EditorGUILayout.ColorField("Light Color", lightColor); + drawGround = EditorGUILayout.Toggle("Draw Ground", drawGround); + + if (EditorGUI.EndChangeCheck()) + { + ApplyLightSettings(); + ClearExportPreview(); + + CenterObjectToOrigin(); + CacheDrawables(); + Repaint(); + } + } + + Rect previewRect = GUILayoutUtility.GetRect( + 10, + 10000, + 10, + 10000, + GUILayout.ExpandWidth(true), + GUILayout.ExpandHeight(true) + ); + + DrawInteractivePreview(previewRect); + + using (new EditorGUILayout.HorizontalScope()) + { + GUI.enabled = sourceObject != null; + + if (GUILayout.Button("Fit To View", GUILayout.Height(28))) + { + FitToView(); + ClearExportPreview(); + Repaint(); + } + + if (GUILayout.Button("Reset Rotation", GUILayout.Height(28))) + { + orbit = new Vector2(135f, -20f); + ClearExportPreview(); + Repaint(); + } + + if (GUILayout.Button("Preview Export Size", GUILayout.Height(28))) + { + UpdateExportPreview(); + } + + if (GUILayout.Button("Save PNG", GUILayout.Height(28))) + { + SavePng(); + } + + GUI.enabled = true; + } + + DrawExportPreviewPanel(); + } + + private void ApplyLightSettings() + { + if (previewUtility == null) + { + return; + } + + previewUtility.lights[0].intensity = lightIntensity; + previewUtility.lights[0].color = lightColor; + previewUtility.lights[0].transform.rotation = Quaternion.Euler(40f, 40f, 0f); + + previewUtility.lights[1].intensity = lightIntensity * 0.35f; + previewUtility.lights[1].color = lightColor; + previewUtility.lights[1].transform.rotation = Quaternion.Euler(340f, 218f, 177f); + } + + private void DrawInteractivePreview(Rect rect) + { + if (previewUtility == null) + { + CreatePreviewUtility(); + } + + if (sourceObject == null) + { + EditorGUI.DrawRect(rect, new Color(0.15f, 0.15f, 0.15f, 1f)); + GUI.Label(rect, "Assign a prefab, model, GameObject, or Mesh", EditorStyles.centeredGreyMiniLabel); + return; + } + + if (previewInstance == null) + { + CreatePreviewInstance(); + FitToView(); + } + + HandlePreviewInput(rect); + + Texture texture = RenderPreview(rect.width, rect.height); + + if (texture != null) + { + GUI.DrawTexture(rect, texture, ScaleMode.StretchToFill, true); + } + } + + private void HandlePreviewInput(Rect rect) + { + Event e = Event.current; + + if (!rect.Contains(e.mousePosition)) + { + return; + } + + if (e.type == EventType.MouseDrag && e.button == 0) + { + orbit += new Vector2(e.delta.x, -e.delta.y); + orbit.y = Mathf.Clamp(orbit.y, -89f, 89f); + + ClearExportPreview(); + + e.Use(); + Repaint(); + } + + if (e.type == EventType.ScrollWheel) + { + zoom *= 1f - e.delta.y * 0.08f; + zoom = Mathf.Clamp(zoom, 0.05f, 100f); + + ClearExportPreview(); + + e.Use(); + Repaint(); + } + } + + private void CreatePreviewInstance() + { + DestroyPreviewObjects(); + + if (sourceObject == null) + { + return; + } + + previewRoot = new GameObject("Thumbnail Preview Root"); + previewRoot.hideFlags = HideFlags.HideAndDontSave; + previewRoot.transform.position = Vector3.zero; + previewRoot.transform.rotation = Quaternion.identity; + previewRoot.transform.localScale = Vector3.one; + + GameObject sourceGameObject = sourceObject as GameObject; + Mesh sourceMesh = sourceObject as Mesh; + + if (sourceGameObject != null) + { + previewInstance = Instantiate(sourceGameObject, previewRoot.transform); + previewInstance.hideFlags = HideFlags.HideAndDontSave; + } + else if (sourceMesh != null) + { + previewInstance = new GameObject("Mesh Preview Instance"); + previewInstance.hideFlags = HideFlags.HideAndDontSave; + previewInstance.transform.SetParent(previewRoot.transform, false); + + MeshFilter meshFilter = previewInstance.AddComponent(); + meshFilter.sharedMesh = sourceMesh; + + MeshRenderer meshRenderer = previewInstance.AddComponent(); + meshRenderer.sharedMaterial = GetDefaultMaterial(); + } + else + { + string path = AssetDatabase.GetAssetPath(sourceObject); + GameObject loaded = AssetDatabase.LoadAssetAtPath(path); + + if (loaded != null) + { + previewInstance = Instantiate(loaded, previewRoot.transform); + previewInstance.hideFlags = HideFlags.HideAndDontSave; + } + } + + if (previewInstance == null) + { + DestroyPreviewObjects(); + return; + } + + DisableSceneOnlyComponents(previewInstance); + + previewInstance.transform.localPosition = Vector3.zero; + previewInstance.transform.localRotation = Quaternion.identity; + previewInstance.transform.localScale = Vector3.one; + + CenterObjectToOrigin(); + CacheDrawables(); + } + + private void CenterObjectToOrigin() + { + if (previewRoot == null || previewInstance == null) + { + return; + } + + previewRoot.transform.position = Vector3.zero; + previewRoot.transform.rotation = Quaternion.identity; + previewRoot.transform.localScale = Vector3.one; + + previewInstance.transform.localPosition = Vector3.zero; + + Bounds bounds = GetWorldBounds(previewRoot); + Vector3 centerOffset = bounds.center; + + previewInstance.transform.position -= centerOffset; + + if (drawGround) + { + Bounds centeredBounds = GetWorldBounds(previewRoot); + previewInstance.transform.position -= new Vector3(0f, centeredBounds.min.y, 0f); + } + } + + private void FitToView() + { + if (previewInstance == null || previewUtility == null) + { + return; + } + + CenterObjectToOrigin(); + CacheDrawables(); + + Bounds bounds = GetWorldBounds(previewRoot); + + float radius = Mathf.Max(bounds.extents.magnitude, 0.001f); + float fov = previewUtility.cameraFieldOfView; + float fovRad = fov * Mathf.Deg2Rad; + + fitDistance = radius / Mathf.Sin(fovRad * 0.5f); + fitDistance *= 1.15f; + + zoom = 1f; + } + + private void CacheDrawables() + { + drawables.Clear(); + + if (previewRoot == null) + { + return; + } + + Renderer[] renderers = previewRoot.GetComponentsInChildren(true); + + foreach (Renderer renderer in renderers) + { + if (renderer == null || !renderer.enabled) + { + continue; + } + + MeshFilter meshFilter = renderer.GetComponent(); + + if (meshFilter != null && meshFilter.sharedMesh != null) + { + drawables.Add(new PreviewDrawable + { + Mesh = meshFilter.sharedMesh, + Matrix = renderer.localToWorldMatrix, + Materials = renderer.sharedMaterials + }); + + continue; + } + + SkinnedMeshRenderer skinned = renderer as SkinnedMeshRenderer; + + if (skinned != null && skinned.sharedMesh != null) + { + drawables.Add(new PreviewDrawable + { + Mesh = skinned.sharedMesh, + Matrix = skinned.localToWorldMatrix, + Materials = skinned.sharedMaterials + }); + } + } + } + + private Texture RenderPreview(float width, float height) + { + if (previewUtility == null || previewInstance == null) + { + return null; + } + + Rect rect = new Rect(0f, 0f, Mathf.Max(1f, width), Mathf.Max(1f, height)); + + previewUtility.BeginPreview(rect, GUIStyle.none); + RenderCurrentView(); + return previewUtility.EndPreview(); + } + + private void RenderCurrentView() + { + Camera camera = previewUtility.camera; + + camera.clearFlags = CameraClearFlags.Color; + camera.backgroundColor = backgroundColor; + camera.nearClipPlane = 0.01f; + camera.farClipPlane = 10000f; + camera.fieldOfView = previewUtility.cameraFieldOfView; + camera.allowHDR = false; + camera.allowMSAA = true; + + RenderSettings.ambientLight = ambientColor; + + Quaternion rotation = Quaternion.Euler(-orbit.y, orbit.x, 0f); + + float distance = fitDistance * cameraDistanceMultiplier / Mathf.Max(zoom, 0.001f); + distance = Mathf.Max(distance, 0.01f); + + Vector3 cameraDirection = rotation * Vector3.forward; + + camera.transform.position = -cameraDirection * distance; + camera.transform.rotation = Quaternion.LookRotation(cameraDirection, Vector3.up); + + ApplyLightSettings(); + + DrawCachedRenderers(); + + if (drawGround) + { + DrawGround(); + } + + camera.Render(); + } + + private void DrawCachedRenderers() + { + for (int i = 0; i < drawables.Count; i++) + { + PreviewDrawable drawable = drawables[i]; + + if (drawable.Mesh == null) + { + continue; + } + + DrawMeshWithMaterials(drawable.Mesh, drawable.Matrix, drawable.Materials); + } + } + + private void DrawMeshWithMaterials(Mesh mesh, Matrix4x4 matrix, Material[] materials) + { + if (mesh == null) + { + return; + } + + int subMeshCount = Mathf.Max(1, mesh.subMeshCount); + + for (int i = 0; i < subMeshCount; i++) + { + Material material = GetDefaultMaterial(); + + if (materials != null && i < materials.Length && materials[i] != null) + { + material = materials[i]; + } + + if (material == null) + { + continue; + } + + previewUtility.DrawMesh(mesh, matrix, material, i); + } + } + + private void DrawGround() + { + Mesh planeMesh = Resources.GetBuiltinResource("Plane.fbx"); + + if (planeMesh == null) + { + return; + } + + Bounds bounds = GetWorldBounds(previewRoot); + + float size = Mathf.Max(bounds.size.x, bounds.size.z, 1f) * 1.5f; + + Matrix4x4 matrix = Matrix4x4.TRS( + new Vector3(0f, bounds.min.y, 0f), + Quaternion.identity, + new Vector3(size * 0.1f, 1f, size * 0.1f) + ); + + previewUtility.DrawMesh(planeMesh, matrix, GetDefaultMaterial(), 0); + } + + private Bounds GetWorldBounds(GameObject root) + { + if (root == null) + { + return new Bounds(Vector3.zero, Vector3.one); + } + + Renderer[] renderers = root.GetComponentsInChildren(true); + + bool hasBounds = false; + Bounds bounds = new Bounds(Vector3.zero, Vector3.one); + + foreach (Renderer renderer in renderers) + { + if (renderer == null) + { + continue; + } + + if (!hasBounds) + { + bounds = renderer.bounds; + hasBounds = true; + } + else + { + bounds.Encapsulate(renderer.bounds); + } + } + + if (!hasBounds) + { + return new Bounds(Vector3.zero, Vector3.one); + } + + return bounds; + } + + private static Material GetDefaultMaterial() + { + Material material = AssetDatabase.GetBuiltinExtraResource("Default-Material.mat"); + + if (material != null) + { + return material; + } + + Shader shader = Shader.Find("Standard"); + + if (shader != null) + { + return new Material(shader); + } + + return null; + } + + private static void DisableSceneOnlyComponents(GameObject root) + { + MonoBehaviour[] behaviours = root.GetComponentsInChildren(true); + + foreach (MonoBehaviour behaviour in behaviours) + { + if (behaviour != null) + { + behaviour.enabled = false; + } + } + + Camera[] cameras = root.GetComponentsInChildren(true); + + foreach (Camera camera in cameras) + { + camera.enabled = false; + } + + Light[] lights = root.GetComponentsInChildren(true); + + foreach (Light light in lights) + { + light.enabled = false; + } + } + + private void SavePng() + { + if (sourceObject == null || previewInstance == null) + { + return; + } + + string defaultName = sourceObject.name + "_thumbnail_" + outputWidth + "x" + outputHeight + ".png"; + + string path = EditorUtility.SaveFilePanel( + "Save Thumbnail PNG", + Application.dataPath, + defaultName, + "png" + ); + + if (string.IsNullOrEmpty(path)) + { + return; + } + + Texture2D texture = RenderToTexture2D(outputWidth, outputHeight); + + if (texture == null) + { + Debug.LogError("Failed to render thumbnail."); + return; + } + + byte[] png = texture.EncodeToPNG(); + File.WriteAllBytes(path, png); + + DestroyImmediate(texture); + + AssetDatabase.Refresh(); + + PingSavedAsset(path); + UpdateExportPreview(); + + Debug.Log("Saved thumbnail: " + path); + } + + private Texture2D RenderToTexture2D(int width, int height) + { + if (previewUtility == null || previewInstance == null) + { + return null; + } + + Rect rect = new Rect(0f, 0f, width, height); + + previewUtility.BeginStaticPreview(rect); + RenderCurrentView(); + + Texture2D texture = previewUtility.EndStaticPreview(); + + if (texture == null) + { + return null; + } + + Texture2D copy = new Texture2D(texture.width, texture.height, TextureFormat.RGBA32, false); + copy.SetPixels(texture.GetPixels()); + copy.Apply(); + + return copy; + } + + private static void PingSavedAsset(string absolutePath) + { + string projectPath = Path.GetFullPath(Application.dataPath + "/..").Replace("\\", "/"); + string fixedPath = Path.GetFullPath(absolutePath).Replace("\\", "/"); + + if (!fixedPath.StartsWith(projectPath)) + { + EditorUtility.RevealInFinder(absolutePath); + return; + } + + string assetPath = fixedPath.Substring(projectPath.Length + 1); + + Object asset = AssetDatabase.LoadAssetAtPath(assetPath); + + if (asset != null) + { + Selection.activeObject = asset; + EditorGUIUtility.PingObject(asset); + } + else + { + EditorUtility.RevealInFinder(absolutePath); + } + } + + private void UpdateExportPreview() + { + if (sourceObject == null || previewInstance == null) + { + return; + } + + ClearExportPreview(); + + exportPreviewTexture = RenderToTexture2D(outputWidth, outputHeight); + Repaint(); + } + + private void DrawExportPreviewPanel() + { + if (exportPreviewTexture == null) + { + return; + } + + EditorGUILayout.Space(); + + using (new EditorGUILayout.VerticalScope(EditorStyles.helpBox)) + { + EditorGUILayout.LabelField( + "Export Preview: " + exportPreviewTexture.width + "x" + exportPreviewTexture.height + " px", + EditorStyles.boldLabel + ); + + Rect rect = GUILayoutUtility.GetRect( + exportPreviewTexture.width, + exportPreviewTexture.height, + GUILayout.Width(exportPreviewTexture.width), + GUILayout.Height(exportPreviewTexture.height) + ); + + EditorGUI.DrawTextureTransparent( + rect, + exportPreviewTexture, + ScaleMode.StretchToFill + ); + + if (GUILayout.Button("Clear Preview")) + { + ClearExportPreview(); + } + } + } + + } // class +} // namespace From 636a217963ad02d12496b7a4390257442ba70953 Mon Sep 17 00:00:00 2001 From: mika Date: Sat, 30 May 2026 23:39:11 +0300 Subject: [PATCH 11/26] Update MeshThumbnailGrabberWindow with new preferences fix sRGB, fix Alpha --- .../Tools/MeshThumbnailGrabberWindow.cs | 124 ++++++++++++++++-- 1 file changed, 111 insertions(+), 13 deletions(-) diff --git a/Assets/Scripts/Editor/Tools/MeshThumbnailGrabberWindow.cs b/Assets/Scripts/Editor/Tools/MeshThumbnailGrabberWindow.cs index f12e6bc..ea28fba 100644 --- a/Assets/Scripts/Editor/Tools/MeshThumbnailGrabberWindow.cs +++ b/Assets/Scripts/Editor/Tools/MeshThumbnailGrabberWindow.cs @@ -43,20 +43,94 @@ private struct PreviewDrawable public Material[] Materials; } - [MenuItem("Tools/Thumbnail Grabber/Mesh Thumbnail Grabber")] + [MenuItem("Tools/UnityLibrary/Mesh Thumbnail Grabber")] public static void Open() { var win = GetWindow("Mesh Thumbnail Grabber"); win.minSize = new Vector2(500, 680); } + private const string PrefOrbitX = "MeshThumbGrabber_OrbitX"; + private const string PrefOrbitY = "MeshThumbGrabber_OrbitY"; + private const string PrefZoom = "MeshThumbGrabber_Zoom"; + private const string PrefCamDistMult = "MeshThumbGrabber_CamDistMult"; + private const string PrefLightIntensity = "MeshThumbGrabber_LightIntensity"; + private const string PrefOutputWidth = "MeshThumbGrabber_OutputWidth"; + private const string PrefOutputHeight = "MeshThumbGrabber_OutputHeight"; + private const string PrefBgColorR = "MeshThumbGrabber_BgR"; + private const string PrefBgColorG = "MeshThumbGrabber_BgG"; + private const string PrefBgColorB = "MeshThumbGrabber_BgB"; + private const string PrefBgColorA = "MeshThumbGrabber_BgA"; + private const string PrefAmbientColorR = "MeshThumbGrabber_AmbR"; + private const string PrefAmbientColorG = "MeshThumbGrabber_AmbG"; + private const string PrefAmbientColorB = "MeshThumbGrabber_AmbB"; + private const string PrefAmbientColorA = "MeshThumbGrabber_AmbA"; + private const string PrefLightColorR = "MeshThumbGrabber_LightR"; + private const string PrefLightColorG = "MeshThumbGrabber_LightG"; + private const string PrefLightColorB = "MeshThumbGrabber_LightB"; + private const string PrefLightColorA = "MeshThumbGrabber_LightA"; + private const string PrefDrawGround = "MeshThumbGrabber_DrawGround"; + + private void LoadPrefs() + { + orbit.x = EditorPrefs.GetFloat(PrefOrbitX, orbit.x); + orbit.y = EditorPrefs.GetFloat(PrefOrbitY, orbit.y); + zoom = EditorPrefs.GetFloat(PrefZoom, zoom); + cameraDistanceMultiplier = EditorPrefs.GetFloat(PrefCamDistMult, cameraDistanceMultiplier); + lightIntensity = EditorPrefs.GetFloat(PrefLightIntensity, lightIntensity); + outputWidth = EditorPrefs.GetInt(PrefOutputWidth, outputWidth); + outputHeight = EditorPrefs.GetInt(PrefOutputHeight, outputHeight); + backgroundColor = new Color( + EditorPrefs.GetFloat(PrefBgColorR, backgroundColor.r), + EditorPrefs.GetFloat(PrefBgColorG, backgroundColor.g), + EditorPrefs.GetFloat(PrefBgColorB, backgroundColor.b), + EditorPrefs.GetFloat(PrefBgColorA, backgroundColor.a)); + ambientColor = new Color( + EditorPrefs.GetFloat(PrefAmbientColorR, ambientColor.r), + EditorPrefs.GetFloat(PrefAmbientColorG, ambientColor.g), + EditorPrefs.GetFloat(PrefAmbientColorB, ambientColor.b), + EditorPrefs.GetFloat(PrefAmbientColorA, ambientColor.a)); + lightColor = new Color( + EditorPrefs.GetFloat(PrefLightColorR, lightColor.r), + EditorPrefs.GetFloat(PrefLightColorG, lightColor.g), + EditorPrefs.GetFloat(PrefLightColorB, lightColor.b), + EditorPrefs.GetFloat(PrefLightColorA, lightColor.a)); + drawGround = EditorPrefs.GetBool(PrefDrawGround, drawGround); + } + + private void SavePrefs() + { + EditorPrefs.SetFloat(PrefOrbitX, orbit.x); + EditorPrefs.SetFloat(PrefOrbitY, orbit.y); + EditorPrefs.SetFloat(PrefZoom, zoom); + EditorPrefs.SetFloat(PrefCamDistMult, cameraDistanceMultiplier); + EditorPrefs.SetFloat(PrefLightIntensity, lightIntensity); + EditorPrefs.SetInt(PrefOutputWidth, outputWidth); + EditorPrefs.SetInt(PrefOutputHeight, outputHeight); + EditorPrefs.SetFloat(PrefBgColorR, backgroundColor.r); + EditorPrefs.SetFloat(PrefBgColorG, backgroundColor.g); + EditorPrefs.SetFloat(PrefBgColorB, backgroundColor.b); + EditorPrefs.SetFloat(PrefBgColorA, backgroundColor.a); + EditorPrefs.SetFloat(PrefAmbientColorR, ambientColor.r); + EditorPrefs.SetFloat(PrefAmbientColorG, ambientColor.g); + EditorPrefs.SetFloat(PrefAmbientColorB, ambientColor.b); + EditorPrefs.SetFloat(PrefAmbientColorA, ambientColor.a); + EditorPrefs.SetFloat(PrefLightColorR, lightColor.r); + EditorPrefs.SetFloat(PrefLightColorG, lightColor.g); + EditorPrefs.SetFloat(PrefLightColorB, lightColor.b); + EditorPrefs.SetFloat(PrefLightColorA, lightColor.a); + EditorPrefs.SetBool(PrefDrawGround, drawGround); + } + private void OnEnable() { + LoadPrefs(); CreatePreviewUtility(); } private void OnDisable() { + SavePrefs(); Cleanup(); } @@ -141,6 +215,7 @@ private void OnGUI() if (EditorGUI.EndChangeCheck()) { ClearExportPreview(); + SavePrefs(); } zoom = EditorGUILayout.Slider("Zoom", zoom, 0.05f, 100f); @@ -160,6 +235,7 @@ private void OnGUI() CenterObjectToOrigin(); CacheDrawables(); + SavePrefs(); Repaint(); } } @@ -183,6 +259,7 @@ private void OnGUI() { FitToView(); ClearExportPreview(); + SavePrefs(); Repaint(); } @@ -190,6 +267,7 @@ private void OnGUI() { orbit = new Vector2(135f, -20f); ClearExportPreview(); + SavePrefs(); Repaint(); } @@ -275,12 +353,18 @@ private void HandlePreviewInput(Rect rect) Repaint(); } + if (e.type == EventType.MouseUp && e.button == 0) + { + SavePrefs(); + } + if (e.type == EventType.ScrollWheel) { zoom *= 1f - e.delta.y * 0.08f; zoom = Mathf.Clamp(zoom, 0.05f, 100f); ClearExportPreview(); + SavePrefs(); e.Use(); Repaint(); @@ -690,23 +774,37 @@ private Texture2D RenderToTexture2D(int width, int height) return null; } - Rect rect = new Rect(0f, 0f, width, height); + RenderTexture rt = RenderTexture.GetTemporary(width, height, 24, RenderTextureFormat.ARGB32, RenderTextureReadWrite.sRGB); + RenderTexture prevActive = RenderTexture.active; - previewUtility.BeginStaticPreview(rect); - RenderCurrentView(); + try + { + // BeginPreview activates the preview scene lights; we then swap its + // internal RGB target for our ARGB32 RT before camera.Render() fires. + Rect previewRect = new Rect(0f, 0f, width, height); + previewUtility.BeginPreview(previewRect, GUIStyle.none); - Texture2D texture = previewUtility.EndStaticPreview(); + previewUtility.camera.targetTexture = rt; - if (texture == null) - { - return null; - } + RenderCurrentView(); - Texture2D copy = new Texture2D(texture.width, texture.height, TextureFormat.RGBA32, false); - copy.SetPixels(texture.GetPixels()); - copy.Apply(); + // EndPreview would blit its internal RT to screen – skip that and + // read directly from our ARGB32 RT instead. + previewUtility.EndPreview(); - return copy; + RenderTexture.active = rt; + + Texture2D copy = new Texture2D(width, height, TextureFormat.RGBA32, false); + copy.ReadPixels(new Rect(0, 0, width, height), 0, 0); + copy.Apply(); + + return copy; + } + finally + { + RenderTexture.active = prevActive; + RenderTexture.ReleaseTemporary(rt); + } } private static void PingSavedAsset(string absolutePath) From ec6e1d7d008826831f991fff585bc6bfb5d88c38 Mon Sep 17 00:00:00 2001 From: mika Date: Wed, 3 Jun 2026 16:32:09 +0300 Subject: [PATCH 12/26] PivotAligner add Scale support --- Assets/Scripts/Editor/Tools/PivotAligner.cs | 782 +++++++++++++------- 1 file changed, 523 insertions(+), 259 deletions(-) diff --git a/Assets/Scripts/Editor/Tools/PivotAligner.cs b/Assets/Scripts/Editor/Tools/PivotAligner.cs index a03ca8e..e24d762 100644 --- a/Assets/Scripts/Editor/Tools/PivotAligner.cs +++ b/Assets/Scripts/Editor/Tools/PivotAligner.cs @@ -6,7 +6,6 @@ /// Place this file inside any Editor/ folder in your project. /// Open via: Tools/UnityLibrary/Pivot Aligner /// - using UnityEngine; using UnityEditor; @@ -14,111 +13,109 @@ namespace UnityLibrary.Tools { public class PivotAligner : EditorWindow { - // ────────────────────────────────────────────────────────────────────────── - // Enums & constants - // ────────────────────────────────────────────────────────────────────────── - enum PickMode { Vertex, Face } - enum ToolState { Idle, Picking, Rotating } + enum ToolState { Idle, Picking, Transforming } - const string MENU_PATH = "Tools/UnityLibrary/Pivot Aligner"; + const string MENU_PATH = "Tools/Pivot Aligner"; const float GIZMO_RADIUS = 0.06f; const float GIZMO_CROSS = 0.25f; - // ────────────────────────────────────────────────────────────────────────── - // Inspector / serialised fields - // ────────────────────────────────────────────────────────────────────────── - - [SerializeField] GameObject sourceObject; - [SerializeField] PickMode pickMode = PickMode.Vertex; - - // ── Rotation ────────────────────────────────────────────────────────────── - // Coarse float fields (full range, typed or dragged) - float rotX, rotY, rotZ; + [SerializeField] private GameObject sourceObject; + [SerializeField] private PickMode pickMode = PickMode.Vertex; + + // Rotation + private float rotX; + private float rotY; + private float rotZ; + + private bool showFinetune = false; + private float fineTuneRange = 5f; + private float fineX; + private float fineY; + private float fineZ; + + // Scale + private bool showScale = true; + private bool uniformScale = true; + private float uniformScaleValue = 1f; + private float scaleX = 1f; + private float scaleY = 1f; + private float scaleZ = 1f; + + // Position offset + private bool showPosOffset = false; + private float posOffsetX; + private float posOffsetY; + private float posOffsetZ; + private float finePosRange = 0.1f; - // Fine-tune additive deltas (±fineTuneRange degrees, applied on top of coarse) - bool showFinetune = false; - float fineTuneRange = 5f; - float fineX, fineY, fineZ; - - // ── Position offset ─────────────────────────────────────────────────────── - // Shifts the model in world space AND moves the pivot so subsequent - // rotations keep the same relative geometry. - bool showPosOffset = false; - float posOffsetX, posOffsetY, posOffsetZ; - float finePosRange = 0.1f; - - // ────────────────────────────────────────────────────────────────────────── // Runtime state - // ────────────────────────────────────────────────────────────────────────── - - ToolState state = ToolState.Idle; - Vector3 pivotWorld = Vector3.zero; - bool hasPivot = false; + private ToolState state = ToolState.Idle; + private Vector3 pivotWorld = Vector3.zero; + private bool hasPivot = false; - // Snapshot taken when pivot is confirmed – rotation is always rebuilt from - // this base so there is no floating-point drift on repeated slider edits. - Vector3 basePosition; - Quaternion baseRotation; + private Vector3 basePosition; + private Quaternion baseRotation; + private Vector3 baseScale; - // Highlight during picking - Vector3 highlightPoint = Vector3.zero; - Vector3 highlightNormal = Vector3.up; - bool hasHighlight = false; + private Vector3 highlightPoint = Vector3.zero; + private Vector3 highlightNormal = Vector3.up; + private bool hasHighlight = false; - // Scroll view - Vector2 scroll; + private Vector2 scroll; - // Style cache - GUIStyle headerStyle, sectionStyle, stateStyle, subLabelStyle; - bool stylesInit; + private GUIStyle headerStyle; + private GUIStyle sectionStyle; + private GUIStyle stateStyle; + private GUIStyle subLabelStyle; + private bool stylesInit; - // ────────────────────────────────────────────────────────────────────────── - // Window lifecycle - // ────────────────────────────────────────────────────────────────────────── + private int undoGroupIndex = 0; + private int lastHotControl = 0; + private string lastUndoLabel = ""; [MenuItem(MENU_PATH)] public static void ShowWindow() { - var win = GetWindow("Pivot Aligner"); - win.minSize = new Vector2(440, 520); + PivotAligner win = GetWindow("Pivot Aligner"); + win.minSize = new Vector2(440, 560); } - void OnEnable() + private void OnEnable() { SceneView.duringSceneGui += OnSceneGUI; - titleContent = new GUIContent("Pivot Aligner", - EditorGUIUtility.IconContent("d_ToolHandleLocal").image); + titleContent = new GUIContent("Pivot Aligner"); } - void OnDisable() + private void OnDisable() { SceneView.duringSceneGui -= OnSceneGUI; CancelPicking(); } - // ────────────────────────────────────────────────────────────────────────── - // Editor Window GUI - // ────────────────────────────────────────────────────────────────────────── - - void OnGUI() + private void OnGUI() { InitStyles(); + scroll = EditorGUILayout.BeginScrollView(scroll); - // ── Header ──────────────────────────────────────────────────────────── EditorGUILayout.Space(6); EditorGUILayout.LabelField("PIVOT ALIGNER", headerStyle); EditorGUILayout.Space(2); DrawHR(); - // ── 1 · Source Model ───────────────────────────────────────────────── EditorGUILayout.Space(6); - EditorGUILayout.LabelField("1 · Source Model", sectionStyle); + EditorGUILayout.LabelField("1. Source Model", sectionStyle); + EditorGUI.BeginChangeCheck(); sourceObject = (GameObject)EditorGUILayout.ObjectField( - "Game Object", sourceObject, typeof(GameObject), true); - if (EditorGUI.EndChangeCheck()) ResetTool(); + "Game Object", + sourceObject, + typeof(GameObject), + true); + + if (EditorGUI.EndChangeCheck()) + ResetTool(); if (sourceObject == null) { @@ -127,36 +124,48 @@ void OnGUI() return; } - // ── 2 · Pick Mode ───────────────────────────────────────────────────── EditorGUILayout.Space(8); - EditorGUILayout.LabelField("2 · Pick Mode", sectionStyle); + EditorGUILayout.LabelField("2. Pick Mode", sectionStyle); + EditorGUILayout.BeginHorizontal(); - if (DrawModeButton(" Vertex", pickMode == PickMode.Vertex)) - { pickMode = PickMode.Vertex; hasHighlight = false; } - if (DrawModeButton(" Face", pickMode == PickMode.Face)) - { pickMode = PickMode.Face; hasHighlight = false; } + + if (DrawModeButton("Vertex", pickMode == PickMode.Vertex)) + { + pickMode = PickMode.Vertex; + hasHighlight = false; + } + + if (DrawModeButton("Face", pickMode == PickMode.Face)) + { + pickMode = PickMode.Face; + hasHighlight = false; + } + EditorGUILayout.EndHorizontal(); - // ── 3 · Pivot Point ─────────────────────────────────────────────────── EditorGUILayout.Space(8); - EditorGUILayout.LabelField("3 · Select Pivot Point", sectionStyle); + EditorGUILayout.LabelField("3. Select Pivot Point", sectionStyle); - using (new EditorGUI.DisabledScope(state == ToolState.Rotating)) + using (new EditorGUI.DisabledScope(state == ToolState.Transforming)) { if (state != ToolState.Picking) { - if (GUILayout.Button("⊕ Select Target Point in Scene", GUILayout.Height(30))) + if (GUILayout.Button("Select Target Point in Scene", GUILayout.Height(30))) BeginPicking(); } else { Color prev = GUI.backgroundColor; GUI.backgroundColor = new Color(1f, 0.55f, 0.15f); - if (GUILayout.Button("✕ Cancel Picking", GUILayout.Height(30))) + + if (GUILayout.Button("Cancel Picking", GUILayout.Height(30))) CancelPicking(); + GUI.backgroundColor = prev; + + string modeText = pickMode == PickMode.Vertex ? "vertex" : "face center"; EditorGUILayout.HelpBox( - $"Hover model → {(pickMode == PickMode.Vertex ? "vertex" : "face center")} highlights. Click to confirm pivot.", + "Hover over the model. The nearest " + modeText + " will highlight. Click to confirm pivot.", MessageType.None); } } @@ -164,69 +173,133 @@ void OnGUI() if (hasPivot) { EditorGUILayout.Space(2); + using (new EditorGUILayout.HorizontalScope()) { - EditorGUILayout.LabelField($"Pivot {pivotWorld:F4}", subLabelStyle); + EditorGUILayout.LabelField("Pivot " + pivotWorld.ToString("F4"), subLabelStyle); + if (GUILayout.Button("Re-pick", GUILayout.Width(56), GUILayout.Height(18))) BeginPicking(); } } - // ── 4 · Rotation ────────────────────────────────────────────────────── EditorGUILayout.Space(8); DrawHR(); EditorGUILayout.Space(4); - EditorGUILayout.LabelField("4 · Rotation Around Pivot", sectionStyle); + EditorGUILayout.LabelField("4. Rotation Around Pivot", sectionStyle); using (new EditorGUI.DisabledScope(!hasPivot)) { - // Coarse float input rows bool dirty = false; + EditorGUI.BeginChangeCheck(); - DrawRotRow("Pitch X", ref rotX); - DrawRotRow("Yaw Y", ref rotY); - DrawRotRow("Roll Z", ref rotZ); - if (EditorGUI.EndChangeCheck()) dirty = true; - // Fine-tune + DrawRotRow("Pitch X", ref rotX); + DrawRotRow("Yaw Y", ref rotY); + DrawRotRow("Roll Z", ref rotZ); + + if (EditorGUI.EndChangeCheck()) + dirty = true; + EditorGUILayout.Space(4); + using (new EditorGUILayout.HorizontalScope()) { - showFinetune = EditorGUILayout.ToggleLeft("Fine-tune ±", showFinetune, GUILayout.Width(102)); + showFinetune = EditorGUILayout.ToggleLeft("Fine-tune +/-", showFinetune, GUILayout.Width(102)); + using (new EditorGUI.DisabledScope(!showFinetune)) fineTuneRange = Mathf.Max(0.001f, EditorGUILayout.FloatField(fineTuneRange, GUILayout.Width(52))); - EditorGUILayout.LabelField("°", subLabelStyle, GUILayout.Width(14)); + + EditorGUILayout.LabelField("deg", subLabelStyle, GUILayout.Width(28)); } if (showFinetune) { EditorGUI.BeginChangeCheck(); - fineX = DrawFineRotSlider(" Δ Pitch X", fineX, fineTuneRange); - fineY = DrawFineRotSlider(" Δ Yaw Y", fineY, fineTuneRange); - fineZ = DrawFineRotSlider(" Δ Roll Z", fineZ, fineTuneRange); - if (EditorGUI.EndChangeCheck()) dirty = true; + + fineX = DrawFineRotSlider("Delta X", fineX, fineTuneRange); + fineY = DrawFineRotSlider("Delta Y", fineY, fineTuneRange); + fineZ = DrawFineRotSlider("Delta Z", fineZ, fineTuneRange); + + if (EditorGUI.EndChangeCheck()) + dirty = true; } - if (dirty && hasPivot) ApplyAll("Pivot Aligner — Rotate"); + if (dirty && hasPivot) + ApplyAll("Pivot Aligner - Rotate"); EditorGUILayout.Space(4); + using (new EditorGUILayout.HorizontalScope()) { if (GUILayout.Button("Reset All Rotation", GUILayout.Height(24))) ResetRotation(); + if (showFinetune && GUILayout.Button("Reset Fine", GUILayout.Width(80), GUILayout.Height(24))) - { fineX = fineY = fineZ = 0f; if (hasPivot) ApplyAll("Pivot Aligner — Rotate"); } + { + fineX = 0f; + fineY = 0f; + fineZ = 0f; + + if (hasPivot) + ApplyAll("Pivot Aligner - Rotate"); + } } } - // ── 5 · Position Offset ─────────────────────────────────────────────── EditorGUILayout.Space(8); DrawHR(); EditorGUILayout.Space(4); using (new EditorGUILayout.HorizontalScope()) { - showPosOffset = EditorGUILayout.Foldout(showPosOffset, "5 · Position Offset", true, sectionStyle); + showScale = EditorGUILayout.Foldout(showScale, "5. Scale Around Pivot", true, sectionStyle); + EditorGUILayout.LabelField("(uses selected point)", subLabelStyle); + } + + if (showScale) + { + using (new EditorGUI.DisabledScope(!hasPivot)) + { + EditorGUI.BeginChangeCheck(); + + uniformScale = EditorGUILayout.ToggleLeft("Uniform Scale", uniformScale); + + if (uniformScale) + { + uniformScaleValue = EditorGUILayout.FloatField("Scale", uniformScaleValue); + uniformScaleValue = Mathf.Max(0.0001f, uniformScaleValue); + + scaleX = uniformScaleValue; + scaleY = uniformScaleValue; + scaleZ = uniformScaleValue; + } + else + { + scaleX = Mathf.Max(0.0001f, EditorGUILayout.FloatField("Scale X", scaleX)); + scaleY = Mathf.Max(0.0001f, EditorGUILayout.FloatField("Scale Y", scaleY)); + scaleZ = Mathf.Max(0.0001f, EditorGUILayout.FloatField("Scale Z", scaleZ)); + + uniformScaleValue = scaleX; + } + + if (EditorGUI.EndChangeCheck() && hasPivot) + ApplyAll("Pivot Aligner - Scale"); + + EditorGUILayout.Space(3); + + if (GUILayout.Button("Reset Scale", GUILayout.Height(24))) + ResetScale(); + } + } + + EditorGUILayout.Space(8); + DrawHR(); + EditorGUILayout.Space(4); + + using (new EditorGUILayout.HorizontalScope()) + { + showPosOffset = EditorGUILayout.Foldout(showPosOffset, "6. Position Offset", true, sectionStyle); EditorGUILayout.LabelField("(moves pivot too)", subLabelStyle); } @@ -234,10 +307,9 @@ void OnGUI() { using (new EditorGUI.DisabledScope(!hasPivot)) { - // Slider range control using (new EditorGUILayout.HorizontalScope()) { - EditorGUILayout.LabelField("Slider range ±", subLabelStyle, GUILayout.Width(102)); + EditorGUILayout.LabelField("Slider range +/-", subLabelStyle, GUILayout.Width(102)); finePosRange = Mathf.Max(0.0001f, EditorGUILayout.FloatField(finePosRange, GUILayout.Width(52))); EditorGUILayout.LabelField("m", subLabelStyle, GUILayout.Width(14)); } @@ -245,19 +317,21 @@ void OnGUI() EditorGUILayout.Space(2); EditorGUI.BeginChangeCheck(); - posOffsetX = DrawOffsetSliderRow("Offset X", posOffsetX, finePosRange); - posOffsetY = DrawOffsetSliderRow("Offset Y", posOffsetY, finePosRange); - posOffsetZ = DrawOffsetSliderRow("Offset Z", posOffsetZ, finePosRange); + + posOffsetX = DrawOffsetSliderRow("Offset X", posOffsetX, finePosRange); + posOffsetY = DrawOffsetSliderRow("Offset Y", posOffsetY, finePosRange); + posOffsetZ = DrawOffsetSliderRow("Offset Z", posOffsetZ, finePosRange); + if (EditorGUI.EndChangeCheck() && hasPivot) - ApplyAll("Pivot Aligner — Move"); + ApplyAll("Pivot Aligner - Move"); EditorGUILayout.Space(3); + if (GUILayout.Button("Reset Position Offset", GUILayout.Height(24))) ResetPositionOffset(); } } - // ── Apply / Revert ──────────────────────────────────────────────────── EditorGUILayout.Space(8); DrawHR(); EditorGUILayout.Space(4); @@ -266,138 +340,193 @@ void OnGUI() { Color prev = GUI.backgroundColor; GUI.backgroundColor = new Color(0.22f, 0.80f, 0.40f); - if (GUILayout.Button("✔ Apply & Clear Pivot", GUILayout.Height(36))) + + if (GUILayout.Button("Apply and Clear Pivot", GUILayout.Height(36))) Apply(); + GUI.backgroundColor = prev; } if (hasPivot) { - if (GUILayout.Button("↺ Cancel & Revert to Original", GUILayout.Height(26))) + if (GUILayout.Button("Cancel and Revert to Original", GUILayout.Height(26))) RevertAndReset(); } - // ── Status bar ──────────────────────────────────────────────────────── EditorGUILayout.Space(4); - string totalRot = hasPivot - ? $"rot({rotX + fineX:F3}, {rotY + fineY:F3}, {rotZ + fineZ:F3})° " + - $"pos offset({posOffsetX:F4}, {posOffsetY:F4}, {posOffsetZ:F4}) m" - : ""; - string stateLabel = state switch + + string totalInfo = ""; + + if (hasPivot) + { + totalInfo = + "rot(" + + (rotX + fineX).ToString("F3") + ", " + + (rotY + fineY).ToString("F3") + ", " + + (rotZ + fineZ).ToString("F3") + ") deg scale(" + + scaleX.ToString("F3") + ", " + + scaleY.ToString("F3") + ", " + + scaleZ.ToString("F3") + ") pos offset(" + + posOffsetX.ToString("F4") + ", " + + posOffsetY.ToString("F4") + ", " + + posOffsetZ.ToString("F4") + ") m"; + } + + string stateLabel; + + switch (state) { - ToolState.Picking => "● PICKING", - ToolState.Rotating => $"● ROTATING {totalRot}", - _ => "○ idle" - }; + case ToolState.Picking: + stateLabel = "PICKING"; + break; + + case ToolState.Transforming: + stateLabel = "TRANSFORMING " + totalInfo; + break; + + default: + stateLabel = "idle"; + break; + } + EditorGUILayout.LabelField(stateLabel, stateStyle); EditorGUILayout.Space(4); + EditorGUILayout.EndScrollView(); SceneView.RepaintAll(); } - // ────────────────────────────────────────────────────────────────────────── - // Row helpers - // ────────────────────────────────────────────────────────────────────────── - - /// Radio-style button: highlighted when active, always clickable, returns true on click. - bool DrawModeButton(string label, bool active) + private bool DrawModeButton(string label, bool active) { Color prev = GUI.backgroundColor; - if (active) GUI.backgroundColor = new Color(0.3f, 0.65f, 1f); + + if (active) + GUI.backgroundColor = new Color(0.3f, 0.65f, 1f); + bool clicked = GUILayout.Button(label, GUILayout.Height(26)); + GUI.backgroundColor = prev; + return clicked; } - /// Coarse rotation row: label | float field | quick-snap buttons - void DrawRotRow(string label, ref float value) + private void DrawRotRow(string label, ref float value) { using (new EditorGUILayout.HorizontalScope()) { EditorGUILayout.LabelField(label, GUILayout.Width(72)); + value = EditorGUILayout.FloatField(value, GUILayout.Width(74)); - if (GUILayout.Button("-90", GUILayout.Width(36), GUILayout.Height(18))) value -= 90f; - if (GUILayout.Button("-45", GUILayout.Width(36), GUILayout.Height(18))) value -= 45f; - if (GUILayout.Button("0", GUILayout.Width(28), GUILayout.Height(18))) value = 0f; - if (GUILayout.Button("+45", GUILayout.Width(36), GUILayout.Height(18))) value += 45f; - if (GUILayout.Button("+90", GUILayout.Width(36), GUILayout.Height(18))) value += 90f; + + if (GUILayout.Button("-90", GUILayout.Width(36), GUILayout.Height(18))) + value -= 90f; + + if (GUILayout.Button("-45", GUILayout.Width(36), GUILayout.Height(18))) + value -= 45f; + + if (GUILayout.Button("0", GUILayout.Width(28), GUILayout.Height(18))) + value = 0f; + + if (GUILayout.Button("+45", GUILayout.Width(36), GUILayout.Height(18))) + value += 45f; + + if (GUILayout.Button("+90", GUILayout.Width(36), GUILayout.Height(18))) + value += 90f; } } - /// Fine rotation slider: returns new value. - float DrawFineRotSlider(string label, float value, float range) + private float DrawFineRotSlider(string label, float value, float range) { using (new EditorGUILayout.HorizontalScope()) { EditorGUILayout.LabelField(label, subLabelStyle, GUILayout.Width(76)); + value = GUILayout.HorizontalSlider(value, -range, range); value = EditorGUILayout.FloatField(value, GUILayout.Width(64)); - EditorGUILayout.LabelField("°", subLabelStyle, GUILayout.Width(14)); + + EditorGUILayout.LabelField("deg", subLabelStyle, GUILayout.Width(28)); } + return value; } - /// Position offset row: slider + float field + zero button. Direct value, no delta accumulation. - float DrawOffsetSliderRow(string label, float value, float range) + private float DrawOffsetSliderRow(string label, float value, float range) { using (new EditorGUILayout.HorizontalScope()) { EditorGUILayout.LabelField(label, GUILayout.Width(72)); + value = GUILayout.HorizontalSlider(value, -range, range); value = EditorGUILayout.FloatField(value, GUILayout.Width(74)); + EditorGUILayout.LabelField("m", subLabelStyle, GUILayout.Width(14)); - if (GUILayout.Button("0", GUILayout.Width(24), GUILayout.Height(18))) value = 0f; + + if (GUILayout.Button("0", GUILayout.Width(24), GUILayout.Height(18))) + value = 0f; } + return value; } - // ────────────────────────────────────────────────────────────────────────── - // Scene GUI - // ────────────────────────────────────────────────────────────────────────── - - void OnSceneGUI(SceneView sv) + private void OnSceneGUI(SceneView sv) { - if (sourceObject == null) return; - if (hasPivot) DrawPivotGizmo(pivotWorld, Color.cyan); - if (state == ToolState.Picking) HandlePicking(sv); + if (sourceObject == null) + return; + + if (hasPivot) + DrawPivotGizmo(pivotWorld, Color.cyan); + + if (state == ToolState.Picking) + HandlePicking(sv); } - void HandlePicking(SceneView sv) + private void HandlePicking(SceneView sv) { Event e = Event.current; + if (e.type == EventType.Layout) HandleUtility.AddDefaultControl(GUIUtility.GetControlID(FocusType.Passive)); if (e.type == EventType.MouseMove || e.type == EventType.MouseDown) { Ray ray = HandleUtility.GUIPointToWorldRay(e.mousePosition); + TryRaycast(ray, out hasHighlight, out highlightPoint, out highlightNormal); + if (hasHighlight) DrawPivotGizmo(highlightPoint, new Color(1f, 0.8f, 0.1f, 0.9f)); + if (e.type == EventType.MouseDown && e.button == 0 && hasHighlight) - { ConfirmPivot(highlightPoint); e.Use(); } + { + ConfirmPivot(highlightPoint); + e.Use(); + } + sv.Repaint(); } + if (hasHighlight) DrawPivotGizmo(highlightPoint, new Color(1f, 0.8f, 0.1f, 0.9f)); } - // ────────────────────────────────────────────────────────────────────────── - // Raycasting - // ────────────────────────────────────────────────────────────────────────── - - void TryRaycast(Ray ray, out bool hit, out Vector3 point, out Vector3 normal) + private void TryRaycast(Ray ray, out bool hit, out Vector3 point, out Vector3 normal) { - hit = false; point = Vector3.zero; normal = Vector3.up; - var filters = sourceObject.GetComponentsInChildren(); + hit = false; + point = Vector3.zero; + normal = Vector3.up; + + MeshFilter[] filters = sourceObject.GetComponentsInChildren(); float bestDist = float.MaxValue; - foreach (var mf in filters) + foreach (MeshFilter mf in filters) { - if (mf.sharedMesh == null) continue; + if (mf.sharedMesh == null) + continue; + Mesh mesh = mf.sharedMesh; Transform t = mf.transform; + Ray localRay = new Ray( t.InverseTransformPoint(ray.origin), t.InverseTransformDirection(ray.direction).normalized); @@ -408,122 +537,192 @@ void TryRaycast(Ray ray, out bool hit, out Vector3 point, out Vector3 normal) for (int i = 0; i < tris.Length; i += 3) { - Vector3 v0 = verts[tris[i]], v1 = verts[tris[i + 1]], v2 = verts[tris[i + 2]]; - if (!RayTriangle(localRay, v0, v1, v2, out float dist, out float u, out float v)) continue; - if (dist < 0 || dist >= bestDist) continue; - bestDist = dist; hit = true; + Vector3 v0 = verts[tris[i]]; + Vector3 v1 = verts[tris[i + 1]]; + Vector3 v2 = verts[tris[i + 2]]; + + float dist; + float u; + float v; + + if (!RayTriangle(localRay, v0, v1, v2, out dist, out u, out v)) + continue; + + if (dist < 0f || dist >= bestDist) + continue; + + bestDist = dist; + hit = true; if (pickMode == PickMode.Vertex) { float w = 1f - u - v; int vi = FindNearestVertex(u, v, w); - point = t.TransformPoint(vi == 0 ? v0 : vi == 1 ? v1 : v2); + + if (vi == 0) + point = t.TransformPoint(v0); + else if (vi == 1) + point = t.TransformPoint(v1); + else + point = t.TransformPoint(v2); + } + else + { + point = t.TransformPoint((v0 + v1 + v2) / 3f); } - else point = t.TransformPoint((v0 + v1 + v2) / 3f); Vector3 n0 = normals.Length > tris[i] ? normals[tris[i]] : Vector3.up; Vector3 n1 = normals.Length > tris[i + 1] ? normals[tris[i + 1]] : Vector3.up; Vector3 n2 = normals.Length > tris[i + 2] ? normals[tris[i + 2]] : Vector3.up; - normal = t.TransformDirection((n0 * (1 - u - v) + n1 * u + n2 * v).normalized); + + normal = t.TransformDirection((n0 * (1f - u - v) + n1 * u + n2 * v).normalized); } } } - static bool RayTriangle(Ray ray, Vector3 v0, Vector3 v1, Vector3 v2, - out float dist, out float u, out float v) + private static bool RayTriangle( + Ray ray, + Vector3 v0, + Vector3 v1, + Vector3 v2, + out float dist, + out float u, + out float v) { - dist = u = v = 0; - Vector3 e1 = v1 - v0, e2 = v2 - v0, h = Vector3.Cross(ray.direction, e2); + dist = 0f; + u = 0f; + v = 0f; + + Vector3 e1 = v1 - v0; + Vector3 e2 = v2 - v0; + Vector3 h = Vector3.Cross(ray.direction, e2); + float det = Vector3.Dot(e1, h); - if (Mathf.Abs(det) < 1e-6f) return false; + + if (Mathf.Abs(det) < 1e-6f) + return false; + float f = 1f / det; Vector3 s = ray.origin - v0; + u = f * Vector3.Dot(s, h); - if (u < 0 || u > 1) return false; + + if (u < 0f || u > 1f) + return false; + Vector3 q = Vector3.Cross(s, e1); + v = f * Vector3.Dot(ray.direction, q); - if (v < 0 || u + v > 1) return false; + + if (v < 0f || u + v > 1f) + return false; + dist = f * Vector3.Dot(e2, q); + return dist > 1e-5f; } - static int FindNearestVertex(float u, float v, float w) + private static int FindNearestVertex(float u, float v, float w) { - if (w >= u && w >= v) return 0; - if (u >= w && u >= v) return 1; + if (w >= u && w >= v) + return 0; + + if (u >= w && u >= v) + return 1; + return 2; } - // ────────────────────────────────────────────────────────────────────────── - // Gizmo drawing - // ────────────────────────────────────────────────────────────────────────── - - void DrawPivotGizmo(Vector3 pos, Color color) + private void DrawPivotGizmo(Vector3 pos, Color color) { Handles.color = color; - Handles.SphereHandleCap(0, pos, Quaternion.identity, - GIZMO_RADIUS * HandleUtility.GetHandleSize(pos), EventType.Repaint); - float sz = GIZMO_CROSS * HandleUtility.GetHandleSize(pos); + + float handleSize = HandleUtility.GetHandleSize(pos); + + Handles.SphereHandleCap( + 0, + pos, + Quaternion.identity, + GIZMO_RADIUS * handleSize, + EventType.Repaint); + + float sz = GIZMO_CROSS * handleSize; + Handles.DrawLine(pos - Vector3.right * sz, pos + Vector3.right * sz); Handles.DrawLine(pos - Vector3.up * sz, pos + Vector3.up * sz); Handles.DrawLine(pos - Vector3.forward * sz, pos + Vector3.forward * sz); - GUIStyle s = new GUIStyle(EditorStyles.miniLabel) { normal = { textColor = color } }; - Handles.Label(pos + Vector3.up * sz * 1.5f, - (hasPivot && pos == pivotWorld) ? "PIVOT" : "○", s); - } - // ────────────────────────────────────────────────────────────────────────── - // State transitions - // ────────────────────────────────────────────────────────────────────────── + GUIStyle s = new GUIStyle(EditorStyles.miniLabel); + s.normal.textColor = color; + + string label = hasPivot && Vector3.Distance(pos, pivotWorld) < 0.0001f ? "PIVOT" : "point"; + + Handles.Label(pos + Vector3.up * sz * 1.5f, label, s); + } - void BeginPicking() + private void BeginPicking() { - if (sourceObject == null) return; - state = ToolState.Picking; hasHighlight = false; + if (sourceObject == null) + return; + + state = ToolState.Picking; + hasHighlight = false; + SceneView.RepaintAll(); } - void CancelPicking() + private void CancelPicking() { if (state == ToolState.Picking) - state = hasPivot ? ToolState.Rotating : ToolState.Idle; - hasHighlight = false; SceneView.RepaintAll(); + state = hasPivot ? ToolState.Transforming : ToolState.Idle; + + hasHighlight = false; + + SceneView.RepaintAll(); } - void ConfirmPivot(Vector3 worldPoint) + private void ConfirmPivot(Vector3 worldPoint) { - if (hasPivot && state == ToolState.Rotating) RevertTransform(); + if (hasPivot && state == ToolState.Transforming) + RevertTransform(); + pivotWorld = worldPoint; hasPivot = true; - state = ToolState.Rotating; + state = ToolState.Transforming; hasHighlight = false; + basePosition = sourceObject.transform.position; baseRotation = sourceObject.transform.rotation; - rotX = rotY = rotZ = 0f; - fineX = fineY = fineZ = 0f; - posOffsetX = posOffsetY = posOffsetZ = 0f; - Repaint(); SceneView.RepaintAll(); - } + baseScale = sourceObject.transform.localScale; + + rotX = 0f; + rotY = 0f; + rotZ = 0f; - // ────────────────────────────────────────────────────────────────────────── - // Transform computation — single source of truth - // ────────────────────────────────────────────────────────────────────────── + fineX = 0f; + fineY = 0f; + fineZ = 0f; - // Each continuous drag (slider or float field) collapses into a single undo - // step by using the same group name while the control is hot, then - // incrementing undoGroupIndex when the user releases (EndChangeCheck fires - // but the control is no longer hot on the next frame). - int undoGroupIndex = 0; - int lastHotControl = 0; - string lastUndoLabel = ""; + scaleX = 1f; + scaleY = 1f; + scaleZ = 1f; + uniformScaleValue = 1f; - void ApplyAll(string undoLabel = "Pivot Aligner") + posOffsetX = 0f; + posOffsetY = 0f; + posOffsetZ = 0f; + + Repaint(); + SceneView.RepaintAll(); + } + + private void ApplyAll(string undoLabel = "Pivot Aligner") { - if (sourceObject == null || !hasPivot) return; + if (sourceObject == null || !hasPivot) + return; - // Start a new undo group whenever the active control changes or the - // label changes (e.g. switching from Rotate to Move). int hot = GUIUtility.hotControl; + if (hot != lastHotControl || undoLabel != lastUndoLabel) { undoGroupIndex++; @@ -533,80 +732,145 @@ void ApplyAll(string undoLabel = "Pivot Aligner") Undo.RecordObject(sourceObject.transform, undoLabel); - Quaternion delta = Quaternion.Euler(rotX + fineX, rotY + fineY, rotZ + fineZ); - Vector3 posOff = new Vector3(posOffsetX, posOffsetY, posOffsetZ); + Quaternion deltaRotation = Quaternion.Euler( + rotX + fineX, + rotY + fineY, + rotZ + fineZ); - sourceObject.transform.position = pivotWorld + delta * (basePosition - pivotWorld) + posOff; - sourceObject.transform.rotation = delta * baseRotation; + Vector3 scaleMultiplier = new Vector3(scaleX, scaleY, scaleZ); + Vector3 positionOffset = new Vector3(posOffsetX, posOffsetY, posOffsetZ); + + Vector3 baseOffset = basePosition - pivotWorld; + + Vector3 scaledOffset = new Vector3( + baseOffset.x * scaleMultiplier.x, + baseOffset.y * scaleMultiplier.y, + baseOffset.z * scaleMultiplier.z); + + sourceObject.transform.position = + pivotWorld + + deltaRotation * scaledOffset + + positionOffset; + + sourceObject.transform.rotation = deltaRotation * baseRotation; + sourceObject.transform.localScale = Vector3.Scale(baseScale, scaleMultiplier); - // Collapse all RecordObject calls for this drag into one undo step Undo.CollapseUndoOperations(Undo.GetCurrentGroup() - undoGroupIndex + 1); } - void ResetRotation() + private void ResetRotation() { - rotX = rotY = rotZ = fineX = fineY = fineZ = 0f; - ApplyAll("Pivot Aligner — Reset Rotation"); + rotX = 0f; + rotY = 0f; + rotZ = 0f; + + fineX = 0f; + fineY = 0f; + fineZ = 0f; + + ApplyAll("Pivot Aligner - Reset Rotation"); } - void ResetPositionOffset() + private void ResetScale() { - posOffsetX = posOffsetY = posOffsetZ = 0f; - ApplyAll("Pivot Aligner — Reset Offset"); + scaleX = 1f; + scaleY = 1f; + scaleZ = 1f; + uniformScaleValue = 1f; + + ApplyAll("Pivot Aligner - Reset Scale"); } - void Apply() + private void ResetPositionOffset() { - if (sourceObject == null) return; + posOffsetX = 0f; + posOffsetY = 0f; + posOffsetZ = 0f; + + ApplyAll("Pivot Aligner - Reset Offset"); + } + + private void Apply() + { + if (sourceObject == null) + return; + Undo.SetCurrentGroupName("Pivot Aligner Apply"); Undo.CollapseUndoOperations(Undo.GetCurrentGroup()); + ResetTool(); } - void RevertAndReset() { RevertTransform(); ResetTool(); } + private void RevertAndReset() + { + RevertTransform(); + ResetTool(); + } - void RevertTransform() + private void RevertTransform() { - if (sourceObject == null || !hasPivot) return; + if (sourceObject == null || !hasPivot) + return; + Undo.RecordObject(sourceObject.transform, "Pivot Aligner Revert"); + sourceObject.transform.position = basePosition; sourceObject.transform.rotation = baseRotation; + sourceObject.transform.localScale = baseScale; } - void ResetTool() + private void ResetTool() { - state = ToolState.Idle; hasPivot = hasHighlight = false; - rotX = rotY = rotZ = fineX = fineY = fineZ = 0f; - posOffsetX = posOffsetY = posOffsetZ = 0f; - SceneView.RepaintAll(); Repaint(); - } + state = ToolState.Idle; + + hasPivot = false; + hasHighlight = false; + + rotX = 0f; + rotY = 0f; + rotZ = 0f; + + fineX = 0f; + fineY = 0f; + fineZ = 0f; - // ────────────────────────────────────────────────────────────────────────── - // Styles & layout helpers - // ────────────────────────────────────────────────────────────────────────── + scaleX = 1f; + scaleY = 1f; + scaleZ = 1f; + uniformScaleValue = 1f; - void InitStyles() + posOffsetX = 0f; + posOffsetY = 0f; + posOffsetZ = 0f; + + SceneView.RepaintAll(); + Repaint(); + } + + private void InitStyles() { - if (stylesInit) return; + if (stylesInit) + return; + stylesInit = true; - headerStyle = new GUIStyle(EditorStyles.boldLabel) - { - fontSize = 13, - alignment = TextAnchor.MiddleCenter, - normal = { textColor = new Color(0.65f, 0.88f, 1f) } - }; - sectionStyle = new GUIStyle(EditorStyles.boldLabel) - { normal = { textColor = new Color(0.85f, 0.85f, 0.85f) } }; - stateStyle = new GUIStyle(EditorStyles.miniLabel) - { - alignment = TextAnchor.MiddleRight, - normal = { textColor = new Color(0.40f, 0.75f, 0.50f) } - }; - subLabelStyle = new GUIStyle(EditorStyles.miniLabel) - { normal = { textColor = new Color(0.55f, 0.55f, 0.55f) } }; + + headerStyle = new GUIStyle(EditorStyles.boldLabel); + headerStyle.fontSize = 13; + headerStyle.alignment = TextAnchor.MiddleCenter; + headerStyle.normal.textColor = new Color(0.65f, 0.88f, 1f); + + sectionStyle = new GUIStyle(EditorStyles.boldLabel); + sectionStyle.normal.textColor = new Color(0.85f, 0.85f, 0.85f); + + stateStyle = new GUIStyle(EditorStyles.miniLabel); + stateStyle.alignment = TextAnchor.MiddleRight; + stateStyle.normal.textColor = new Color(0.40f, 0.75f, 0.50f); + + subLabelStyle = new GUIStyle(EditorStyles.miniLabel); + subLabelStyle.normal.textColor = new Color(0.55f, 0.55f, 0.55f); } - void DrawHR() + private void DrawHR() { Rect r = EditorGUILayout.GetControlRect(false, 1); EditorGUI.DrawRect(r, new Color(0.35f, 0.35f, 0.35f, 0.6f)); From 6bcc04fee2f044e080567a0578beb4bc30f590d5 Mon Sep 17 00:00:00 2001 From: mika Date: Sat, 27 Jun 2026 13:47:24 +0300 Subject: [PATCH 13/26] Add InvertedMaskImage script for UI masking --- Assets/Scripts/UI/InvertedMaskImage.cs | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) create mode 100644 Assets/Scripts/UI/InvertedMaskImage.cs diff --git a/Assets/Scripts/UI/InvertedMaskImage.cs b/Assets/Scripts/UI/InvertedMaskImage.cs new file mode 100644 index 0000000..a485cce --- /dev/null +++ b/Assets/Scripts/UI/InvertedMaskImage.cs @@ -0,0 +1,22 @@ +// Here is a simple script which must be places instead of Image (beneath the mask object) +// https://discussions.unity.com/t/ui-inverse-mask/590229/5 + +using UnityEngine; +using UnityEngine.Rendering; +using UnityEngine.UI; + +namespace UnityLibrary.UI +{ + public class InvertedMaskImage : Image + { + public override Material materialForRendering + { + get + { + Material result = base.materialForRendering; + result.SetInt("_StencilComp", (int)CompareFunction.NotEqual); + return result; + } + } + } +} From 0d46b8eee629a4c0ec61f7ce4547cfecbd568873 Mon Sep 17 00:00:00 2001 From: mika Date: Sat, 5 Sep 2026 17:50:21 +0300 Subject: [PATCH 14/26] Add usage instructions to SliderStyleCopier.cs Added comments for usage instructions and context. --- .../Editor/BatchTools/SliderStyleCopier.cs | 259 ++++++++++++++++++ 1 file changed, 259 insertions(+) create mode 100644 Assets/Scripts/Editor/BatchTools/SliderStyleCopier.cs diff --git a/Assets/Scripts/Editor/BatchTools/SliderStyleCopier.cs b/Assets/Scripts/Editor/BatchTools/SliderStyleCopier.cs new file mode 100644 index 0000000..9559541 --- /dev/null +++ b/Assets/Scripts/Editor/BatchTools/SliderStyleCopier.cs @@ -0,0 +1,259 @@ +// Put this file in any folder named "Editor". +// Window: Tools > UI > Slider Style Copier +// Also available as right-click on a Slider component: Copy / Paste Slider Style + +using System.Collections.Generic; +using UnityEditor; +using UnityEngine; +using UnityEngine.UI; + +namespace UnityLibrary.UI.Tools +{ + public class SliderStyleCopier : EditorWindow + { + [SerializeField] Slider source; + [SerializeField] List targets = new List(); + + [SerializeField] bool copySlider = true; // colors, transition, target graphic, fill/handle refs + [SerializeField] bool copyRects = true; // RectTransforms of children (root excluded) + [SerializeField] bool copyGraphics = true; // Image / RawImage / Text: sprite, color, type, settings + [SerializeField] bool copyValues = false; // value / min / max / wholeNumbers + + // Never copied: script ref and event wiring (target keeps its own listeners). + static readonly HashSet AlwaysSkip = new HashSet { "m_Script", "m_OnValueChanged" }; + static readonly HashSet ValueProps = new HashSet { "m_Value", "m_MinValue", "m_MaxValue", "m_WholeNumbers" }; + + static Slider clipboard; + SerializedObject so; + Vector2 scroll; + + [MenuItem("Tools/UI/Slider Style Copier")] + static void Open() => GetWindow("Slider Copier").Show(); + + void OnEnable() => so = new SerializedObject(this); + + void OnGUI() + { + if (so == null) so = new SerializedObject(this); + so.Update(); + + EditorGUILayout.PropertyField(so.FindProperty("source"), new GUIContent("Source Slider")); + + EditorGUILayout.Space(); + scroll = EditorGUILayout.BeginScrollView(scroll); + EditorGUILayout.PropertyField(so.FindProperty("targets"), new GUIContent("Targets"), true); + EditorGUILayout.EndScrollView(); + + EditorGUILayout.Space(); + EditorGUILayout.PropertyField(so.FindProperty("copySlider"), new GUIContent("Slider component")); + EditorGUILayout.PropertyField(so.FindProperty("copyRects"), new GUIContent("Child RectTransforms")); + EditorGUILayout.PropertyField(so.FindProperty("copyGraphics"), new GUIContent("Images / Graphics")); + EditorGUILayout.PropertyField(so.FindProperty("copyValues"), new GUIContent("Slider values (min/max/value)")); + + so.ApplyModifiedProperties(); + + EditorGUILayout.Space(); + using (new EditorGUILayout.HorizontalScope()) + { + if (GUILayout.Button("Add Selection To Targets")) AddSelectionToTargets(); + if (GUILayout.Button("Clear Targets")) { targets.Clear(); so.Update(); } + } + + EditorGUILayout.Space(); + using (new EditorGUI.DisabledScope(source == null)) + { + if (GUILayout.Button("Apply To Target List", GUILayout.Height(24))) + ApplyToMany(source, targets, Options()); + + if (GUILayout.Button("Apply To Current Selection", GUILayout.Height(24))) + ApplyToMany(source, SelectedSliders(), Options()); + } + + if (source == null) + EditorGUILayout.HelpBox("Assign a source slider. Target hierarchies must match the source hierarchy.", MessageType.Info); + } + + Opts Options() => new Opts { slider = copySlider, rects = copyRects, graphics = copyGraphics, values = copyValues }; + + void AddSelectionToTargets() + { + foreach (var s in SelectedSliders()) + if (s != source && !targets.Contains(s)) targets.Add(s); + so.Update(); + Repaint(); + } + + static List SelectedSliders() + { + var list = new List(); + foreach (var go in Selection.gameObjects) + { + var s = go.GetComponent(); + if (s != null && !list.Contains(s)) list.Add(s); + } + return list; + } + + // ---------------------------------------------------------------- context menu + + [MenuItem("CONTEXT/Slider/Copy Slider Style")] + static void ContextCopy(MenuCommand cmd) => clipboard = (Slider)cmd.context; + + [MenuItem("CONTEXT/Slider/Paste Slider Style", true)] + static bool ContextPasteValidate() => clipboard != null; + + [MenuItem("CONTEXT/Slider/Paste Slider Style")] + static void ContextPaste(MenuCommand cmd) + { + var list = SelectedSliders(); + var clicked = (Slider)cmd.context; + if (!list.Contains(clicked)) list.Add(clicked); + ApplyToMany(clipboard, list, new Opts { slider = true, rects = true, graphics = true, values = false }); + } + + // ---------------------------------------------------------------- copying + + struct Opts { public bool slider, rects, graphics, values; } + + static void ApplyToMany(Slider src, List list, Opts opts) + { + if (src == null || list == null) return; + + int group = Undo.GetCurrentGroup(); + Undo.SetCurrentGroupName("Copy Slider Style"); + + int done = 0; + foreach (var dst in list) + { + if (dst == null || dst == src) continue; + Undo.RegisterFullObjectHierarchyUndo(dst.gameObject, "Copy Slider Style"); + CopyNode(src.transform, dst.transform, src.transform, dst.transform, opts); + done++; + } + + Undo.CollapseUndoOperations(group); + Debug.Log($"Slider Style Copier: copied '{src.name}' to {done} slider(s).", src); + } + + static void CopyNode(Transform s, Transform d, Transform sRoot, Transform dRoot, Opts opts) + { + if (opts.rects && s != sRoot && s is RectTransform sr && d is RectTransform dr) + CopyRect(sr, dr); + + if (opts.graphics) + CopySameTypeComponents(s, d, sRoot, dRoot, null); + + if (opts.slider) + CopySameTypeComponents(s, d, sRoot, dRoot, opts.values ? null : ValueProps); + + if (s.childCount != d.childCount) + Debug.LogWarning($"Slider Style Copier: child count mismatch at '{d.name}' ({s.childCount} vs {d.childCount}). Extra children are ignored.", d); + + int n = Mathf.Min(s.childCount, d.childCount); + for (int i = 0; i < n; i++) + CopyNode(s.GetChild(i), d.GetChild(i), sRoot, dRoot, opts); + } + + static void CopyRect(RectTransform s, RectTransform d) + { + Undo.RecordObject(d, "Copy Slider Style"); + d.anchorMin = s.anchorMin; + d.anchorMax = s.anchorMax; + d.pivot = s.pivot; + d.anchoredPosition3D = s.anchoredPosition3D; + d.sizeDelta = s.sizeDelta; + d.localRotation = s.localRotation; + d.localScale = s.localScale; + PrefabUtility.RecordPrefabInstancePropertyModifications(d); + } + + static void CopySameTypeComponents(Transform s, Transform d, Transform sRoot, Transform dRoot, HashSet extraSkip) where T : Component + { + var src = s.GetComponents(); + var dst = d.GetComponents(); + for (int i = 0; i < src.Length && i < dst.Length; i++) + { + if (src[i].GetType() != dst[i].GetType()) continue; + CopyComponent(src[i], dst[i], sRoot, dRoot, extraSkip); + } + } + + // Serialized copy: covers every inspector field (colors, transition, sprite state, + // image type/fill settings, ...) without listing them one by one. + // Object references pointing inside the source hierarchy are remapped to the + // matching object in the target hierarchy; asset references are copied as-is. + static void CopyComponent(Component src, Component dst, Transform sRoot, Transform dRoot, HashSet extraSkip) + { + var from = new SerializedObject(src); + var to = new SerializedObject(dst); + var it = from.GetIterator(); + + bool enterChildren = true; + while (it.NextVisible(enterChildren)) + { + enterChildren = true; + + if (AlwaysSkip.Contains(it.propertyPath) || (extraSkip != null && extraSkip.Contains(it.propertyPath))) + { + enterChildren = false; // do not descend into skipped branches + continue; + } + + var tp = to.FindProperty(it.propertyPath); + if (tp == null) continue; + + if (it.propertyType == SerializedPropertyType.ObjectReference) + tp.objectReferenceValue = Remap(it.objectReferenceValue, sRoot, dRoot); + else if (!it.hasVisibleChildren) + to.CopyFromSerializedProperty(it); + } + + to.ApplyModifiedProperties(); // registers undo + prefab modifications + } + + static Object Remap(Object value, Transform sRoot, Transform dRoot) + { + if (value == null) return null; + + Transform t = value as Transform; + if (t == null && value is Component c) t = c.transform; + if (t == null && value is GameObject go) t = go.transform; + if (t == null) return value; // asset (sprite, material, ...) + if (!IsUnder(t, sRoot)) return value; // outside the slider hierarchy, keep as is + + var mapped = FindMatching(t, sRoot, dRoot); + if (mapped == null) return value; + + if (value is GameObject) return mapped.gameObject; + if (value is Transform) return mapped; + return mapped.GetComponent(value.GetType()); + } + + static bool IsUnder(Transform t, Transform root) + { + for (var p = t; p != null; p = p.parent) + if (p == root) return true; + return false; + } + + // Same sibling-index path under the target root. + static Transform FindMatching(Transform node, Transform sRoot, Transform dRoot) + { + var path = new List(); + for (var t = node; t != sRoot; t = t.parent) + { + if (t == null) return null; + path.Add(t.GetSiblingIndex()); + } + path.Reverse(); + + var d = dRoot; + for (int i = 0; i < path.Count; i++) + { + if (path[i] >= d.childCount) return null; + d = d.GetChild(path[i]); + } + return d; + } + } +} From 9e2a0568db000bcc7e77a597773c1b4e7d074f97 Mon Sep 17 00:00:00 2001 From: mika Date: Wed, 16 Sep 2026 22:10:59 +0300 Subject: [PATCH 15/26] Create SceneSizeAnalyzer.cs --- .../Scripts/Editor/Tools/SceneSizeAnalyzer.cs | 584 ++++++++++++++++++ 1 file changed, 584 insertions(+) create mode 100644 Assets/Scripts/Editor/Tools/SceneSizeAnalyzer.cs diff --git a/Assets/Scripts/Editor/Tools/SceneSizeAnalyzer.cs b/Assets/Scripts/Editor/Tools/SceneSizeAnalyzer.cs new file mode 100644 index 0000000..77638b9 --- /dev/null +++ b/Assets/Scripts/Editor/Tools/SceneSizeAnalyzer.cs @@ -0,0 +1,584 @@ +// SceneSizeAnalyzer.cs — put in an Editor/ folder. +// Tools > UnityLibrary > Scene Size Analyzer +// +// Parses a .unity scene file (text/YAML serialization) directly from disk and reports +// where the bytes go: per component type, per script, per field, per GameObject and +// per hierarchy subtree. Exports a text or HTML report. + +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Text; +using UnityEditor; +using UnityEditor.SceneManagement; +using UnityEngine; + +namespace UnityLibrary.EditorTools +{ + // ------------------------------------------------------------------ Window + + public class SceneSizeAnalyzerWindow : EditorWindow + { + [MenuItem("Tools/UnityLibrary/Scene Size Analyzer")] + public static void Open() => GetWindow("Scene Size Analyzer"); + + SceneAsset _scene; + int _topN = 25; + Vector2 _scroll; + SceneSizeReport _report; + string _text = ""; + + void OnGUI() + { + _scene = (SceneAsset)EditorGUILayout.ObjectField("Scene", _scene, typeof(SceneAsset), false); + + using (new EditorGUILayout.HorizontalScope()) + { + if (GUILayout.Button("Use Active Scene")) + { + var p = EditorSceneManager.GetActiveScene().path; + if (!string.IsNullOrEmpty(p)) _scene = AssetDatabase.LoadAssetAtPath(p); + } + _topN = EditorGUILayout.IntSlider("Top N", _topN, 5, 100); + } + + using (new EditorGUI.DisabledScope(_scene == null)) + { + if (GUILayout.Button("Analyze", GUILayout.Height(28))) Analyze(); + } + + if (_report == null) return; + + using (new EditorGUILayout.HorizontalScope()) + { + if (GUILayout.Button("Save HTML Report")) Save(true); + if (GUILayout.Button("Save Text Report")) Save(false); + if (GUILayout.Button("Copy Text")) EditorGUIUtility.systemCopyBuffer = _text; + } + + _scroll = EditorGUILayout.BeginScrollView(_scroll); + EditorGUILayout.TextArea(_text, GUILayout.ExpandHeight(true)); + EditorGUILayout.EndScrollView(); + } + + void Analyze() + { + string path = AssetDatabase.GetAssetPath(_scene); + var active = EditorSceneManager.GetActiveScene(); + if (active.path == path && active.isDirty) + Debug.LogWarning("Scene has unsaved changes — the report reflects the file on disk."); + + try + { + _report = SceneSizeReport.Analyze(path, _topN); + _text = SceneSizeReportWriter.ToText(_report); + } + catch (Exception e) + { + Debug.LogException(e); + _report = null; + } + } + + void Save(bool html) + { + string ext = html ? "html" : "txt"; + string name = Path.GetFileNameWithoutExtension(_report.ScenePath) + "_size_report"; + string file = EditorUtility.SaveFilePanel("Save report", "", name, ext); + if (string.IsNullOrEmpty(file)) return; + + File.WriteAllText(file, html ? SceneSizeReportWriter.ToHtml(_report) : _text); + if (html) Application.OpenURL("file://" + file); + else EditorUtility.RevealInFinder(file); + } + } + + // ------------------------------------------------------------------ Data + + public class SceneDoc + { + public int ClassId; + public long FileId; + public bool Stripped; + public string TypeName = "?"; + public string DisplayType = "?"; + public string Name; // m_Name + public long GameObjectId; // m_GameObject + public long ParentTransformId; // m_Father / m_TransformParent + public long PrefabInstanceId; // m_PrefabInstance (stripped docs) + public string ScriptGuid; // m_Script + public string SourcePrefabGuid; // m_SourcePrefab + public long Bytes; + public List> Fields = new List>(); + } + + public class GoNode + { + public long Id; + public string Name; + public string Path; + public long OwnBytes; // GameObject doc + its components + public long SubtreeBytes; + public GoNode Parent; + public List Children = new List(); + public long ParentTransformId; + public long ParentPrefabInstanceId; + public bool IsPrefabInstance; + } + + public struct Entry + { + public string Key; + public int Count; + public long Bytes; + } + + public class SceneSizeReport + { + public string ScenePath; + public long FileBytes; + public bool IsText; + public int TopN; + public long HeaderBytes; + public long UnownedBytes; + public List Docs = new List(); + public List ByType = new List(); + public List ByField = new List(); + public List TopDocs = new List(); + public List TopObjects = new List(); + public List TopSubtrees = new List(); + public List Hints = new List(); + + // ---------------------------------------------------------------- Analyze + + public static SceneSizeReport Analyze(string scenePath, int topN) + { + var r = new SceneSizeReport { ScenePath = scenePath, TopN = topN }; + r.FileBytes = new FileInfo(scenePath).Length; + + string text = File.ReadAllText(scenePath); + r.IsText = text.StartsWith("%YAML", StringComparison.Ordinal); + if (!r.IsText) + { + r.Hints.Add("Scene is not text-serialized. Set Edit > Project Settings > Editor > Asset Serialization to 'Force Text' and re-save."); + return r; + } + + Parse(r, text); + Aggregate(r); + BuildHints(r); + return r; + } + + // ---------------------------------------------------------------- Parse + + static void Parse(SceneSizeReport r, string text) + { + int nl = text.IndexOf("\r\n", StringComparison.Ordinal) >= 0 ? 2 : 1; + var reader = new StringReader(text); + SceneDoc doc = null; + string field = null; + long fieldBytes = 0; + bool expectType = false; + + void Flush() + { + if (doc != null && field != null) + doc.Fields.Add(new KeyValuePair(field, fieldBytes)); + field = null; + fieldBytes = 0; + } + + string line; + while ((line = reader.ReadLine()) != null) + { + long bytes = Encoding.UTF8.GetByteCount(line) + nl; + + if (line.StartsWith("--- !u!", StringComparison.Ordinal)) + { + Flush(); + doc = new SceneDoc { Bytes = bytes }; + r.Docs.Add(doc); + ParseHeader(line, doc); + expectType = true; + continue; + } + + if (doc == null) { r.HeaderBytes += bytes; continue; } + doc.Bytes += bytes; + + if (expectType) + { + doc.TypeName = line.TrimEnd(':'); + expectType = false; + continue; + } + + // Top-level field of the document: exactly two spaces of indentation. + if (line.Length > 2 && line[0] == ' ' && line[1] == ' ' && line[2] != ' ' && line[2] != '-') + { + Flush(); + int colon = line.IndexOf(':'); + field = colon > 2 ? line.Substring(2, colon - 2) : line.Trim(); + ExtractKnown(doc, field, line); + } + else if (line.StartsWith(" m_TransformParent:", StringComparison.Ordinal)) + { + doc.ParentTransformId = ParseFileId(line); // inside PrefabInstance.m_Modification + } + + fieldBytes += bytes; + } + Flush(); + } + + static void ParseHeader(string line, SceneDoc d) + { + // "--- !u!4 &12345" or "--- !u!4 &12345 stripped" + int i = 7; + int start = i; + while (i < line.Length && char.IsDigit(line[i])) i++; + int.TryParse(line.Substring(start, i - start), out d.ClassId); + + int amp = line.IndexOf('&', i); + if (amp >= 0) + { + int j = amp + 1; + if (j < line.Length && line[j] == '-') j++; + while (j < line.Length && char.IsDigit(line[j])) j++; + long.TryParse(line.Substring(amp + 1, j - amp - 1), out d.FileId); + } + d.Stripped = line.EndsWith("stripped", StringComparison.Ordinal); + } + + static void ExtractKnown(SceneDoc d, string key, string line) + { + switch (key) + { + case "m_Name": + if (d.Name == null) + { + int c = line.IndexOf(':'); + d.Name = line.Substring(c + 1).Trim().Trim('\'', '"'); + } + break; + case "m_GameObject": d.GameObjectId = ParseFileId(line); break; + case "m_Father": d.ParentTransformId = ParseFileId(line); break; + case "m_PrefabInstance": d.PrefabInstanceId = ParseFileId(line); break; + case "m_Script": d.ScriptGuid = ParseGuid(line); break; + case "m_SourcePrefab": d.SourcePrefabGuid = ParseGuid(line); break; + } + } + + static long ParseFileId(string line) + { + int i = line.IndexOf("fileID:", StringComparison.Ordinal); + if (i < 0) return 0; + i += 7; + while (i < line.Length && line[i] == ' ') i++; + int s = i; + if (i < line.Length && line[i] == '-') i++; + while (i < line.Length && char.IsDigit(line[i])) i++; + long.TryParse(line.Substring(s, i - s), out long id); + return id; + } + + static string ParseGuid(string line) + { + int i = line.IndexOf("guid:", StringComparison.Ordinal); + if (i < 0) return null; + i += 5; + while (i < line.Length && line[i] == ' ') i++; + int s = i; + while (i < line.Length && Uri.IsHexDigit(line[i])) i++; + return i - s == 32 ? line.Substring(s, 32) : null; + } + + // ---------------------------------------------------------------- Aggregate + + static void Aggregate(SceneSizeReport r) + { + var guidNames = new Dictionary(); + string GuidName(string guid) + { + if (guid == null) return null; + if (!guidNames.TryGetValue(guid, out var n)) + { + string p = AssetDatabase.GUIDToAssetPath(guid); + n = string.IsNullOrEmpty(p) ? "missing " + guid.Substring(0, 8) : Path.GetFileNameWithoutExtension(p); + guidNames[guid] = n; + } + return n; + } + + // Display type names + foreach (var d in r.Docs) + { + d.DisplayType = d.TypeName; + if (d.ClassId == 114 && d.ScriptGuid != null) d.DisplayType = "MonoBehaviour: " + GuidName(d.ScriptGuid); + else if (d.ClassId == 1001 && d.SourcePrefabGuid != null) d.DisplayType = "PrefabInstance: " + GuidName(d.SourcePrefabGuid); + if (d.Stripped) d.DisplayType += " (stripped)"; + } + + // Per type + var byType = new Dictionary(); + var byField = new Dictionary(); + foreach (var d in r.Docs) + { + Add(byType, d.DisplayType, d.Bytes); + foreach (var f in d.Fields) Add(byField, d.TypeName + "." + f.Key, f.Value); + } + r.ByType = byType.Values.OrderByDescending(e => e.Bytes).ToList(); + r.ByField = byField.Values.OrderByDescending(e => e.Bytes).Take(r.TopN).ToList(); + r.TopDocs = r.Docs.OrderByDescending(d => d.Bytes).Take(r.TopN).ToList(); + + // Hierarchy + var nodes = new Dictionary(); + var transformToGo = new Dictionary(); + + foreach (var d in r.Docs) + { + if (d.ClassId == 1) + nodes[d.FileId] = new GoNode + { + Id = d.FileId, + Name = d.Stripped ? "(prefab child)" : (string.IsNullOrEmpty(d.Name) ? "(unnamed)" : d.Name), + OwnBytes = d.Bytes, + ParentPrefabInstanceId = d.Stripped ? d.PrefabInstanceId : 0 + }; + else if (d.ClassId == 1001) + nodes[d.FileId] = new GoNode + { + Id = d.FileId, + Name = "[" + d.DisplayType + "]", + OwnBytes = d.Bytes, + IsPrefabInstance = true, + ParentTransformId = d.ParentTransformId + }; + } + + foreach (var d in r.Docs) + { + if (d.ClassId != 4 && d.ClassId != 224) continue; + transformToGo[d.FileId] = d.GameObjectId; + if (!d.Stripped && nodes.TryGetValue(d.GameObjectId, out var n)) n.ParentTransformId = d.ParentTransformId; + } + + // Components -> owner + foreach (var d in r.Docs) + { + if (d.ClassId == 1 || d.ClassId == 1001) continue; + GoNode owner = null; + if (d.GameObjectId != 0) nodes.TryGetValue(d.GameObjectId, out owner); + if (owner == null && d.Stripped) nodes.TryGetValue(d.PrefabInstanceId, out owner); + if (owner != null) owner.OwnBytes += d.Bytes; + else r.UnownedBytes += d.Bytes; + } + + // Parent links + foreach (var n in nodes.Values) + { + GoNode parent = null; + if (n.ParentPrefabInstanceId != 0) nodes.TryGetValue(n.ParentPrefabInstanceId, out parent); + else if (n.ParentTransformId != 0 && transformToGo.TryGetValue(n.ParentTransformId, out long goId)) + nodes.TryGetValue(goId, out parent); + if (parent != null && parent != n) + { + n.Parent = parent; + parent.Children.Add(n); + } + } + + var roots = nodes.Values.Where(n => n.Parent == null).ToList(); + var visited = new HashSet(); + foreach (var root in roots) Accumulate(root, root.Name, visited); + + r.TopObjects = nodes.Values.OrderByDescending(n => n.OwnBytes).Take(r.TopN).ToList(); + r.TopSubtrees = nodes.Values.Where(n => n.Children.Count > 0).OrderByDescending(n => n.SubtreeBytes).Take(r.TopN).ToList(); + } + + static void Accumulate(GoNode n, string path, HashSet visited) + { + if (!visited.Add(n)) return; + n.Path = path; + n.SubtreeBytes = n.OwnBytes; + foreach (var c in n.Children) + { + Accumulate(c, path + "/" + c.Name, visited); + n.SubtreeBytes += c.SubtreeBytes; + } + } + + static void Add(Dictionary dict, string key, long bytes) + { + dict.TryGetValue(key, out var e); + e.Key = key; e.Count++; e.Bytes += bytes; + dict[key] = e; + } + + // ---------------------------------------------------------------- Hints + + static readonly Dictionary EmbeddedAssetTypes = new Dictionary + { + { 43, "Mesh" }, { 28, "Texture2D" }, { 21, "Material" }, { 74, "AnimationClip" }, + { 48, "Shader" }, { 89, "Cubemap" }, { 117, "Texture3D" }, { 91, "AnimatorController" }, + }; + + static void BuildHints(SceneSizeReport r) + { + long total = Math.Max(1, r.FileBytes); + double Share(long b) => 100.0 * b / total; + + long prefab = r.ByType.Where(e => e.Key.StartsWith("PrefabInstance")).Sum(e => e.Bytes); + if (Share(prefab) > 15) + r.Hints.Add($"PrefabInstance overrides take {Share(prefab):0}% of the file. Large m_Modifications lists usually mean many per-instance overrides. Apply overrides to the prefab, use prefab variants, or reduce serialized fields on prefab components."); + + var scripts = r.ByType.Where(e => e.Key.StartsWith("MonoBehaviour")).ToList(); + long mono = scripts.Sum(e => e.Bytes); + if (Share(mono) > 15) + r.Hints.Add($"MonoBehaviour data takes {Share(mono):0}%. Biggest scripts: " + + string.Join(", ", scripts.Take(3).Select(e => e.Key.Replace("MonoBehaviour: ", "") + " " + Fmt(e.Bytes))) + + ". Check for large serialized arrays/strings; mark runtime caches [NonSerialized] or move data to ScriptableObjects / assets."); + + var embedded = r.Docs.Where(d => EmbeddedAssetTypes.ContainsKey(d.ClassId)).ToList(); + if (embedded.Count > 0) + r.Hints.Add($"{embedded.Count} asset object(s) are embedded in the scene ({Fmt(embedded.Sum(d => d.Bytes))}): " + + string.Join(", ", embedded.GroupBy(d => EmbeddedAssetTypes[d.ClassId]).Select(g => g.Key + " x" + g.Count())) + + ". Save them as project assets (e.g. generated/ProBuilder meshes, runtime-created materials)."); + + if (r.TopDocs.Count > 0 && Share(r.TopDocs[0].Bytes) > 10) + r.Hints.Add($"A single object dominates: {r.TopDocs[0].DisplayType} '{r.TopDocs[0].Name}' is {Share(r.TopDocs[0].Bytes):0}% of the file. See its largest fields in the report."); + + int goCount = r.Docs.Count(d => d.ClassId == 1); + if (goCount > 20000) + r.Hints.Add($"{goCount:N0} GameObjects in the scene. Consider prefabs, static batching via assets, additive scenes, or generating content at runtime."); + + long perObject = goCount > 0 ? (r.FileBytes - r.UnownedBytes) / goCount : 0; + if (goCount > 0 && r.Hints.Count == 0) + r.Hints.Add($"No single culprit; size is spread over {goCount:N0} objects (~{Fmt(perObject)} each). Check the per-type table for the heaviest component types."); + } + + public static string Fmt(long bytes) + { + if (bytes >= 1L << 30) return $"{bytes / (double)(1L << 30):0.00} GB"; + if (bytes >= 1L << 20) return $"{bytes / (double)(1L << 20):0.00} MB"; + if (bytes >= 1L << 10) return $"{bytes / 1024.0:0.0} KB"; + return bytes + " B"; + } + } + + // ------------------------------------------------------------------ Writers + + public static class SceneSizeReportWriter + { + static string Fmt(long b) => SceneSizeReport.Fmt(b); + static string Pct(long b, long total) => total > 0 ? $"{100.0 * b / total:0.0}%" : "0%"; + + public static string ToText(SceneSizeReport r) + { + var sb = new StringBuilder(); + long t = r.FileBytes; + sb.AppendLine($"Scene: {r.ScenePath}"); + sb.AppendLine($"Size: {Fmt(t)} ({t:N0} bytes) | {r.Docs.Count:N0} objects | {r.Docs.Count(d => d.ClassId == 1):N0} GameObjects"); + sb.AppendLine(); + + if (r.Hints.Count > 0) + { + sb.AppendLine("HINTS"); + foreach (var h in r.Hints) sb.AppendLine(" * " + h); + sb.AppendLine(); + } + if (!r.IsText) return sb.ToString(); + + sb.AppendLine("BY TYPE"); + foreach (var e in r.ByType.Take(r.TopN)) + sb.AppendLine($" {Fmt(e.Bytes),10} {Pct(e.Bytes, t),6} x{e.Count,-7} {e.Key}"); + sb.AppendLine(); + + sb.AppendLine("BY FIELD (Type.field, summed over all objects)"); + foreach (var e in r.ByField) + sb.AppendLine($" {Fmt(e.Bytes),10} {Pct(e.Bytes, t),6} x{e.Count,-7} {e.Key}"); + sb.AppendLine(); + + sb.AppendLine("LARGEST SINGLE OBJECTS"); + foreach (var d in r.TopDocs) + { + sb.AppendLine($" {Fmt(d.Bytes),10} {Pct(d.Bytes, t),6} {d.DisplayType} '{d.Name}' &{d.FileId}"); + foreach (var f in d.Fields.OrderByDescending(f => f.Value).Take(3)) + sb.AppendLine($" {"",10} {"",6} {f.Key}: {Fmt(f.Value)}"); + } + sb.AppendLine(); + + sb.AppendLine("LARGEST GAMEOBJECTS (object + own components)"); + foreach (var n in r.TopObjects) + sb.AppendLine($" {Fmt(n.OwnBytes),10} {Pct(n.OwnBytes, t),6} {n.Path}"); + sb.AppendLine(); + + sb.AppendLine("LARGEST HIERARCHY SUBTREES"); + foreach (var n in r.TopSubtrees) + sb.AppendLine($" {Fmt(n.SubtreeBytes),10} {Pct(n.SubtreeBytes, t),6} {n.Path} ({CountNodes(n):N0} objects)"); + sb.AppendLine(); + + sb.AppendLine($"Scene settings / unowned: {Fmt(r.UnownedBytes)} YAML header: {Fmt(r.HeaderBytes)}"); + return sb.ToString(); + } + + public static string ToHtml(SceneSizeReport r) + { + long t = r.FileBytes; + var sb = new StringBuilder(); + sb.Append("Scene Size Report"); + + sb.Append($"

{H(Path.GetFileName(r.ScenePath))}

"); + sb.Append($"
{H(r.ScenePath)}  |  {Fmt(t)} ({t:N0} bytes)  |  {r.Docs.Count:N0} objects  |  {r.Docs.Count(d => d.ClassId == 1):N0} GameObjects  |  {DateTime.Now:yyyy-MM-dd HH:mm}
"); + + if (r.Hints.Count > 0) + { + sb.Append("

Hints

    "); + foreach (var h in r.Hints) sb.Append("
  • " + H(h) + "
  • "); + sb.Append("
"); + } + if (!r.IsText) return sb.Append("").ToString(); + + Table(sb, "By type", "Type", r.ByType.Take(r.TopN).Select(e => (e.Key, e.Count, e.Bytes, (string)null)), t); + Table(sb, "By field (Type.field, summed over all objects)", "Field", r.ByField.Select(e => (e.Key, e.Count, e.Bytes, (string)null)), t); + Table(sb, "Largest single objects", "Object", r.TopDocs.Select(d => ( + $"{d.DisplayType} '{d.Name}' &{d.FileId}", 1, d.Bytes, + string.Join(", ", d.Fields.OrderByDescending(f => f.Value).Take(4).Select(f => $"{f.Key} {Fmt(f.Value)}")))), t); + Table(sb, "Largest GameObjects (object + own components)", "Path", r.TopObjects.Select(n => (n.Path, 1, n.OwnBytes, (string)null)), t); + Table(sb, "Largest hierarchy subtrees", "Path", r.TopSubtrees.Select(n => (n.Path, CountNodes(n), n.SubtreeBytes, (string)null)), t); + + sb.Append($"

Other

Scene settings / unowned: {Fmt(r.UnownedBytes)}  |  YAML header: {Fmt(r.HeaderBytes)}
"); + return sb.Append("").ToString(); + } + + static void Table(StringBuilder sb, string title, string col, IEnumerable<(string key, int count, long bytes, string sub)> rows, long total) + { + sb.Append($"

{H(title)}

"); + foreach (var (key, count, bytes, sub) in rows) + { + double pct = total > 0 ? 100.0 * bytes / total : 0; + sb.Append($""); + sb.Append($""); + sb.Append($""); + } + sb.Append("
Size%Count{H(col)}
{Fmt(bytes)}{pct:0.0}%{count:N0}{H(key)}"); + if (sub != null) sb.Append($"
{H(sub)}
"); + sb.Append("
"); + } + + static int CountNodes(GoNode n) => 1 + n.Children.Sum(CountNodes); + + static string H(string s) => string.IsNullOrEmpty(s) ? "" : + s.Replace("&", "&").Replace("<", "<").Replace(">", ">").Replace("'", "'"); + } +} From 182b052bf19703c1426e552e2b831fca57091eeb Mon Sep 17 00:00:00 2001 From: mika Date: Thu, 17 Sep 2026 23:12:36 +0300 Subject: [PATCH 16/26] add MiddleClickProperties.cs --- .../Editor/Tools/MiddleClickProperties.cs | 50 +++++++++++++++++++ 1 file changed, 50 insertions(+) create mode 100644 Assets/Scripts/Editor/Tools/MiddleClickProperties.cs diff --git a/Assets/Scripts/Editor/Tools/MiddleClickProperties.cs b/Assets/Scripts/Editor/Tools/MiddleClickProperties.cs new file mode 100644 index 0000000..a913452 --- /dev/null +++ b/Assets/Scripts/Editor/Tools/MiddleClickProperties.cs @@ -0,0 +1,50 @@ +// Press Middle Mouse Button on a GameObject in the Hierarchy to open its properties in the Inspector. + +using Unity.Hierarchy; +using Unity.Hierarchy.Editor; +using UnityEditor; +using UnityEngine; +using UnityEngine.UIElements; + +namespace UnityLibrary.EditorTools +{ + static class MiddleClickProperties + { + const string k_Hooked = "middleclick-properties--hooked"; + + [InitializeOnLoadMethod] + static void Init() + { + HierarchyWindow.BindViewItem += OnBindViewItem; + } + + static void OnBindViewItem(HierarchyWindow window, HierarchyView view, HierarchyViewItem item) + { + // View items are recycled, so register the callback only once per element. + if (item.ClassListContains(k_Hooked)) + return; + + item.AddToClassList(k_Hooked); + item.RegisterCallback(OnPointerDown, TrickleDown.TrickleDown); + } + + static void OnPointerDown(PointerDownEvent evt) + { + if (evt.button != (int)MouseButton.MiddleMouse) + return; + + if (evt.currentTarget is not HierarchyViewItem item) + return; + + if (item.Handler is not HierarchyGameObjectHandler handler) + return; + + GameObject go = handler.GetGameObject(item.Node); + if (go == null) + return; + + EditorUtility.OpenPropertyEditor(go); + evt.StopPropagation(); + } + } +} \ No newline at end of file From 6fce328cbd517c2af63e27b66617d96302bd179f Mon Sep 17 00:00:00 2001 From: mika Date: Sat, 19 Sep 2026 01:56:14 +0300 Subject: [PATCH 17/26] Clarify comment for SingleExePostProcessor Updated comment to clarify functionality and usage. --- .../BuildProcess/SingleExePostProcessor.cs | 120 ++++++++++++++++++ 1 file changed, 120 insertions(+) create mode 100644 Assets/Scripts/Editor/BuildProcess/SingleExePostProcessor.cs diff --git a/Assets/Scripts/Editor/BuildProcess/SingleExePostProcessor.cs b/Assets/Scripts/Editor/BuildProcess/SingleExePostProcessor.cs new file mode 100644 index 0000000..a009c63 --- /dev/null +++ b/Assets/Scripts/Editor/BuildProcess/SingleExePostProcessor.cs @@ -0,0 +1,120 @@ +// builds single standalone exe from your Unity build (using 7-Zip SFX module) +// Note: Change those hardcoded 7zip paths for you +// Note: Download SDK package for the 7zSD.sfx files https://www.7-zip.org/download.html + +using UnityEditor; +using UnityEditor.Callbacks; +using System; +using System.Diagnostics; +using System.IO; +using System.Text; + +namespace UnityLibrary.BuildTools +{ + public static class SingleExePostProcessor + { + private const string SevenZipExe = @"D:\Program Files\7-Zip\7z.exe"; + private const string SevenZipSfx = @"D:\sdk\lzma2603\bin\7zSD.sfx"; + + [PostProcessBuild(1000)] + public static void OnPostProcessBuild(BuildTarget target, string pathToBuiltProject) + { + if (target != BuildTarget.StandaloneWindows64) + return; + + string buildExe = Path.GetFullPath(pathToBuiltProject); + string buildDirectory = Path.GetDirectoryName(buildExe); + string exeName = Path.GetFileName(buildExe); + string gameName = Path.GetFileNameWithoutExtension(buildExe); + + if (buildDirectory == null) + return; + + if (!File.Exists(SevenZipExe)) + { + UnityEngine.Debug.LogError("7-Zip not found: " + SevenZipExe); + return; + } + + if (!File.Exists(SevenZipSfx)) + { + UnityEngine.Debug.LogError("7-Zip SFX module not found: " + SevenZipSfx); + return; + } + + string tempDirectory = Path.Combine(Path.GetTempPath(), "UnitySingleExe_" + Guid.NewGuid().ToString("N")); + Directory.CreateDirectory(tempDirectory); + + string archivePath = Path.Combine(tempDirectory, "game.7z"); + string configPath = Path.Combine(tempDirectory, "config.txt"); + string outputExe = Path.Combine(Directory.GetParent(buildDirectory)?.FullName ?? buildDirectory, gameName + "_Standalone.exe"); + + try + { + CreateArchive(buildDirectory, archivePath); + + string config = ";!@Install@!UTF-8!\r\n" + "Title=\"" + gameName + "\"\r\n" + "RunProgram=\"" + exeName + "\"\r\n" + "GUIMode=\"2\"\r\n" + ";!@InstallEnd@!\r\n"; + + File.WriteAllText(configPath, config, new UTF8Encoding(false)); + + using (FileStream output = File.Create(outputExe)) + { + AppendFile(output, SevenZipSfx); + AppendFile(output, configPath); + AppendFile(output, archivePath); + } + + UnityEngine.Debug.Log("Single EXE created: " + outputExe); + } + catch (Exception e) + { + UnityEngine.Debug.LogException(e); + } + finally + { + try + { + Directory.Delete(tempDirectory, true); + } + catch + { + } + } + } + + private static void CreateArchive(string buildDirectory, string archivePath) + { + ProcessStartInfo psi = new ProcessStartInfo + { + FileName = SevenZipExe, + WorkingDirectory = buildDirectory, + Arguments = "a -t7z -mx=5 \"" + archivePath + "\" \"*\"", + UseShellExecute = false, + CreateNoWindow = true, + RedirectStandardOutput = true, + RedirectStandardError = true + }; + + using Process process = Process.Start(psi); + + if (process == null) + throw new Exception("Could not start 7-Zip."); + + string stdout = process.StandardOutput.ReadToEnd(); + string stderr = process.StandardError.ReadToEnd(); + + process.WaitForExit(); + + if (process.ExitCode != 0) + { + throw new Exception("7-Zip failed.\n" + stdout + "\n" + stderr); + } + } + + private static void AppendFile(Stream destination, string file) + { + using FileStream source = File.OpenRead(file); + source.CopyTo(destination); + } + } +} From a0734b31be703eaf8c43afc2e540138d2fbbe3e9 Mon Sep 17 00:00:00 2001 From: mika Date: Sat, 19 Sep 2026 01:56:37 +0300 Subject: [PATCH 18/26] Change 7-Zip executable paths in SingleExePostProcessor Updated paths for SevenZipExe and SevenZipSfx to reflect new locations. --- Assets/Scripts/Editor/BuildProcess/SingleExePostProcessor.cs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Assets/Scripts/Editor/BuildProcess/SingleExePostProcessor.cs b/Assets/Scripts/Editor/BuildProcess/SingleExePostProcessor.cs index a009c63..e2950c2 100644 --- a/Assets/Scripts/Editor/BuildProcess/SingleExePostProcessor.cs +++ b/Assets/Scripts/Editor/BuildProcess/SingleExePostProcessor.cs @@ -13,8 +13,8 @@ namespace UnityLibrary.BuildTools { public static class SingleExePostProcessor { - private const string SevenZipExe = @"D:\Program Files\7-Zip\7z.exe"; - private const string SevenZipSfx = @"D:\sdk\lzma2603\bin\7zSD.sfx"; + private const string SevenZipExe = @"C:\Program Files\7-Zip\7z.exe"; + private const string SevenZipSfx = @"C:\sdk\lzma2603\bin\7zSD.sfx"; [PostProcessBuild(1000)] public static void OnPostProcessBuild(BuildTarget target, string pathToBuiltProject) From b5a9b5d4d2c33db9d3f2e4f0f0a88d6445a9ac44 Mon Sep 17 00:00:00 2001 From: mika Date: Sat, 19 Sep 2026 02:03:05 +0300 Subject: [PATCH 19/26] Update comments in SingleExePostProcessor.cs --- Assets/Scripts/Editor/BuildProcess/SingleExePostProcessor.cs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Assets/Scripts/Editor/BuildProcess/SingleExePostProcessor.cs b/Assets/Scripts/Editor/BuildProcess/SingleExePostProcessor.cs index e2950c2..b902720 100644 --- a/Assets/Scripts/Editor/BuildProcess/SingleExePostProcessor.cs +++ b/Assets/Scripts/Editor/BuildProcess/SingleExePostProcessor.cs @@ -1,6 +1,8 @@ // builds single standalone exe from your Unity build (using 7-Zip SFX module) // Note: Change those hardcoded 7zip paths for you // Note: Download SDK package for the 7zSD.sfx files https://www.7-zip.org/download.html +// Warning: This copies all build folder output there, you might not want debug symbols or other data +// Note: You could make it customize the exe icon also (with external tool calls to create .ico from project icon and assign it) using UnityEditor; using UnityEditor.Callbacks; From f369f512356e81b1845bd6c8121daab46f3a526a Mon Sep 17 00:00:00 2001 From: mika Date: Sat, 26 Sep 2026 23:12:13 +0300 Subject: [PATCH 20/26] Create KeystrokeVisualizer.cs --- .../Editor/Tools/KeystrokeVisualizer.cs | 306 ++++++++++++++++++ 1 file changed, 306 insertions(+) create mode 100644 Assets/Scripts/Editor/Tools/KeystrokeVisualizer.cs diff --git a/Assets/Scripts/Editor/Tools/KeystrokeVisualizer.cs b/Assets/Scripts/Editor/Tools/KeystrokeVisualizer.cs new file mode 100644 index 0000000..84c4897 --- /dev/null +++ b/Assets/Scripts/Editor/Tools/KeystrokeVisualizer.cs @@ -0,0 +1,306 @@ +// displays the currently held keys in a small window, useful for recording tutorials or presentations. + +using System.Collections.Generic; +using UnityEditor; +using UnityEngine; + +namespace UnityLibrary.EditorTools +{ + public class KeystrokeVisualizer : EditorWindow + { + private readonly List heldKeys = new List(); + + private bool ctrlHeld; + private bool shiftHeld; + private bool altHeld; + private bool cmdHeld; + + private string displayedKeys = ""; + private double lastReleaseTime; + + private float displayDuration = 2.0f; + private int fontSize = 30; + private bool showMouseClicks = true; + private bool showSettings; + + private GUIStyle keyStyle; + + private bool HasHeldKeys => ctrlHeld || shiftHeld || altHeld || cmdHeld || heldKeys.Count > 0; + + [MenuItem("Tools/UnityLibrary/Keystroke Visualizer")] + public static void OpenWindow() + { + KeystrokeVisualizer window = GetWindow(true, "Keystroke Visualizer", true); + window.minSize = new Vector2(360, 120); + window.ShowUtility(); + } + + private void OnEnable() + { + SceneView.beforeSceneGui += OnSceneGUI; + EditorApplication.update += OnEditorUpdate; + } + + private void OnDisable() + { + SceneView.beforeSceneGui -= OnSceneGUI; + EditorApplication.update -= OnEditorUpdate; + } + + private void OnEditorUpdate() + { + if (HasHeldKeys && !(EditorWindow.focusedWindow is SceneView)) + { + ClearHeldKeys(); + lastReleaseTime = EditorApplication.timeSinceStartup; + } + + if (HasHeldKeys || EditorApplication.timeSinceStartup - lastReleaseTime < displayDuration) + Repaint(); + } + + private void OnSceneGUI(SceneView sceneView) + { + Event e = Event.current; + + if (e == null) + return; + + if (e.type == EventType.KeyDown) + { + HandleKeyDown(e); + } + else if (e.type == EventType.KeyUp) + { + HandleKeyUp(e); + } + else if (showMouseClicks && e.type == EventType.MouseDown) + { + HandleMouseDown(e); + } + } + + private void HandleKeyDown(Event e) + { + KeyCode key = e.keyCode; + + if (key == KeyCode.None) + return; + + UpdateModifiers(e); + + if (!IsModifier(key) && !heldKeys.Contains(key)) + heldKeys.Add(key); + + UpdateHeldDisplay(); + } + + private void HandleKeyUp(Event e) + { + KeyCode key = e.keyCode; + + if (key == KeyCode.None) + return; + + UpdateModifiers(e); + + if (IsModifier(key)) + { + ReleaseModifier(key); + } + else + { + heldKeys.Remove(key); + } + + if (HasHeldKeys) + { + UpdateHeldDisplay(); + } + else + { + lastReleaseTime = EditorApplication.timeSinceStartup; + } + + Repaint(); + } + + private void UpdateModifiers(Event e) + { + ctrlHeld = e.control; + shiftHeld = e.shift; + altHeld = e.alt; + cmdHeld = e.command; + } + + private void ReleaseModifier(KeyCode key) + { + switch (key) + { + case KeyCode.LeftControl: + case KeyCode.RightControl: + ctrlHeld = false; + break; + + case KeyCode.LeftShift: + case KeyCode.RightShift: + shiftHeld = false; + break; + + case KeyCode.LeftAlt: + case KeyCode.RightAlt: + altHeld = false; + break; + + case KeyCode.LeftCommand: + case KeyCode.RightCommand: + cmdHeld = false; + break; + } + } + + private void UpdateHeldDisplay() + { + List parts = new List(); + + if (ctrlHeld) + parts.Add("Ctrl"); + + if (cmdHeld) + parts.Add("Cmd"); + + if (altHeld) + parts.Add("Alt"); + + if (shiftHeld) + parts.Add("Shift"); + + foreach (KeyCode key in heldKeys) + parts.Add(FormatKey(key)); + + if (parts.Count > 0) + displayedKeys = string.Join(" + ", parts); + + Repaint(); + } + + private void HandleMouseDown(Event e) + { + string mouseButton = ""; + + switch (e.button) + { + case 0: mouseButton = "Left Click"; break; + case 1: mouseButton = "Right Click"; break; + case 2: mouseButton = "Middle Click"; break; + default: return; + } + + UpdateModifiers(e); + + List parts = new List(); + + if (ctrlHeld) + parts.Add("Ctrl"); + + if (cmdHeld) + parts.Add("Cmd"); + + if (altHeld) + parts.Add("Alt"); + + if (shiftHeld) + parts.Add("Shift"); + + parts.Add(mouseButton); + + displayedKeys = string.Join(" + ", parts); + lastReleaseTime = EditorApplication.timeSinceStartup; + + Repaint(); + } + + private void ClearHeldKeys() + { + heldKeys.Clear(); + ctrlHeld = false; + shiftHeld = false; + altHeld = false; + cmdHeld = false; + } + + private static bool IsModifier(KeyCode key) + { + return key == KeyCode.LeftShift || key == KeyCode.RightShift || + key == KeyCode.LeftControl || key == KeyCode.RightControl || + key == KeyCode.LeftAlt || key == KeyCode.RightAlt || + key == KeyCode.LeftCommand || key == KeyCode.RightCommand; + } + + private static string FormatKey(KeyCode key) + { + string name = key.ToString(); + + if (name.StartsWith("Alpha")) + return name.Substring(5); + + switch (key) + { + case KeyCode.Return: return "Enter"; + case KeyCode.Escape: return "Esc"; + case KeyCode.Space: return "Space"; + case KeyCode.Backspace: return "Backspace"; + case KeyCode.Delete: return "Delete"; + case KeyCode.LeftArrow: return "Left"; + case KeyCode.RightArrow: return "Right"; + case KeyCode.UpArrow: return "Up"; + case KeyCode.DownArrow: return "Down"; + case KeyCode.KeypadEnter: return "Numpad Enter"; + default: return name; + } + } + + private void OnGUI() + { + EditorGUI.DrawRect(new Rect(0, 0, position.width, position.height), new Color(0.07f, 0.07f, 0.09f, 1f)); + + if (keyStyle == null) + { + keyStyle = new GUIStyle(EditorStyles.boldLabel); + keyStyle.alignment = TextAnchor.MiddleCenter; + keyStyle.wordWrap = true; + keyStyle.normal.textColor = Color.white; + } + + keyStyle.fontSize = fontSize; + + double elapsed = EditorApplication.timeSinceStartup - lastReleaseTime; + + float alpha = HasHeldKeys ? 1f : Mathf.Clamp01((float)(displayDuration - elapsed) / 0.35f); + + float contentHeight = showSettings ? position.height - 115f : position.height - 30f; + contentHeight = Mathf.Max(30f, contentHeight); + + if (!string.IsNullOrEmpty(displayedKeys) && alpha > 0f) + { + Color oldColor = GUI.color; + GUI.color = new Color(1f, 1f, 1f, alpha); + GUI.Label(new Rect(12, 8, position.width - 24, contentHeight), displayedKeys, keyStyle); + GUI.color = oldColor; + } + + GUILayout.FlexibleSpace(); + + showSettings = EditorGUILayout.Foldout(showSettings, "Settings", true); + + if (showSettings) + { + fontSize = EditorGUILayout.IntSlider("Font Size", fontSize, 16, 60); + displayDuration = EditorGUILayout.Slider("Duration", displayDuration, 0.5f, 5f); + showMouseClicks = EditorGUILayout.Toggle("Mouse Clicks", showMouseClicks); + } + + GUILayout.Space(8); + } + } +} From 527328c1e25658734a96ee9abd221e99d6a3310e Mon Sep 17 00:00:00 2001 From: mika Date: Fri, 2 Oct 2026 21:35:04 +0300 Subject: [PATCH 21/26] Add UnityIgnore script to manage Project window visibility This script hides files and folders in the Unity Project window based on rules defined in a .unityignore file. It provides functionality to toggle visibility and edit the ignore rules. --- .../Editor/ProjectWindow/UnityIgnore.cs | 442 ++++++++++++++++++ 1 file changed, 442 insertions(+) create mode 100644 Assets/Scripts/Editor/ProjectWindow/UnityIgnore.cs diff --git a/Assets/Scripts/Editor/ProjectWindow/UnityIgnore.cs b/Assets/Scripts/Editor/ProjectWindow/UnityIgnore.cs new file mode 100644 index 0000000..098c878 --- /dev/null +++ b/Assets/Scripts/Editor/ProjectWindow/UnityIgnore.cs @@ -0,0 +1,442 @@ +// UnityIgnore.cs - put this in any "Editor" folder. +// +// Hides files and folders from the Project window, driven by a gitignore-style +// ".unityignore" file in the project root (next to Assets/). +// +// Display only: hidden assets are still imported, referenced and built as usual. +// Toggle: Assets > Unity Ignore > Hide Ignored Files (Ctrl+Alt+H), also in the Project right-click menu. +// +// Unity has no public API for this, so the script filters the Project Browser's internal +// row lists through reflection. Member names were checked against the UnityCsReference +// source for 6000.0 - 6000.7. If they ever change, it logs one warning and switches itself off. + +using System; +using System.Collections; +using System.Collections.Generic; +using System.IO; +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Text; +using System.Text.RegularExpressions; +using UnityEditor; +using UnityEditorInternal; +using UnityEngine; + +namespace UnityLibrary.UnityIgnore +{ + [InitializeOnLoad] + static class UnityIgnore + { + const string IgnoreFile = ".unityignore"; + const string PrefKey = "UnityIgnore.Enabled"; + const string ToggleName = "Assets/Unity Ignore/Hide Ignored Files"; + const string ToggleMenu = ToggleName + " %&h"; + const string EditMenu = "Assets/Unity Ignore/Edit .unityignore"; + + const string Template = + "# .unityignore - hides matching files and folders from the Project window.\n" + + "# gitignore syntax, paths relative to the project root, not case sensitive.\n" + + "# Hidden assets are still imported and usable.\n" + + "#\n" + + "# desktop.ini\n" + + "# *.psd\n" + + "# /Assets/ScriptTemplates/\n"; + + const BindingFlags Declared = + BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly; + + struct Rule + { + public Regex regex; + public bool negate, dirOnly; + } + + static readonly List s_Rules = new List(); + static readonly Dictionary s_Cache = new Dictionary(); + + // Objects already handled: filtered row lists / result arrays, and data sources that carry our hook. + static readonly ConditionalWeakTable s_Seen = new ConditionalWeakTable(); + + static IList s_Browsers; + static MethodInfo s_ResetViews; + static bool s_Enabled, s_Broken; + static DateTime s_FileTime; + static double s_NextFileCheck; + + static UnityIgnore() + { + s_Enabled = EditorUserSettings.GetConfigValue(PrefKey) != "0"; + LoadRules(); + EditorApplication.update += Tick; + EditorApplication.projectChanged += s_Cache.Clear; + } + + // ------------------------------------------------------------------ menu + + [MenuItem(ToggleMenu, false, 2000)] + static void Toggle() + { + s_Enabled = !s_Enabled; + EditorUserSettings.SetConfigValue(PrefKey, s_Enabled ? "1" : "0"); + Refresh(); + } + + [MenuItem(ToggleMenu, true)] + static bool ToggleValidate() + { + Menu.SetChecked(ToggleName, s_Enabled); + return true; + } + + [MenuItem(EditMenu, false, 2001)] + static void Edit() + { + if (!File.Exists(IgnoreFile)) + File.WriteAllText(IgnoreFile, Template); + InternalEditorUtility.OpenFileAtLineExternal(Path.GetFullPath(IgnoreFile), 1); + } + + // ------------------------------------------------------------------ rules + + static void LoadRules() + { + string[] lines; + try + { + s_FileTime = File.GetLastWriteTimeUtc(IgnoreFile); // a missing file has a stable timestamp too + lines = File.Exists(IgnoreFile) ? File.ReadAllLines(IgnoreFile) : new string[0]; + } + catch (IOException) + { + s_FileTime = DateTime.MinValue; // file is mid-save, try again on the next check + return; + } + + s_Rules.Clear(); + s_Cache.Clear(); + + for (int n = 0; n < lines.Length; n++) + { + string line = lines[n].Trim(); + if (line.Length == 0 || line[0] == '#') + continue; + + Rule rule = new Rule(); + rule.negate = line[0] == '!'; + if (rule.negate) + line = line.Substring(1); + + rule.dirOnly = line.EndsWith("/"); + line = line.TrimEnd('/'); + bool anchored = line.Contains("/"); // "/x" or "a/x" starts at the project root, plain "x" matches at any depth + line = line.TrimStart('/'); + if (line.Length == 0) + continue; + + try + { + rule.regex = new Regex(GlobToRegex(line, anchored), RegexOptions.IgnoreCase | RegexOptions.CultureInvariant); + s_Rules.Add(rule); + } + catch (ArgumentException) + { + Debug.LogWarning("[UnityIgnore] Skipping bad pattern on line " + (n + 1) + ": " + lines[n]); + } + } + } + + static string GlobToRegex(string glob, bool anchored) + { + StringBuilder sb = new StringBuilder(anchored ? "^" : "^(?:.*/)?"); + + for (int i = 0; i < glob.Length; i++) + { + char c = glob[i]; + int close = c == '[' && i + 2 < glob.Length ? glob.IndexOf(']', i + 2) : -1; + + if (c == '*' && i + 1 < glob.Length && glob[i + 1] == '*') + { + i++; + if (i + 1 < glob.Length && glob[i + 1] == '/') + { + i++; + sb.Append("(?:.*/)?"); // "**/" = any number of folders, including none + } + else + { + sb.Append(".*"); + } + } + else if (c == '*') + { + sb.Append("[^/]*"); + } + else if (c == '?') + { + sb.Append("[^/]"); + } + else if (close > 0) + { + string set = glob.Substring(i + 1, close - i - 1); + bool not = set[0] == '!' || set[0] == '^'; + if (not) + set = set.Substring(1); + set = set.Replace("\\", "\\\\").Replace("[", "\\[").Replace("]", "\\]").Replace("^", "\\^"); + sb.Append(not ? "[^" : "[").Append(set).Append(']'); + i = close; + } + else + { + if (c == '\\' && i + 1 < glob.Length) + c = glob[++i]; + sb.Append(Regex.Escape(c.ToString())); + } + } + + return sb.Append('$').ToString(); + } + + static bool IsHidden(string guid) + { + return !string.IsNullOrEmpty(guid) && IsIgnored(AssetDatabase.GUIDToAssetPath(guid)); + } + + static bool IsIgnored(string path) + { + if (string.IsNullOrEmpty(path)) + return false; + + bool ignored; + if (s_Cache.TryGetValue(path, out ignored)) + return ignored; + + // A hidden folder hides everything inside it. Otherwise the last matching rule wins. + int slash = path.LastIndexOf('/'); + ignored = slash > 0 && IsIgnored(path.Substring(0, slash)); + if (!ignored) + { + bool isDir = AssetDatabase.IsValidFolder(path); + foreach (Rule rule in s_Rules) + if ((isDir || !rule.dirOnly) && rule.regex.IsMatch(path)) + ignored = !rule.negate; + } + + s_Cache[path] = ignored; + return ignored; + } + + // ------------------------------------------------------------------ project window + + static void Tick() + { + try + { + // Pick up edits to .unityignore (checked once a second). + if (EditorApplication.timeSinceStartup >= s_NextFileCheck) + { + s_NextFileCheck = EditorApplication.timeSinceStartup + 1; + if (File.GetLastWriteTimeUtc(IgnoreFile) != s_FileTime) + { + LoadRules(); + if (s_Enabled) + Refresh(); + return; + } + } + + FilterAll(); + } + catch (Exception e) + { + Fail(e); + } + } + + static bool Active + { + get { return s_Enabled && !s_Broken && s_Rules.Count > 0; } + } + + static IList Browsers() + { + if (s_Browsers == null) + { + Type type = typeof(EditorWindow).Assembly.GetType("UnityEditor.ProjectBrowser", true); + s_ResetViews = type.GetMethod("ResetViews", BindingFlags.Instance | BindingFlags.NonPublic); + s_Browsers = (IList)type.GetMethod("GetAllProjectBrowsers").Invoke(null, null); + } + return s_Browsers; + } + + static void FilterAll() + { + if (!Active) + return; + + foreach (object browser in Browsers()) + { + FilterTree(Get(browser, "m_AssetTree")); // one column layout + FilterTree(Get(browser, "m_FolderTree")); // two column layout: folder tree + FilterList(browser); // two column layout: right pane, and search results + } + } + + // Rebuilds every Project window, the same way Unity does after an asset change. + static void Refresh() + { + s_Cache.Clear(); + try + { + foreach (EditorWindow browser in Browsers()) + { + s_ResetViews.Invoke(browser, null); + browser.Repaint(); + } + FilterAll(); + } + catch (Exception e) + { + Fail(e); + } + } + + static void FilterTree(object tree) + { + object data = Get(tree, "data"); + if (data == null) + return; + + if (FirstTime(data)) + { + // Expanding or collapsing a folder rebuilds the rows lazily inside OnGUI. + // This callback fires right after that, so nothing flashes. + Action hook = delegate { FilterRows(data); }; + Set(data, "onVisibleRowsChanged", Delegate.Combine((Delegate)Get(data, "onVisibleRowsChanged"), hook)); + } + + FilterRows(data); // covers the rebuilds that skip the callback (ReloadData and friends) + } + + static void FilterRows(object data) + { + if (!Active) + return; + + try + { + IList rows = Get(data, "m_Rows") as IList; + if (rows == null || !FirstTime(rows)) + return; + + for (int i = rows.Count - 1; i >= 0; i--) + { + object item = rows[i]; + if (!IsHidden(Get(item, "Guid", true) as string)) + continue; + + rows.RemoveAt(i); + + // Also detach it from its parent, so a folder with nothing visible left loses its foldout arrow. + IList siblings = Get(Get(item, "parent"), "children") as IList; + if (siblings != null) + siblings.Remove(item); + } + } + catch (Exception e) + { + Fail(e); + } + } + + static void FilterList(object browser) + { + object hierarchy = Get(Get(Get(browser, "m_ListArea"), "m_LocalAssets"), "m_FilteredHierarchy"); + if (hierarchy == null) + return; + + // Single "|" on purpose: both arrays have to be stripped. + if (Strip(hierarchy, "m_Results") | Strip(hierarchy, "m_VisibleItems")) + ((EditorWindow)browser).Repaint(); + } + + static bool Strip(object hierarchy, string field) + { + Array items = Get(hierarchy, field) as Array; + if (items == null || !FirstTime(items)) + return false; + + List kept = new List(items.Length); + foreach (object item in items) + if (!IsHidden(Get(item, "guid") as string)) + kept.Add(item); + + if (kept.Count == items.Length) + return false; + + Array filtered = Array.CreateInstance(items.GetType().GetElementType(), kept.Count); + for (int i = 0; i < kept.Count; i++) + filtered.SetValue(kept[i], i); + + FirstTime(filtered); + Set(hierarchy, field, filtered); + return true; + } + + // ------------------------------------------------------------------ helpers + + static bool FirstTime(object obj) + { + object unused; + if (s_Seen.TryGetValue(obj, out unused)) + return false; + s_Seen.Add(obj, null); + return true; + } + + // Reads a field or property by name, searching base classes too. Null in, null out. + static object Get(object obj, string name, bool optional = false) + { + if (obj == null) + return null; + + for (Type type = obj.GetType(); type != null; type = type.BaseType) + { + FieldInfo field = type.GetField(name, Declared); + if (field != null) + return field.GetValue(obj); + + PropertyInfo property = type.GetProperty(name, Declared); + if (property != null) + return property.GetValue(obj, null); + } + + if (optional) + return null; + throw new MissingMemberException(obj.GetType().Name, name); + } + + static void Set(object obj, string name, object value) + { + for (Type type = obj.GetType(); type != null; type = type.BaseType) + { + FieldInfo field = type.GetField(name, Declared); + if (field != null) + { + field.SetValue(obj, value); + return; + } + } + throw new MissingMemberException(obj.GetType().Name, name); + } + + static void Fail(Exception e) + { + if (s_Broken) + return; + + s_Broken = true; + EditorApplication.update -= Tick; + Debug.LogWarning("[UnityIgnore] The Project window internals look different in this Unity version, so hiding is switched off.\n" + e); + } + } +} From 7fd8d6d45b8ec935df1b08be4fc19b585de8ed15 Mon Sep 17 00:00:00 2001 From: mika Date: Mon, 5 Oct 2026 21:56:01 +0300 Subject: [PATCH 22/26] Add note to LegacyAssetUpgrader.cs Add note about folder update behavior --- .../Editor/BatchTools/LegacyAssetUpgrader.cs | 235 ++++++++++++++++++ 1 file changed, 235 insertions(+) create mode 100644 Assets/Scripts/Editor/BatchTools/LegacyAssetUpgrader.cs diff --git a/Assets/Scripts/Editor/BatchTools/LegacyAssetUpgrader.cs b/Assets/Scripts/Editor/BatchTools/LegacyAssetUpgrader.cs new file mode 100644 index 0000000..6dfb806 --- /dev/null +++ b/Assets/Scripts/Editor/BatchTools/LegacyAssetUpgrader.cs @@ -0,0 +1,235 @@ +// NOTE updates whole selected folder (not just the ones that print warnings) + +using System; +using System.Collections.Generic; +using System.IO; +using UnityEditor; +using UnityEngine; + +namespace UnityLibrary.Editor.Tools +{ + public class LegacyAssetUpgrader : EditorWindow + { + private DefaultAsset rootFolder; + private bool includeSubfolders = true; + private Vector2 scroll; + private readonly List log = new(); + + [MenuItem("Tools/UnityLibrary/Batch/Upgrade Legacy Serialized Assets")] + public static void ShowWindow() + { + GetWindow("Asset Upgrader"); + } + + private void OnGUI() + { + EditorGUILayout.LabelField("Legacy Serialized Asset Upgrader", EditorStyles.boldLabel); + EditorGUILayout.Space(); + + EditorGUILayout.HelpBox( + "Re-saves assets and their .meta files using the current Unity serialization version.\n\n" + + "This fixes warnings such as:\n" + + "\"TextureImporter object at version 7, below the supported minimum (10)\"\n" + + "\"GameObject object at version 5, below the supported minimum (6)\"", + MessageType.Info); + + EditorGUILayout.Space(); + + rootFolder = (DefaultAsset)EditorGUILayout.ObjectField("Root Folder", rootFolder, typeof(DefaultAsset), false); + includeSubfolders = EditorGUILayout.Toggle("Include Subfolders", includeSubfolders); + + EditorGUILayout.Space(); + + using (new EditorGUI.DisabledScope(rootFolder == null)) + { + if (GUILayout.Button("Upgrade All Assets In Folder", GUILayout.Height(35))) + UpgradeFolder(); + } + + if (GUILayout.Button("Upgrade Selected Assets", GUILayout.Height(28))) + UpgradeSelected(); + + EditorGUILayout.Space(); + + if (log.Count > 0) + { + EditorGUILayout.LabelField("Log", EditorStyles.boldLabel); + + scroll = EditorGUILayout.BeginScrollView(scroll); + + foreach (string line in log) + EditorGUILayout.LabelField(line, EditorStyles.wordWrappedLabel); + + EditorGUILayout.EndScrollView(); + + if (GUILayout.Button("Clear Log")) + log.Clear(); + } + } + + private void UpgradeFolder() + { + string rootPath = AssetDatabase.GetAssetPath(rootFolder); + + if (!AssetDatabase.IsValidFolder(rootPath)) + { + Debug.LogError("Selected object is not a folder."); + return; + } + + string[] guids = AssetDatabase.FindAssets("", new[] { rootPath }); + List paths = new(); + + foreach (string guid in guids) + { + string path = AssetDatabase.GUIDToAssetPath(guid); + + if (AssetDatabase.IsValidFolder(path)) + continue; + + if (!includeSubfolders) + { + string directory = Path.GetDirectoryName(path)?.Replace("\\", "/"); + + if (!string.Equals(directory, rootPath, StringComparison.OrdinalIgnoreCase)) + continue; + } + + paths.Add(path); + } + + UpgradeAssets(paths); + } + + private void UpgradeSelected() + { + List paths = new(); + + foreach (UnityEngine.Object obj in Selection.objects) + { + string path = AssetDatabase.GetAssetPath(obj); + + if (string.IsNullOrEmpty(path)) + continue; + + if (AssetDatabase.IsValidFolder(path)) + { + string[] guids = AssetDatabase.FindAssets("", new[] { path }); + + foreach (string guid in guids) + { + string assetPath = AssetDatabase.GUIDToAssetPath(guid); + + if (!AssetDatabase.IsValidFolder(assetPath)) + paths.Add(assetPath); + } + } + else + { + paths.Add(path); + } + } + + UpgradeAssets(paths); + } + + private void UpgradeAssets(List paths) + { + if (paths.Count == 0) + { + Debug.LogWarning("No assets found."); + return; + } + + log.Clear(); + + try + { + for (int i = 0; i < paths.Count; i++) + { + string path = paths[i]; + + if (EditorUtility.DisplayCancelableProgressBar( + "Upgrading Legacy Assets", + $"{i + 1}/{paths.Count}\n{path}", + (float)i / paths.Count)) + { + log.Add("Cancelled."); + break; + } + + try + { + UpgradeAsset(path); + log.Add($"OK: {path}"); + } + catch (Exception e) + { + log.Add($"FAILED: {path} - {e.Message}"); + Debug.LogException(e); + } + } + } + finally + { + EditorUtility.ClearProgressBar(); + } + + AssetDatabase.SaveAssets(); + AssetDatabase.Refresh(); + + Debug.Log($"Legacy asset upgrade finished. Processed {paths.Count} assets."); + } + + private void UpgradeAsset(string path) + { + string extension = Path.GetExtension(path).ToLowerInvariant(); + + if (extension == ".prefab") + { + ResavePrefab(path); + Reserialize(path); + return; + } + + if (extension == ".unity") + { + Reserialize(path); + return; + } + + AssetImporter importer = AssetImporter.GetAtPath(path); + + if (importer != null) + { + EditorUtility.SetDirty(importer); + importer.SaveAndReimport(); + } + + Reserialize(path); + } + + private static void ResavePrefab(string path) + { + GameObject root = null; + + try + { + root = PrefabUtility.LoadPrefabContents(path); + PrefabUtility.SaveAsPrefabAsset(root, path); + } + finally + { + if (root != null) + PrefabUtility.UnloadPrefabContents(root); + } + } + + private static void Reserialize(string path) + { + AssetDatabase.ForceReserializeAssets( + new[] { path }, + ForceReserializeAssetsOptions.ReserializeAssetsAndMetadata); + } + } +} From e82df4c7b82f6316dfb962ce46cf4faa169d5b8c Mon Sep 17 00:00:00 2001 From: mika Date: Wed, 7 Oct 2026 21:37:59 +0300 Subject: [PATCH 23/26] Add PropertyWatcher for tracking Inspector changes This file implements a Property Watcher for Unity, allowing users to track changes to Inspector properties during Play mode. It provides functionality to watch properties, log changes, and display the source of changes in a user-friendly interface. --- .../Scripts/Editor/Debug/PropertyWatcher.cs | 587 ++++++++++++++++++ 1 file changed, 587 insertions(+) create mode 100644 Assets/Scripts/Editor/Debug/PropertyWatcher.cs diff --git a/Assets/Scripts/Editor/Debug/PropertyWatcher.cs b/Assets/Scripts/Editor/Debug/PropertyWatcher.cs new file mode 100644 index 0000000..451ceae --- /dev/null +++ b/Assets/Scripts/Editor/Debug/PropertyWatcher.cs @@ -0,0 +1,587 @@ +// Property Watcher - "who changed this?" for Inspector properties. +// Put this file in any Editor folder (Unity 2022.1 or newer). +// +// 1. Right-click a property in the Inspector > Watch Changes. +// 2. Enter Play mode. Window > Analysis > Property Watcher lists every change and its source. +// +// The value is compared at checkpoints in the player loop, so every change is caught and pinned +// to a loop stage (scripts, physics, animation...). +// If 0Harmony.dll (Harmony 2.2 or newer, the net48 build from the Harmony-Fat zip, set to Editor only) is in the project, +// download dll https://github.com/pardeike/Harmony/releases (copy to Assets/Plugins/PropertyWatcher or so) +// the code that can write the value is hooked as well, and the entry names the calling script with a call stack +// (click a row for the stack, double-click to open the file): +// - built-in components: the component's own void methods, e.g. Transform.set_position +// - script fields: every method whose IL writes the field + +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Globalization; +using System.IO; +using System.Linq; +using System.Reflection; +using System.Threading; +using UnityEditor; +using UnityEditorInternal; +using UnityEngine; +using UnityEngine.LowLevel; +using UnityEngine.SceneManagement; +using Debug = UnityEngine.Debug; +using Object = UnityEngine.Object; + +public class PropertyWatcher : EditorWindow +{ + const int MaxHistory = 30; + const string HarmonyId = "PropertyWatcher"; + const BindingFlags Declared = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly; + + [Serializable] + class Watch + { + public Object target; // serialized by the window, survives domain reloads + public string path; + [NonSerialized] public SerializedObject so; + [NonSerialized] public uint hash; + [NonSerialized] public string label, value; + [NonSerialized] public bool hooked, byInstance; + [NonSerialized] public List history; + } + + class Entry + { + public string time, source, from, to, stack, file; + public int line, count = 1; + } + + [Serializable] class Ref { public Object obj; } + + struct Checkpoint { } // marks our systems in the player loop + + [SerializeField] List watches = new List(); + [SerializeField] bool pauseOnChange; + Vector2 scroll; + Entry selected; + + static PropertyWatcher instance; + static int mainThread; + static bool busy, armed; + + // ---------------------------------------------------------------- setup + + [InitializeOnLoadMethod] + static void Init() + { + EditorApplication.contextualPropertyMenu += OnPropertyMenu; + EditorApplication.playModeStateChanged += OnPlayModeChanged; + SceneManager.sceneLoaded += (scene, mode) => Rebind(); + } + + [MenuItem("Window/Analysis/Property Watcher")] + static void Open() => GetWindow("Property Watcher"); + + void OnEnable() + { + instance = this; + mainThread = Thread.CurrentThread.ManagedThreadId; + // After the domain reload that starts Play mode this runs before any game code, so the hooks + // are in place before the game's methods get JIT-compiled (the JIT can inline small setters). + if (EditorApplication.isPlayingOrWillChangePlaymode) { Arm(); return; } + watches.RemoveAll(w => !w.target); // e.g. left over from a closed scene + Rebind(); + } + + void OnDisable() + { + Disarm(); + instance = null; + } + + static void OnPropertyMenu(GenericMenu menu, SerializedProperty property) + { + var targets = property.serializedObject.targetObjects; + string path = property.propertyPath; + bool watched = instance && instance.watches.Any(w => w.target == targets[0] && w.path == path); + + menu.AddItem(new GUIContent(watched ? "Stop Watching Changes" : "Watch Changes"), false, () => + { + var window = GetWindow("Property Watcher"); + foreach (var t in targets) + { + foreach (var old in window.watches.Where(w => w.target == t && w.path == path).ToArray()) Remove(old); + if (watched) continue; + var watch = new Watch { target = t, path = path }; + window.watches.Add(watch); + Bind(watch); + } + }); + } + + static void OnPlayModeChanged(PlayModeStateChange state) + { + if (!instance) return; + if (state == PlayModeStateChange.ExitingEditMode) + foreach (var w in instance.watches) w.history?.Clear(); + else if (state == PlayModeStateChange.EnteredPlayMode) Arm(); + else if (state == PlayModeStateChange.ExitingPlayMode) Disarm(); + else if (state == PlayModeStateChange.EnteredEditMode) Rebind(); // history stays readable + } + + static void Arm() + { + armed = true; + SetCheckpoints(true); + Rebind(); + } + + static void Disarm() + { + armed = false; + SetCheckpoints(false); + Unhook(); + if (instance) foreach (var w in instance.watches) w.hooked = false; + } + + static void Rebind() + { + if (instance) foreach (var w in instance.watches) Bind(w); + } + + static void Bind(Watch w) + { + w.history ??= new List(); + w.target = Refresh(w.target); + w.so = w.target ? new SerializedObject(w.target) : null; + if (w.so == null) return; + + var p = w.so.FindProperty(w.path); + string component = ObjectNames.NicifyVariableName(w.target.GetType().Name); + w.label = w.target.name + " > " + component + " > " + (p != null ? p.displayName : w.path); + if (p != null) { w.hash = p.contentHash; w.value = Format(p); } + + if (armed && !w.hooked) { w.hooked = true; Hook(w); } + } + + // Entering and exiting Play mode reloads the scene: the C# wrapper can go stale while the + // instance ID lives on. A JSON round trip resolves the reference again by ID. + static Object Refresh(Object obj) + { + var r = new Ref { obj = obj }; + JsonUtility.FromJsonOverwrite(JsonUtility.ToJson(r), r); + return r.obj ? r.obj : obj; + } + + static void Remove(Watch w) + { + if (instance) instance.watches.Remove(w); + foreach (var list in hooks.Values) list.Remove(w); + } + + // ---------------------------------------------------------------- change detection + + static readonly string[] Stages = { "Script", "Physics", "Director", "Animation", "AI", "Constraint", "Particle", "Cloth" }; + + // Adds (or strips) a value check after every interesting player-loop system and at the end of each phase. + static void SetCheckpoints(bool install) + { + var loop = PlayerLoop.GetCurrentPlayerLoop(); + var phases = loop.subSystemList; + if (phases == null) return; + + for (int i = 0; i < phases.Length; i++) + { + string phase = phases[i].type?.Name; + var list = new List(); + if (install && i == 0) list.Add(MakeCheckpoint("Editor: Inspector or editor code, between frames")); + + foreach (var system in phases[i].subSystemList ?? new PlayerLoopSystem[0]) + { + if (system.type == typeof(Checkpoint)) continue; + list.Add(system); + string name = system.type?.Name ?? ""; + if (install && Stages.Any(k => name.Contains(k))) + list.Add(MakeCheckpoint((name.Contains("Script") ? "Scripts: " : "Engine: ") + phase + "." + name)); + } + + if (install && (list.Count == 0 || list[list.Count - 1].type != typeof(Checkpoint))) + list.Add(MakeCheckpoint("Other: " + phase)); + phases[i].subSystemList = list.ToArray(); + } + PlayerLoop.SetPlayerLoop(loop); + } + + static PlayerLoopSystem MakeCheckpoint(string label) => new PlayerLoopSystem + { + type = typeof(Checkpoint), + updateDelegate = () => + { + if (instance) foreach (var w in instance.watches) Check(w, null, false, label); + } + }; + + // via == null: player-loop checkpoint. Otherwise called right before / after a hooked method. + // Runs inside game code when hooked, so it must never throw. + static void Check(Watch w, MethodBase via, bool after, string label) + { + if (busy || w.so == null || !w.target) return; + busy = true; // so.Update() can run user serialization callbacks + try + { + w.so.Update(); + var p = w.so.FindProperty(w.path); + if (p == null || p.contentHash == w.hash) return; + + var e = via == null ? new Entry { source = label } + : after ? Describe(via) + : new Entry { source = "Unknown (changed before " + Pretty(via) + " ran)" }; + e.time = DateTime.Now.ToString("HH:mm:ss") + " #" + Time.frameCount; + e.from = w.value; + e.to = w.value = Format(p); + w.hash = p.contentHash; + + var last = w.history.Count > 0 ? w.history[0] : null; + if (last != null && last.source == e.source && last.line == e.line) + { + last.count++; // same source again: update the row instead of adding one + last.time = e.time; last.from = e.from; last.to = e.to; last.stack = e.stack; + } + else + { + w.history.Insert(0, e); + if (w.history.Count > MaxHistory) w.history.RemoveAt(MaxHistory); + } + + if (instance && instance.pauseOnChange) Debug.Break(); + } + catch (Exception) { } // e.g. target destroyed mid-frame + finally { busy = false; } + } + + static string Format(SerializedProperty p) + { + try + { + switch (p.propertyType) + { + case SerializedPropertyType.Quaternion: return Text(p.quaternionValue.eulerAngles); + case SerializedPropertyType.ObjectReference: return p.objectReferenceValue ? p.objectReferenceValue.name : "None"; + case SerializedPropertyType.Enum: return p.enumValueIndex >= 0 ? p.enumDisplayNames[p.enumValueIndex] : p.intValue.ToString(); + case SerializedPropertyType.Generic: return (p.isArray ? p.arraySize + " items" : p.type) + " #" + p.contentHash.ToString("X8"); + default: return Text(p.boxedValue); + } + } + catch { return "#" + p.contentHash.ToString("X8"); } + } + + static string Text(object v) => v is IFormattable f ? f.ToString("0.###", CultureInfo.InvariantCulture) : v?.ToString() ?? "null"; + + // ---------------------------------------------------------------- attribution (optional Harmony) + + static Type harmonyType = FindType("HarmonyLib.Harmony"); + static object harmony, prefix, postfix; + static MethodInfo patchMethod, originalOf; + static readonly Dictionary> hooks = new Dictionary>(); // by method handle + static readonly string[] NotUser = { "UnityEngine", "UnityEditor", "Unity.Mathematics", "System", "mscorlib", "netstandard", "Mono.", "0Harmony", "MonoMod" }; + + static Type FindType(string name) => AppDomain.CurrentDomain.GetAssemblies().Select(a => a.GetType(name)).FirstOrDefault(t => t != null); + + static bool IsUserCode(Type t) + { + string assembly = t.Assembly.GetName().Name; + return !NotUser.Any(n => assembly.StartsWith(n)); + } + + // Harmony is used through reflection so the tool compiles with or without the DLL. + static bool InitHarmony() + { + if (harmony != null) return true; + if (harmonyType == null) return false; + try + { + const BindingFlags flags = BindingFlags.Static | BindingFlags.NonPublic; + var wrap = harmonyType.Assembly.GetType("HarmonyLib.HarmonyMethod").GetConstructor(new[] { typeof(MethodInfo) }); + prefix = wrap.Invoke(new object[] { typeof(PropertyWatcher).GetMethod(nameof(Pre), flags) }); + postfix = wrap.Invoke(new object[] { typeof(PropertyWatcher).GetMethod(nameof(Post), flags) }); + patchMethod = harmonyType.GetMethods().First(m => m.Name == "Patch" && m.GetParameters().Length >= 3); + originalOf = harmonyType.GetMethod("GetOriginalMethodFromStackframe", new[] { typeof(StackFrame) }); + harmony = Activator.CreateInstance(harmonyType, HarmonyId); + return true; + } + catch (Exception e) + { + Debug.LogWarning("Property Watcher: Harmony was found but could not be set up: " + e.Message); + harmonyType = null; + return false; + } + } + + static void Hook(Watch w) + { + if (!InitHarmony()) return; + var field = FindUserField(w.target.GetType(), w.path); + w.byInstance = field == null; + + if (field != null) + { + // Script field: hook every method that writes it; any instance may be the one written. + foreach (var m in FindWriters(field)) Patch(m, w); + return; + } + + // Engine property: hook the component's own void methods (setters, Translate, SetParent...). + for (var t = w.target.GetType(); t != null && t != typeof(Component) && t != typeof(Object); t = t.BaseType) + { + if (IsUserCode(t)) continue; + foreach (var m in t.GetMethods(Declared)) + if (m.ReturnType == typeof(void) && !m.ContainsGenericParameters && !m.Name.StartsWith("Get") && IL(m) != null) + Patch(m, w); + } + } + + static void Patch(MethodBase m, Watch w) + { + if (!hooks.TryGetValue(m.MethodHandle.Value, out var list)) + { + try + { + var args = new object[patchMethod.GetParameters().Length]; // (original, prefix, postfix, transpiler, finalizer) + args[0] = m; args[1] = prefix; args[2] = postfix; + patchMethod.Invoke(harmony, args); + } + catch { return; } // not patchable, skip + hooks[m.MethodHandle.Value] = list = new List(); + } + if (!list.Contains(w)) list.Add(w); + } + + static void Unhook() + { + if (harmony != null && hooks.Count > 0) + { + var unpatch = harmonyType.GetMethod("UnpatchSelf", Type.EmptyTypes) ?? harmonyType.GetMethod("UnpatchAll", new[] { typeof(string) }); + unpatch?.Invoke(harmony, unpatch.GetParameters().Length == 0 ? null : new object[] { HarmonyId }); + } + hooks.Clear(); + } + + // Harmony injects these parameters by name. + static void Pre(object __instance, MethodBase __originalMethod) => OnHook(__instance, __originalMethod, false); + static void Post(object __instance, MethodBase __originalMethod) => OnHook(__instance, __originalMethod, true); + + static void OnHook(object target, MethodBase method, bool after) + { + if (busy || Thread.CurrentThread.ManagedThreadId != mainThread) return; + if (!hooks.TryGetValue(method.MethodHandle.Value, out var list)) return; + for (int i = 0; i < list.Count; i++) + { + var w = list[i]; + if (!w.byInstance || (target is Object o && o == w.target)) Check(w, method, after, null); + } + } + + // Builds the "who" text and call stack for a change that a hooked method just made. + static Entry Describe(MethodBase via) + { + var e = new Entry(); + var lines = new List(); + string who = null, first = null; + + foreach (var frame in new StackTrace(true).GetFrames() ?? new StackFrame[0]) + { + var m = FrameMethod(frame); + if (m == null || m.DeclaringType == null || m.DeclaringType == typeof(PropertyWatcher)) continue; + if (m.DeclaringType == via.DeclaringType && m.Name == via.Name) continue; // the hooked method itself + if (m.DeclaringType.Name.StartsWith("DynamicMethodDefinition")) continue; // unresolved Harmony frame + + string name = Pretty(m), file = frame.GetFileName(); + bool hasFile = !string.IsNullOrEmpty(file); + lines.Add(name + (hasFile ? " " + Path.GetFileName(file) + ":" + frame.GetFileLineNumber() : "")); + first ??= name; + + if (!IsUserCode(m.DeclaringType)) continue; + who ??= name; + if (e.file == null && hasFile) { e.file = file; e.line = frame.GetFileLineNumber(); } // hooked methods have no line info + } + + who ??= first; + string writer = Pretty(via); + e.source = !IsUserCode(via.DeclaringType) ? (who ?? "Unity") + " -> " + writer // script, then the engine setter it called + : who == null || who == writer ? writer + : writer + " <- " + who; // field writer, then its caller + e.stack = string.Join("\n", lines); + return e; + } + + // A hooked method shows up on the stack as Harmony's replacement; map it back to the original. + static MethodBase FrameMethod(StackFrame frame) + { + MethodBase m = null; + try { m = originalOf?.Invoke(null, new object[] { frame }) as MethodBase; } catch { } + return m ?? frame.GetMethod(); + } + + static string Pretty(MethodBase m) + { + var t = m.DeclaringType; + string name = m.Name; + while (t != null && t.IsNested && t.Name.StartsWith("<")) // lambda, coroutine, async + { + if (name == "MoveNext") name = t.Name; + t = t.DeclaringType; + } + int end = name.IndexOf('>'); + if (name.StartsWith("<") && end > 1) name = name.Substring(1, end - 1); + return (t != null ? t.Name + "." : "") + name; + } + + // Deepest field on the property path that is declared in project code (null for native properties). + static FieldInfo FindUserField(Type type, string path) + { + FieldInfo best = null; + foreach (string part in path.Replace(".Array.data[", "[").Split('.')) + { + int bracket = part.IndexOf('['); + string name = bracket < 0 ? part : part.Substring(0, bracket); + + FieldInfo field = null; + for (var t = type; t != null && field == null; t = t.BaseType) field = t.GetField(name, Declared); + if (field == null) break; + + if (IsUserCode(field.DeclaringType)) best = field; + type = field.FieldType; + if (bracket >= 0) type = type.IsArray ? type.GetElementType() : type.IsGenericType ? type.GetGenericArguments()[0] : type; + } + return best; + } + + static IEnumerable FindWriters(FieldInfo field) + { + var home = field.DeclaringType.Assembly; + string homeName = home.GetName().Name; + + // A private field can only be written by its own class (and the lambdas/coroutines nested in it). + IEnumerable types = field.IsPrivate + ? WithNested(field.DeclaringType) + : AppDomain.CurrentDomain.GetAssemblies() + .Where(a => !a.IsDynamic && (a == home || (!field.IsAssembly && a.GetReferencedAssemblies().Any(r => r.Name == homeName)))) + .SelectMany(SafeTypes); + + foreach (var t in types) + { + if (t.IsValueType) continue; // struct methods are left alone, they fall back to the loop stage + foreach (var m in t.GetMethods(Declared | BindingFlags.Static)) + if (!m.ContainsGenericParameters && Writes(m, field)) yield return m; + } + } + + static IEnumerable WithNested(Type t) => + new[] { t }.Concat(t.GetNestedTypes(BindingFlags.Public | BindingFlags.NonPublic).SelectMany(WithNested)); + + static IEnumerable SafeTypes(Assembly a) + { + try { return a.GetTypes(); } + catch (ReflectionTypeLoadException e) { return e.Types.Where(t => t != null); } + } + + static byte[] IL(MethodBase m) + { + try { return m.GetMethodBody()?.GetILAsByteArray(); } + catch { return null; } + } + + // True if the method contains stfld / ldflda for the field (ldflda covers "field.x = ..." and ref use). + static bool Writes(MethodBase m, FieldInfo field) + { + var il = IL(m); + if (il == null) return false; + + for (int i = 0; i + 4 < il.Length; i++) + { + if (il[i] != 0x7D && il[i] != 0x7C) continue; // stfld, ldflda + int token = BitConverter.ToInt32(il, i + 1); + int table = token >> 24; + if (table != 0x04 && table != 0x0A) continue; // FieldDef, MemberRef + try + { + var f = m.Module.ResolveField(token); + if (f.Module == field.Module && f.MetadataToken == field.MetadataToken) return true; + } + catch { } // the bytes were not a field token + } + return false; + } + + // ---------------------------------------------------------------- window + + void OnInspectorUpdate() => Repaint(); + + void OnGUI() + { + using (new EditorGUILayout.HorizontalScope(EditorStyles.toolbar)) + { + pauseOnChange = GUILayout.Toggle(pauseOnChange, "Pause on change", EditorStyles.toolbarButton); + if (GUILayout.Button("Clear history", EditorStyles.toolbarButton)) + foreach (var w in watches) w.history?.Clear(); + GUILayout.FlexibleSpace(); + GUILayout.Label(harmonyType != null ? "Harmony: on" : "Harmony: not found", EditorStyles.miniLabel); + } + + if (harmonyType == null) + EditorGUILayout.HelpBox("Without Harmony only the player-loop stage of a change is known. Add 0Harmony.dll (Harmony 2.2+, net48 build) to the project to see the calling script.", MessageType.Info); + if (watches.Count == 0) + EditorGUILayout.HelpBox("Right-click a property in the Inspector and choose \"Watch Changes\".", MessageType.Info); + + scroll = EditorGUILayout.BeginScrollView(scroll); + foreach (var w in watches.ToArray()) DrawWatch(w); + EditorGUILayout.EndScrollView(); + } + + void DrawWatch(Watch w) + { + w.history ??= new List(); + using (new EditorGUILayout.VerticalScope(EditorStyles.helpBox)) + { + using (new EditorGUILayout.HorizontalScope()) + { + if (GUILayout.Button(w.label ?? w.path, EditorStyles.boldLabel)) EditorGUIUtility.PingObject(w.target); + if (GUILayout.Button("Remove", EditorStyles.miniButton, GUILayout.Width(60))) Remove(w); + } + + if (!w.target || w.so == null) + { + EditorGUILayout.LabelField("Object is gone."); + return; + } + + if (!EditorApplication.isPlaying) // outside Play mode just mirror the Inspector + { + w.so.Update(); + var p = w.so.FindProperty(w.path); + if (p != null) w.value = Format(p); + } + + EditorGUILayout.LabelField("Current", w.value); + EditorGUILayout.LabelField("Last changed by", w.history.Count > 0 ? w.history[0].source : "-"); + + var ev = Event.current; + foreach (var e in w.history) + { + string row = e.time + " " + e.source + (e.count > 1 ? " x" + e.count : "") + " " + e.from + " -> " + e.to; + var style = e == selected ? EditorStyles.boldLabel : EditorStyles.label; + var rect = GUILayoutUtility.GetRect(new GUIContent(row), style); + + // click: show the stack, double-click: open the script + if (ev.type == EventType.MouseDown && rect.Contains(ev.mousePosition)) + { + selected = e; + if (ev.clickCount == 2 && !string.IsNullOrEmpty(e.file)) + InternalEditorUtility.OpenFileAtLineExternal(e.file, e.line); + ev.Use(); + } + GUI.Label(rect, row, style); + } + + if (selected != null && w.history.Contains(selected) && !string.IsNullOrEmpty(selected.stack)) + EditorGUILayout.HelpBox(selected.stack, MessageType.None); + } + } +} From 9d05a5340d9e1be8473a96a4bc0e1321b977f6ef Mon Sep 17 00:00:00 2001 From: mika Date: Mon, 26 Oct 2026 21:24:03 +0200 Subject: [PATCH 24/26] Add files via upload --- .../Editor/ContextMenu/MeshRendererSize.cs | 28 +++++++++++++++++++ 1 file changed, 28 insertions(+) create mode 100644 Assets/Scripts/Editor/ContextMenu/MeshRendererSize.cs diff --git a/Assets/Scripts/Editor/ContextMenu/MeshRendererSize.cs b/Assets/Scripts/Editor/ContextMenu/MeshRendererSize.cs new file mode 100644 index 0000000..48e381b --- /dev/null +++ b/Assets/Scripts/Editor/ContextMenu/MeshRendererSize.cs @@ -0,0 +1,28 @@ + +using UnityEditor; +using UnityEngine; + +namespace UnityLibrary.EditorTools +{ + public static class MeshRendererSize + { + [MenuItem("CONTEXT/MeshRenderer/Get Size")] + private static void GetSize(MenuCommand command) + { + MeshRenderer renderer = (MeshRenderer)command.context; + + Debug.Log( + $"Renderer size (local): {FormatSize(renderer.localBounds.size)}\n" + + $"Bounds size (world): {FormatSize(renderer.bounds.size)}", + renderer + ); + } + + private static string FormatSize(Vector3 size) + { + return $"X: {size.x:F3}, " + + $"Y: {size.y:F3}, " + + $"Z: {size.z:F3}"; + } + } +} From 6cb028c78ae711cd10fc78943d605a6b79dc5d3a Mon Sep 17 00:00:00 2001 From: mika Date: Mon, 9 Nov 2026 21:09:13 +0200 Subject: [PATCH 25/26] add megascans URP editor AssetPostprocessor --- .../Editor/Importers/MegaScansURPImporter.cs | 647 ++++++++++++++++++ 1 file changed, 647 insertions(+) create mode 100644 Assets/Scripts/Editor/Importers/MegaScansURPImporter.cs diff --git a/Assets/Scripts/Editor/Importers/MegaScansURPImporter.cs b/Assets/Scripts/Editor/Importers/MegaScansURPImporter.cs new file mode 100644 index 0000000..ce75453 --- /dev/null +++ b/Assets/Scripts/Editor/Importers/MegaScansURPImporter.cs @@ -0,0 +1,647 @@ +// MegaScansURPImporter.cs +// Place in Assets/Editor. Requires Unity 2022.3+ with URP (tested against Unity 6 APIs). +// Processes FBX + source textures under Assets/Models/MegaScans recursively. +// Generated outputs are written to each model's _URPGenerated directory. + +#if UNITY_EDITOR +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Text.RegularExpressions; +using UnityEditor; +using UnityEngine; +using UnityEngine.Rendering; + +namespace UnityLibrary.EditorTools +{ + public sealed class MegaScansURPImporterWindow : EditorWindow + { + internal const string Root = "Assets/Models/MegaScans"; + internal const string OutputFolder = "_URPGenerated"; + + private const string Prefix = "UnityLibrary.MegaScansURP."; + private const string AutoKey = Prefix + "Auto"; + private const string FlipKey = Prefix + "FlipGreen"; + private const string CutoffKey = Prefix + "Cutoff"; + private const string SmoothnessKey = Prefix + "Smoothness"; + private const string MaxSizeKey = Prefix + "MaxSize"; + + internal static bool AutoProcess { get { return EditorPrefs.GetBool(AutoKey, true); } } + internal static bool FlipUnknownNormals { get { return EditorPrefs.GetBool(FlipKey, false); } } + internal static float Cutoff { get { return EditorPrefs.GetFloat(CutoffKey, 0.5f); } } + internal static float DefaultSmoothness { get { return EditorPrefs.GetFloat(SmoothnessKey, 0.45f); } } + internal static int MaxPackedSize { get { return EditorPrefs.GetInt(MaxSizeKey, 4096); } } + + [MenuItem("Tools/MegaScans URP/Importer Settings")] + private static void OpenWindow() + { + GetWindow("MegaScans URP"); + } + + [MenuItem("Tools/MegaScans URP/Process All Models")] + private static void ProcessAllMenu() + { + MegaScansURPProcessor.ProcessAll(true); + } + + private void OnGUI() + { + EditorGUILayout.LabelField("Fab / Quixel MegaScans to URP Lit", EditorStyles.boldLabel); + EditorGUILayout.HelpBox("Only processes FBX models beneath " + Root + ". Output materials and generated PNGs are stored in each model folder's " + OutputFolder + " subfolder.", MessageType.Info); + EditorGUILayout.Space(); + + bool autoProcess = EditorGUILayout.Toggle(new GUIContent("Auto-process imports", "Run when a source FBX or texture is imported/changed."), AutoProcess); + bool flip = EditorGUILayout.Toggle(new GUIContent("Flip ambiguous normal green", "Enable for DirectX-format files named simply Normal. NormalDX and NormalGL are detected automatically."), FlipUnknownNormals); + float cutoff = EditorGUILayout.Slider(new GUIContent("Opacity alpha cutoff"), Cutoff, 0.01f, 0.99f); + float smoothness = EditorGUILayout.Slider(new GUIContent("Fallback smoothness"), DefaultSmoothness, 0f, 1f); + int size = EditorGUILayout.IntPopup( + new GUIContent("Maximum packed size"), + MaxPackedSize, + new[] { new GUIContent("1024"), new GUIContent("2048"), new GUIContent("4096"), new GUIContent("8192") }, + new[] { 1024, 2048, 4096, 8192 }); + + bool changed = autoProcess != AutoProcess || flip != FlipUnknownNormals || !Mathf.Approximately(cutoff, Cutoff) || !Mathf.Approximately(smoothness, DefaultSmoothness) || size != MaxPackedSize; + if (changed) + { + EditorPrefs.SetBool(AutoKey, autoProcess); + EditorPrefs.SetBool(FlipKey, flip); + EditorPrefs.SetFloat(CutoffKey, cutoff); + EditorPrefs.SetFloat(SmoothnessKey, smoothness); + EditorPrefs.SetInt(MaxSizeKey, size); + } + + EditorGUILayout.Space(); + if (GUILayout.Button("Process All MegaScans FBX Models", GUILayout.Height(34))) MegaScansURPProcessor.ProcessAll(true); + EditorGUILayout.HelpBox("Supported: BaseColor/Albedo, Normal/NormalDX/NormalGL, Roughness, AO, Metallic/Metalness, Opacity, and ORM/ARM/RMA/ORD packed maps. JPG and PNG are supported as channel-packing input. Other Unity-importable texture formats work for BaseColor and Normal.", MessageType.None); + EditorGUILayout.HelpBox("The processor assumes one texture set per FBX. If a model contains several different material surfaces, its FBX material slots will all point to the same generated material.", MessageType.Warning); + } + } + + internal static class MegaScansURPProcessor + { + private sealed class TextureSource + { + internal string Path; + internal string Kind; + internal int Score; + } + + private sealed class TextureSet + { + internal string BaseColor; + internal string Normal; + internal string Roughness; + internal string AO; + internal string Metalness; + internal string Opacity; + internal string Packed; + internal string PackedKind; + } + + private sealed class ImageData + { + internal int Width; + internal int Height; + internal Color32[] Pixels; + internal byte Sample(float u, float v, int channel) + { + if (Pixels == null || Pixels.Length == 0) return 255; + int x = Mathf.Clamp(Mathf.RoundToInt(u * (Width - 1)), 0, Width - 1); + int y = Mathf.Clamp(Mathf.RoundToInt(v * (Height - 1)), 0, Height - 1); + Color32 c = Pixels[y * Width + x]; + if (channel == 0) return c.r; + if (channel == 1) return c.g; + if (channel == 2) return c.b; + return c.a; + } + } + + private static readonly HashSet TextureExtensions = new HashSet(StringComparer.OrdinalIgnoreCase) { ".jpg", ".jpeg", ".png", ".tga", ".tif", ".tiff", ".psd", ".exr" }; + private static readonly HashSet PendingModels = new HashSet(StringComparer.OrdinalIgnoreCase); + private static bool processing; + private static bool pendingScheduled; + + internal static bool IsInsideRoot(string assetPath) + { + return !string.IsNullOrEmpty(assetPath) && assetPath.StartsWith(MegaScansURPImporterWindow.Root + "/", StringComparison.OrdinalIgnoreCase) && assetPath.IndexOf("/" + MegaScansURPImporterWindow.OutputFolder + "/", StringComparison.OrdinalIgnoreCase) < 0; + } + + internal static bool IsSourceTexture(string path) + { + return IsInsideRoot(path) && TextureExtensions.Contains(System.IO.Path.GetExtension(path)); + } + + internal static bool IsSourceModel(string path) + { + return IsInsideRoot(path) && path.EndsWith(".fbx", StringComparison.OrdinalIgnoreCase); + } + + internal static void EnqueueChangedAssets(IEnumerable paths) + { + if (!MegaScansURPImporterWindow.AutoProcess || processing) return; + bool any = false; + foreach (string path in paths) + { + if (IsSourceModel(path)) + { + any |= PendingModels.Add(path); + continue; + } + if (!IsSourceTexture(path)) continue; + string directory = System.IO.Path.GetDirectoryName(path).Replace('\\', '/'); + string parent = System.IO.Path.GetDirectoryName(directory).Replace('\\', '/'); + string folderName = System.IO.Path.GetFileName(directory); + bool usesTextureSubfolder = folderName.Equals("Textures", StringComparison.OrdinalIgnoreCase) || folderName.Equals("Texture", StringComparison.OrdinalIgnoreCase) || folderName.Equals("Maps", StringComparison.OrdinalIgnoreCase); + foreach (string folder in usesTextureSubfolder ? new[] { directory, parent } : new[] { directory }) + { + if (folder == null || !folder.StartsWith(MegaScansURPImporterWindow.Root, StringComparison.OrdinalIgnoreCase) || !AssetDatabase.IsValidFolder(folder)) continue; + foreach (string guid in AssetDatabase.FindAssets("t:Model", new[] { folder })) + { + string model = AssetDatabase.GUIDToAssetPath(guid); + if (IsSourceModel(model)) any |= PendingModels.Add(model); + } + } + } + if (!any || pendingScheduled) return; + pendingScheduled = true; + EditorApplication.delayCall += ProcessPending; + } + + private static void ProcessPending() + { + pendingScheduled = false; + if (processing || PendingModels.Count == 0) return; + List models = PendingModels.ToList(); + PendingModels.Clear(); + ProcessModels(models, false); + } + + internal static void ProcessAll(bool showProgress) + { + if (!AssetDatabase.IsValidFolder(MegaScansURPImporterWindow.Root)) + { + Debug.LogWarning("MegaScans URP: Folder not found: " + MegaScansURPImporterWindow.Root); + return; + } + List models = AssetDatabase.FindAssets("t:Model", new[] { MegaScansURPImporterWindow.Root }).Select(AssetDatabase.GUIDToAssetPath).Where(IsSourceModel).Distinct(StringComparer.OrdinalIgnoreCase).OrderBy(x => x).ToList(); + ProcessModels(models, showProgress); + } + + private static void ProcessModels(IList models, bool showProgress) + { + if (processing) return; + Shader shader = Shader.Find("Universal Render Pipeline/Lit"); + if (shader == null) + { + Debug.LogError("MegaScans URP: Universal Render Pipeline/Lit shader not found. Install and configure URP first."); + return; + } + processing = true; + int succeeded = 0; + int skipped = 0; + int failed = 0; + try + { + for (int i = 0; i < models.Count; i++) + { + string model = models[i]; + if (showProgress && EditorUtility.DisplayCancelableProgressBar("Processing MegaScans", model, models.Count > 0 ? (float)i / models.Count : 1f)) break; + if (!IsSourceModel(model) || AssetDatabase.LoadAssetAtPath(model) == null) { skipped++; continue; } + try + { + if (ProcessModel(model, shader)) succeeded++; + else skipped++; + } + catch (Exception ex) + { + failed++; + Debug.LogError("MegaScans URP: Failed to process " + model + "\n" + ex); + } + } + AssetDatabase.SaveAssets(); + } + finally + { + if (showProgress) EditorUtility.ClearProgressBar(); + processing = false; + } + Debug.Log("MegaScans URP: Processed " + succeeded + " FBX models; skipped " + skipped + "; errors " + failed + "."); + } + + private static bool ProcessModel(string modelPath, Shader shader) + { + TextureSet set = DiscoverTextureSet(modelPath); + if (string.IsNullOrEmpty(set.BaseColor) && string.IsNullOrEmpty(set.Normal) && string.IsNullOrEmpty(set.Roughness) && string.IsNullOrEmpty(set.AO) && string.IsNullOrEmpty(set.Packed)) + { + Debug.LogWarning("MegaScans URP: No matching texture set for " + modelPath); + return false; + } + + string dir = System.IO.Path.GetDirectoryName(modelPath).Replace('\\', '/'); + string name = System.IO.Path.GetFileNameWithoutExtension(modelPath); + string outputDir = dir + "/" + MegaScansURPImporterWindow.OutputFolder; + if (!AssetDatabase.IsValidFolder(outputDir)) AssetDatabase.CreateFolder(dir, MegaScansURPImporterWindow.OutputFolder); + + string baseMapPath = set.BaseColor; + bool alphaClip = !string.IsNullOrEmpty(set.Opacity) && !string.IsNullOrEmpty(set.BaseColor); + if (alphaClip) + { + string generatedBase = outputDir + "/" + name + "_URP_BaseColor.png"; + if (GenerateBaseColorAlpha(set.BaseColor, set.Opacity, generatedBase)) baseMapPath = generatedBase; + else { alphaClip = false; Debug.LogWarning("MegaScans URP: Could not combine opacity map for " + modelPath); } + } + + Texture2D baseMap = LoadTexture(baseMapPath); + if (!string.IsNullOrEmpty(set.Normal)) ConfigureNormal(set.Normal); + Texture2D normal = LoadTexture(set.Normal); + + Texture2D packed = null; + bool hasPackedInputs = !string.IsNullOrEmpty(set.Roughness) || !string.IsNullOrEmpty(set.AO) || !string.IsNullOrEmpty(set.Metalness) || !string.IsNullOrEmpty(set.Packed); + if (hasPackedInputs) + { + string packedPath = outputDir + "/" + name + "_URP_Mask.png"; + if (GeneratePackedMask(set, packedPath)) + { + ConfigureDataTexture(packedPath); + packed = LoadTexture(packedPath); + } + } + + string materialPath = outputDir + "/" + name + "_URP.mat"; + Material material = AssetDatabase.LoadAssetAtPath(materialPath); + if (material == null) + { + material = new Material(shader); + AssetDatabase.CreateAsset(material, materialPath); + } + else if (material.shader != shader) material.shader = shader; + + material.SetFloat("_WorkflowMode", 1f); + material.SetFloat("_Surface", 0f); + material.SetFloat("_Blend", 0f); + material.SetFloat("_AlphaClip", alphaClip ? 1f : 0f); + material.SetFloat("_Cutoff", MegaScansURPImporterWindow.Cutoff); + material.SetFloat("_Cull", alphaClip ? 0f : 2f); + material.SetColor("_BaseColor", Color.white); + material.SetTexture("_BaseMap", baseMap); + material.SetTexture("_BumpMap", normal); + material.SetFloat("_BumpScale", 1f); + material.SetTexture("_MetallicGlossMap", packed); + material.SetTexture("_OcclusionMap", packed); + material.SetFloat("_Metallic", string.IsNullOrEmpty(set.Metalness) && string.IsNullOrEmpty(set.Packed) ? 0f : 1f); + material.SetFloat("_Smoothness", packed != null ? 1f : MegaScansURPImporterWindow.DefaultSmoothness); + material.SetFloat("_SmoothnessTextureChannel", 0f); + material.SetFloat("_OcclusionStrength", 1f); + SetKeyword(material, "_NORMALMAP", normal != null); + SetKeyword(material, "_METALLICSPECGLOSSMAP", packed != null); + SetKeyword(material, "_OCCLUSIONMAP", packed != null); + SetKeyword(material, "_ALPHATEST_ON", alphaClip); + SetKeyword(material, "_SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A", false); + material.renderQueue = alphaClip ? (int)RenderQueue.AlphaTest : -1; + material.enableInstancing = true; + EditorUtility.SetDirty(material); + + RemapModelMaterials(modelPath, material); + return true; + } + + private static void RemapModelMaterials(string modelPath, Material material) + { + ModelImporter importer = AssetImporter.GetAtPath(modelPath) as ModelImporter; + if (importer == null) return; + bool changed = false; + if (importer.materialImportMode == ModelImporterMaterialImportMode.None) + { + importer.materialImportMode = ModelImporterMaterialImportMode.ImportStandard; + changed = true; + } + + HashSet names = new HashSet(StringComparer.Ordinal); + foreach (var pair in importer.GetExternalObjectMap()) + { + if (pair.Key.type == typeof(Material) && !string.IsNullOrEmpty(pair.Key.name)) names.Add(pair.Key.name); + } + GameObject prefab = AssetDatabase.LoadAssetAtPath(modelPath); + if (prefab != null) + { + foreach (Renderer renderer in prefab.GetComponentsInChildren(true)) + { + foreach (Material m in renderer.sharedMaterials) + { + if (m != null && !string.IsNullOrEmpty(m.name)) names.Add(m.name); + } + } + } + foreach (Material m in AssetDatabase.LoadAllAssetsAtPath(modelPath).OfType()) + { + if (!string.IsNullOrEmpty(m.name)) names.Add(m.name); + } + if (names.Count == 0) + { + Debug.LogWarning("MegaScans URP: No material slots found in " + modelPath + ". You may need to enable Import Materials on this FBX and run the processor again."); + } + + var existingMap = importer.GetExternalObjectMap(); + foreach (string name in names) + { + var key = new AssetImporter.SourceAssetIdentifier(typeof(Material), name); + UnityEngine.Object existing; + if (existingMap.TryGetValue(key, out existing) && existing == material) continue; + importer.AddRemap(key, material); + changed = true; + } + if (!changed) return; + AssetDatabase.WriteImportSettingsIfDirty(modelPath); + AssetDatabase.ImportAsset(modelPath, ImportAssetOptions.ForceUpdate); + } + + private static TextureSet DiscoverTextureSet(string modelPath) + { + string directory = System.IO.Path.GetDirectoryName(modelPath).Replace('\\', '/'); + string filename = System.IO.Path.GetFileNameWithoutExtension(modelPath); + string normalized = StripLodSuffix(filename); + string id = ExtractMegascansId(filename); + List sources = new List(); + + foreach (string guid in AssetDatabase.FindAssets("t:Texture2D", new[] { directory })) + { + string path = AssetDatabase.GUIDToAssetPath(guid); + if (!IsSourceTexture(path)) continue; + string stem = System.IO.Path.GetFileNameWithoutExtension(path); + string kind = ClassifyTexture(stem); + if (kind == null) continue; + string textureDir = System.IO.Path.GetDirectoryName(path).Replace('\\', '/'); + bool sameFolder = string.Equals(textureDir, directory, StringComparison.OrdinalIgnoreCase); + bool fullMatch = stem.StartsWith(filename + "_", StringComparison.OrdinalIgnoreCase) || string.Equals(stem, filename, StringComparison.OrdinalIgnoreCase); + bool lodMatch = stem.StartsWith(normalized + "_", StringComparison.OrdinalIgnoreCase); + bool idMatch = id != null && stem.IndexOf(id, StringComparison.OrdinalIgnoreCase) >= 0; + if (!fullMatch && !lodMatch && !idMatch) continue; + int score = (fullMatch ? 1000 : lodMatch ? 800 : 500) + (sameFolder ? 100 : 0) + ResolutionScore(stem); + if (kind == "NormalGL") score += 30; + sources.Add(new TextureSource { Path = path, Kind = kind, Score = score }); + } + + // Some Fab downloads use generic texture names, but only fall back when + // there is exactly one FBX in that folder to avoid cross-asset mixing. + if (sources.Count == 0) + { + int fbxCount = AssetDatabase.FindAssets("t:Model", new[] { directory }).Select(AssetDatabase.GUIDToAssetPath).Count(p => IsSourceModel(p) && string.Equals(System.IO.Path.GetDirectoryName(p).Replace('\\', '/'), directory, StringComparison.OrdinalIgnoreCase)); + if (fbxCount == 1) + { + foreach (string guid in AssetDatabase.FindAssets("t:Texture2D", new[] { directory })) + { + string path = AssetDatabase.GUIDToAssetPath(guid); + if (!IsSourceTexture(path) || !string.Equals(System.IO.Path.GetDirectoryName(path).Replace('\\', '/'), directory, StringComparison.OrdinalIgnoreCase)) continue; + string stem = System.IO.Path.GetFileNameWithoutExtension(path); + string kind = ClassifyTexture(stem); + if (kind != null) sources.Add(new TextureSource { Path = path, Kind = kind, Score = ResolutionScore(stem) }); + } + } + } + + TextureSet result = new TextureSet(); + result.BaseColor = Best(sources, "BaseColor"); + result.Normal = Best(sources, "NormalGL") ?? Best(sources, "Normal") ?? Best(sources, "NormalDX"); + result.Roughness = Best(sources, "Roughness"); + result.AO = Best(sources, "AO"); + result.Metalness = Best(sources, "Metalness"); + result.Opacity = Best(sources, "Opacity"); + TextureSource packed = sources.Where(s => s.Kind == "ORM" || s.Kind == "ARM" || s.Kind == "RMA" || s.Kind == "ORD" || s.Kind == "MRA").OrderByDescending(s => s.Score).FirstOrDefault(); + if (packed != null) { result.Packed = packed.Path; result.PackedKind = packed.Kind; } + return result; + } + + private static string Best(List sources, string kind) + { + TextureSource source = sources.Where(s => s.Kind == kind).OrderByDescending(s => s.Score).FirstOrDefault(); + return source != null ? source.Path : null; + } + + private static string StripLodSuffix(string name) + { + return Regex.Replace(name, @"(?i)(?:[_-](?:low|high|mid|nanite|lod[0-9]+))+$", ""); + } + + private static string ExtractMegascansId(string name) + { + MatchCollection matches = Regex.Matches(name, @"(?i)(?:^|[_-])([a-z0-9]{7,9})(?=[_-]|$)"); + return matches.Count > 0 ? matches[matches.Count - 1].Groups[1].Value : null; + } + + private static int ResolutionScore(string name) + { + Match match = Regex.Match(name, @"(?i)(?:^|[_-])([0-9]{1,2})k(?:[_-]|$)"); + int value; + return match.Success && int.TryParse(match.Groups[1].Value, out value) ? value * 4 : 0; + } + + private static string ClassifyTexture(string stem) + { + string[] tokens = Regex.Split(stem.ToLowerInvariant(), @"[_\-. ]+"); + for (int i = tokens.Length - 1; i >= 0; i--) + { + string t = tokens[i]; + if (t == "basecolor" || t == "albedo" || t == "diffuse" || t == "diff" || t == "basecolour") return "BaseColor"; + if (t == "normalgl" || t == "normalogl" || t == "normalopengl") return "NormalGL"; + if (t == "normaldx" || t == "normaldirectx") return "NormalDX"; + if (t == "normal" || t == "normals" || t == "nrm") return i + 1 < tokens.Length && tokens[i + 1] == "dx" ? "NormalDX" : i + 1 < tokens.Length && (tokens[i + 1] == "gl" || tokens[i + 1] == "opengl") ? "NormalGL" : "Normal"; + if (t == "roughness" || t == "rough") return "Roughness"; + if (t == "ao" || t == "ambientocclusion" || t == "occlusion") return "AO"; + if (t == "metalness" || t == "metallic" || t == "metal") return "Metalness"; + if (t == "opacity" || t == "alpha" || t == "opacitymask" || t == "mask") return "Opacity"; + if (t == "orm") return "ORM"; + if (t == "arm") return "ARM"; + if (t == "rma" || t == "rmetal") return "RMA"; + if (t == "mra") return "MRA"; + if (t == "ord" || t == "ordp") return "ORD"; + } + return null; + } + + private static Texture2D LoadTexture(string path) + { + return !string.IsNullOrEmpty(path) ? AssetDatabase.LoadAssetAtPath(path) : null; + } + + private static void ConfigureNormal(string path) + { + TextureImporter importer = AssetImporter.GetAtPath(path) as TextureImporter; + if (importer == null) return; + bool flip = path.IndexOf("normaldx", StringComparison.OrdinalIgnoreCase) >= 0 || (path.IndexOf("normalgl", StringComparison.OrdinalIgnoreCase) < 0 && MegaScansURPImporterWindow.FlipUnknownNormals); + if (importer.textureType == TextureImporterType.NormalMap && importer.flipGreenChannel == flip) return; + importer.textureType = TextureImporterType.NormalMap; + importer.flipGreenChannel = flip; + importer.SaveAndReimport(); + } + + private static void ConfigureDataTexture(string path) + { + TextureImporter importer = AssetImporter.GetAtPath(path) as TextureImporter; + if (importer == null) return; + if (importer.textureType == TextureImporterType.Default && !importer.sRGBTexture && importer.mipmapEnabled && !importer.isReadable) return; + importer.textureType = TextureImporterType.Default; + importer.sRGBTexture = false; + importer.mipmapEnabled = true; + importer.isReadable = false; + importer.SaveAndReimport(); + } + + private static void SetKeyword(Material material, string keyword, bool enabled) + { + if (enabled) material.EnableKeyword(keyword); + else material.DisableKeyword(keyword); + } + + private static bool GeneratePackedMask(TextureSet source, string outputPath) + { + ImageData rough = ReadImage(source.Roughness); + ImageData ao = ReadImage(source.AO); + ImageData metallic = ReadImage(source.Metalness); + ImageData packed = ReadImage(source.Packed); + if (rough == null && ao == null && metallic == null && packed == null) return false; + + int width = 1; + int height = 1; + foreach (ImageData img in new[] { rough, ao, metallic, packed }) + { + if (img == null) continue; + width = Math.Max(width, img.Width); + height = Math.Max(height, img.Height); + } + float scale = Mathf.Min(1f, (float)MegaScansURPImporterWindow.MaxPackedSize / Math.Max(width, height)); + width = Mathf.Max(1, Mathf.RoundToInt(width * scale)); + height = Mathf.Max(1, Mathf.RoundToInt(height * scale)); + + Color32[] pixels = new Color32[width * height]; + byte fallbackSmooth = (byte)Mathf.RoundToInt(MegaScansURPImporterWindow.DefaultSmoothness * 255f); + for (int y = 0; y < height; y++) + { + float v = (y + 0.5f) / height; + for (int x = 0; x < width; x++) + { + float u = (x + 0.5f) / width; + byte metal = metallic != null ? metallic.Sample(u, v, 0) : PackedMetal(packed, source.PackedKind, u, v); + byte occlusion = ao != null ? ao.Sample(u, v, 0) : PackedAO(packed, source.PackedKind, u, v); + byte roughness = rough != null ? rough.Sample(u, v, 0) : PackedRoughness(packed, source.PackedKind, u, v); + byte smoothness = rough != null || packed != null ? (byte)(255 - roughness) : fallbackSmooth; + pixels[y * width + x] = new Color32(metal, occlusion, 0, smoothness); + } + } + return WritePng(outputPath, width, height, pixels); + } + + private static byte PackedAO(ImageData packed, string kind, float u, float v) + { + if (packed == null) return 255; + if (kind == "RMA" || kind == "MRA") return packed.Sample(u, v, 2); + return packed.Sample(u, v, 0); + } + + private static byte PackedMetal(ImageData packed, string kind, float u, float v) + { + if (packed == null || kind == "ORD") return 0; + if (kind == "RMA") return packed.Sample(u, v, 1); + if (kind == "MRA") return packed.Sample(u, v, 0); + return packed.Sample(u, v, 2); + } + + private static byte PackedRoughness(ImageData packed, string kind, float u, float v) + { + if (packed == null) return (byte)Mathf.RoundToInt((1f - MegaScansURPImporterWindow.DefaultSmoothness) * 255f); + return packed.Sample(u, v, kind == "RMA" ? 0 : kind == "MRA" ? 1 : 1); + } + + private static bool GenerateBaseColorAlpha(string baseColor, string opacity, string outputPath) + { + ImageData color = ReadImage(baseColor); + ImageData alpha = ReadImage(opacity); + if (color == null || alpha == null) return false; + Color32[] pixels = new Color32[color.Pixels.Length]; + for (int y = 0; y < color.Height; y++) + { + float v = (y + 0.5f) / color.Height; + for (int x = 0; x < color.Width; x++) + { + float u = (x + 0.5f) / color.Width; + Color32 c = color.Pixels[y * color.Width + x]; + c.a = (byte)((c.a * alpha.Sample(u, v, 0) + 127) / 255); + pixels[y * color.Width + x] = c; + } + } + bool saved = WritePng(outputPath, color.Width, color.Height, pixels); + TextureImporter importer = AssetImporter.GetAtPath(outputPath) as TextureImporter; + if (importer != null && (!importer.sRGBTexture || !importer.alphaIsTransparency || importer.textureType != TextureImporterType.Default)) + { + importer.textureType = TextureImporterType.Default; + importer.sRGBTexture = true; + importer.alphaIsTransparency = true; + importer.SaveAndReimport(); + } + return saved; + } + + private static ImageData ReadImage(string assetPath) + { + if (string.IsNullOrEmpty(assetPath)) return null; + string extension = System.IO.Path.GetExtension(assetPath); + if (!string.Equals(extension, ".png", StringComparison.OrdinalIgnoreCase) && !string.Equals(extension, ".jpg", StringComparison.OrdinalIgnoreCase) && !string.Equals(extension, ".jpeg", StringComparison.OrdinalIgnoreCase)) + { + Debug.LogWarning("MegaScans URP: Channel packing currently supports JPG/PNG inputs. Unsupported: " + assetPath); + return null; + } + string filePath = System.IO.Path.GetFullPath(assetPath); + if (!File.Exists(filePath)) return null; + Texture2D temporary = new Texture2D(2, 2, TextureFormat.RGBA32, false, true); + try + { + if (!ImageConversion.LoadImage(temporary, File.ReadAllBytes(filePath), false)) return null; + return new ImageData { Width = temporary.width, Height = temporary.height, Pixels = temporary.GetPixels32() }; + } + finally + { + UnityEngine.Object.DestroyImmediate(temporary); + } + } + + private static bool WritePng(string assetPath, int width, int height, Color32[] pixels) + { + Texture2D texture = new Texture2D(width, height, TextureFormat.RGBA32, false, true); + byte[] png; + try + { + texture.SetPixels32(pixels); + texture.Apply(false, false); + png = ImageConversion.EncodeToPNG(texture); + } + finally + { + UnityEngine.Object.DestroyImmediate(texture); + } + string filePath = System.IO.Path.GetFullPath(assetPath); + if (File.Exists(filePath) && File.ReadAllBytes(filePath).SequenceEqual(png)) return true; + File.WriteAllBytes(filePath, png); + AssetDatabase.ImportAsset(assetPath, ImportAssetOptions.ForceUpdate); + return true; + } + } + + public sealed class MegaScansURPPostprocessor : AssetPostprocessor + { + public Material OnAssignMaterialModel(Material sourceMaterial, Renderer renderer) + { + if (!MegaScansURPProcessor.IsSourceModel(assetPath)) return null; + string directory = System.IO.Path.GetDirectoryName(assetPath).Replace('\\', '/'); + string name = System.IO.Path.GetFileNameWithoutExtension(assetPath); + string materialPath = directory + "/" + MegaScansURPImporterWindow.OutputFolder + "/" + name + "_URP.mat"; + return AssetDatabase.LoadAssetAtPath(materialPath); + } + + private static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths) + { + if (!MegaScansURPImporterWindow.AutoProcess) return; + MegaScansURPProcessor.EnqueueChangedAssets(importedAssets.Concat(movedAssets)); + } + } +} +#endif From 692ed7a04d26ad24ee1a714dca4a0adfbe066ad8 Mon Sep 17 00:00:00 2001 From: mika Date: Thu, 19 Nov 2026 11:24:06 +0200 Subject: [PATCH 26/26] add cross projects/editors hierarchy copy paste tool --- .../Tools/CrossProjectHierarchyClipboard.cs | 1047 +++++++++++++++++ 1 file changed, 1047 insertions(+) create mode 100644 Assets/Scripts/Editor/Tools/CrossProjectHierarchyClipboard.cs diff --git a/Assets/Scripts/Editor/Tools/CrossProjectHierarchyClipboard.cs b/Assets/Scripts/Editor/Tools/CrossProjectHierarchyClipboard.cs new file mode 100644 index 0000000..6118b43 --- /dev/null +++ b/Assets/Scripts/Editor/Tools/CrossProjectHierarchyClipboard.cs @@ -0,0 +1,1047 @@ +// CrossProjectHierarchyClipboard.cs +// Place this file in Assets/Editor in BOTH Unity projects. +// Intended for Unity 2019.4 through Unity 7 (7000.x). +// Cross-project transfer uses the operating system's text clipboard. +// This copies scene GameObjects, not prefab links or asset file contents. + +using System; +using System.Collections.Generic; +using System.Linq; +using UnityEditor; +using UnityEngine; +using UnityEngine.SceneManagement; +using Object = UnityEngine.Object; + +namespace UnityLibrary.EditorTools +{ + public static class CrossProjectHierarchyClipboard + { + private const string ClipboardHeader = "UNITY_CROSS_PROJECT_HIERARCHY_V1\n"; + private const int FormatVersion = 1; + private const int MaximumObjects = 100000; + + // If an asset's GUID/path cannot be found, allow a unique match by + // asset name and type. Ambiguous matches are deliberately rejected. + private const bool AllowUniqueAssetNameFallback = true; + + [Serializable] + private class Package + { + public int version = FormatVersion; + public string sourceUnityVersion; + public List nodes = new List(); + } + + [Serializable] + private class Node + { + public int id; + public int parentId = -1; + public string name; + public bool active; + public string tag; + public string layerName; + public int layer; + public int staticFlags; + public Vector3 localPosition; + public Quaternion localRotation; + public Vector3 localScale; + public Vector3 worldPosition; + public Quaternion worldRotation; + public Vector3 worldScale; + public bool hasRectTransform; + public Vector2 anchorMin; + public Vector2 anchorMax; + public Vector2 pivot; + public Vector2 sizeDelta; + public Vector2 anchoredPosition; + public List parts = new List(); + } + + [Serializable] + private class Part + { + public int componentIndex; + public string typeFullName; + public string assemblyName; + public bool isTransform; + public List fields = new List(); + } + + [Serializable] + private class Field + { + public string path; + public string kind; + public string stringValue; + public string enumName; + public long integerValue; + public double doubleValue; + public bool boolValue; + public Color color; + public Vector2 vector2; + public Vector3 vector3; + public Vector4 vector4; + public Quaternion quaternion; + public Rect rect; + public Bounds bounds; + public Vector2Int vector2Int; + public Vector3Int vector3Int; + public RectInt rectInt; + public BoundsInt boundsInt; + public AnimationCurve curve; + public GradientColorKey[] gradientColors; + public GradientAlphaKey[] gradientAlphas; + public int gradientMode; + public Reference reference; + } + + [Serializable] + private class Reference + { + public string kind; // null, hierarchy, asset, external + public int nodeId; + public int componentIndex = -1; // -1 = GameObject + public string name; + public string typeFullName; + public string assemblyName; + public string guid; + public long localFileId; + public string path; + } + + private class CaptureContext + { + public readonly Dictionary nodeIds = new Dictionary(); + public readonly List orderedObjects = new List(); + public readonly Dictionary componentRefs = new Dictionary(); + } + + private class PasteContext + { + public readonly Dictionary nodes = new Dictionary(); + public readonly Dictionary components = new Dictionary(); + public readonly Dictionary assetCache = new Dictionary(); + public readonly HashSet warnings = new HashSet(); + public int componentsAdded; + public int missingComponents; + public int missingReferences; + public int skippedFields; + + public void Warn(string message) + { + // Limit log spam for large selections. + if (warnings.Count < 20) + warnings.Add(message); + } + } + + [MenuItem("Tools/Cross-Project Hierarchy/Copy Selected %&c", false, 1)] + public static void CopySelected() + { + var selected = Selection.gameObjects.Where(go => go && go.scene.IsValid()).ToArray(); + if (selected.Length == 0) + { + Debug.LogWarning("Cross-Project Hierarchy: Select one or more scene GameObjects to copy."); + return; + } + + var selectedSet = new HashSet(selected); + var roots = selected.Where(go => !HasSelectedAncestor(go.transform, selectedSet)) + .OrderBy(go => GetHierarchySortKey(go.transform), StringComparer.Ordinal) + .ToArray(); + + var package = new Package { sourceUnityVersion = Application.unityVersion }; + var context = new CaptureContext(); + + // Pass 1: collect the complete hierarchy and stable IDs. + foreach (var root in roots) + CaptureStructure(root.transform, -1, package, context); + + if (package.nodes.Count > MaximumObjects) + { + Debug.LogError("Cross-Project Hierarchy: Selection is too large to copy safely."); + return; + } + + // Pass 2: gather component properties and their portable references. + foreach (var node in package.nodes) + { + var sourceGo = context.orderedObjects[node.id]; + var components = sourceGo.GetComponents(); + for (int index = 0; index < components.Length; ++index) + { + var component = components[index]; + if (!component) // Missing script in the source project. + continue; + + var type = component.GetType(); + var part = new Part + { + componentIndex = index, + typeFullName = type.FullName, + assemblyName = type.Assembly.GetName().Name, + isTransform = component is Transform + }; + + if (!part.isTransform) + CaptureFields(component, part, context); + node.parts.Add(part); + } + } + + string json = JsonUtility.ToJson(package); + EditorGUIUtility.systemCopyBuffer = ClipboardHeader + json; + Debug.Log(string.Format( + "Cross-Project Hierarchy: Copied {0} GameObjects ({1} root objects) to the system clipboard, {2:N0} characters.", + package.nodes.Count, roots.Length, json.Length)); + } + + [MenuItem("Tools/Cross-Project Hierarchy/Copy Selected %&c", true)] + private static bool ValidateCopy() { return Selection.gameObjects.Any(go => go && go.scene.IsValid()); } + + [MenuItem("Tools/Cross-Project Hierarchy/Paste Under Selected %&v", false, 2)] + public static void PasteUnderSelected() + { + var parent = Selection.activeTransform; + if (parent && !parent.gameObject.scene.IsValid()) + parent = null; + Paste(parent); + } + + [MenuItem("Tools/Cross-Project Hierarchy/Paste At Scene Root", false, 3)] + public static void PasteAtRoot() { Paste(null); } + + [MenuItem("Tools/Cross-Project Hierarchy/Paste Under Selected %&v", true)] + [MenuItem("Tools/Cross-Project Hierarchy/Paste At Scene Root", true)] + private static bool ValidatePaste() + { + string buffer = EditorGUIUtility.systemCopyBuffer; + return !string.IsNullOrEmpty(buffer) && buffer.StartsWith(ClipboardHeader, StringComparison.Ordinal); + } + + private static bool HasSelectedAncestor(Transform child, HashSet selected) + { + for (var parent = child.parent; parent; parent = parent.parent) + if (selected.Contains(parent.gameObject)) + return true; + return false; + } + + private static string GetHierarchySortKey(Transform t) + { + var indices = new List(); + while (t) + { + indices.Add(t.GetSiblingIndex().ToString("D8")); + t = t.parent; + } + indices.Reverse(); + return string.Join("/", indices.ToArray()); + } + + private static void CaptureStructure(Transform transform, int parentId, + Package package, CaptureContext context) + { + var go = transform.gameObject; + int id = package.nodes.Count; + var node = new Node + { + id = id, + parentId = parentId, + name = go.name, + active = go.activeSelf, + tag = go.tag, + layer = go.layer, + layerName = LayerMask.LayerToName(go.layer), + staticFlags = (int)GameObjectUtility.GetStaticEditorFlags(go), + localPosition = transform.localPosition, + localRotation = transform.localRotation, + localScale = transform.localScale, + worldPosition = transform.position, + worldRotation = transform.rotation, + worldScale = transform.lossyScale, + hasRectTransform = transform is RectTransform + }; + + var rect = transform as RectTransform; + if (rect) + { + node.anchorMin = rect.anchorMin; + node.anchorMax = rect.anchorMax; + node.pivot = rect.pivot; + node.sizeDelta = rect.sizeDelta; + node.anchoredPosition = rect.anchoredPosition; + } + + package.nodes.Add(node); + context.nodeIds.Add(go, id); + context.orderedObjects.Add(go); + + var components = go.GetComponents(); + for (int i = 0; i < components.Length; ++i) + { + if (!components[i]) + continue; + context.componentRefs[components[i]] = new Reference + { + kind = "hierarchy", + nodeId = id, + componentIndex = i + }; + } + + for (int child = 0; child < transform.childCount; ++child) + CaptureStructure(transform.GetChild(child), id, package, context); + } + + private static void CaptureFields(Component component, Part part, CaptureContext context) + { + try + { + var so = new SerializedObject(component); + var iterator = so.GetIterator(); + bool hasMore = iterator.NextVisible(true); + string ignoredManagedRoot = null; + while (hasMore) + { + string path = iterator.propertyPath; + if (!string.IsNullOrEmpty(ignoredManagedRoot)) + { + if (path.StartsWith(ignoredManagedRoot + ".", StringComparison.Ordinal)) + { + hasMore = iterator.NextVisible(true); + continue; + } + ignoredManagedRoot = null; + } + + if (ShouldSkipProperty(path)) + { + hasMore = iterator.NextVisible(true); + continue; + } + + if (iterator.propertyType == SerializedPropertyType.ManagedReference) + { + // Polymorphic managed references are not portable across arbitrary assemblies. + ignoredManagedRoot = path; + hasMore = iterator.NextVisible(true); + continue; + } + + try + { + var field = ReadField(iterator, context); + if (field != null) + part.fields.Add(field); + } + catch (Exception) + { + // An unsupported native property should never abort hierarchy copying. + } + hasMore = iterator.NextVisible(true); + } + } + catch (Exception ex) + { + Debug.LogWarning("Cross-Project Hierarchy: Could not serialize " + component.GetType().Name + ": " + ex.Message); + } + } + + private static bool ShouldSkipProperty(string path) + { + return path == "m_Script" || path == "m_GameObject" || + path == "m_ObjectHideFlags" || path == "m_CorrespondingSourceObject" || + path == "m_PrefabInstance" || path == "m_PrefabAsset" || + path == "m_EditorClassIdentifier" || path == "m_RootOrder"; + } + + private static Field ReadField(SerializedProperty p, CaptureContext context) + { + var field = new Field { path = p.propertyPath, kind = p.propertyType.ToString() }; + if (p.isArray && p.propertyType == SerializedPropertyType.Generic) + { + field.kind = "PortableArraySize"; + field.integerValue = p.arraySize; + return field; + } + + switch (p.propertyType) + { + case SerializedPropertyType.Integer: + case SerializedPropertyType.LayerMask: + case SerializedPropertyType.Character: + field.integerValue = p.longValue; + break; + case SerializedPropertyType.Boolean: + field.boolValue = p.boolValue; + break; + case SerializedPropertyType.Float: + field.doubleValue = p.doubleValue; + break; + case SerializedPropertyType.String: + field.stringValue = p.stringValue; + break; + case SerializedPropertyType.Color: + field.color = p.colorValue; + break; + case SerializedPropertyType.ObjectReference: + field.reference = CaptureReference(p.objectReferenceValue, context); + break; + case SerializedPropertyType.ExposedReference: + field.reference = CaptureReference(p.exposedReferenceValue, context); + break; + case SerializedPropertyType.Enum: + field.integerValue = p.intValue; + int index = p.enumValueIndex; + var names = p.enumNames; + if (index >= 0 && index < names.Length) + field.enumName = names[index]; + break; + case SerializedPropertyType.Vector2: + field.vector2 = p.vector2Value; + break; + case SerializedPropertyType.Vector3: + field.vector3 = p.vector3Value; + break; + case SerializedPropertyType.Vector4: + field.vector4 = p.vector4Value; + break; + case SerializedPropertyType.Quaternion: + field.quaternion = p.quaternionValue; + break; + case SerializedPropertyType.Rect: + field.rect = p.rectValue; + break; + case SerializedPropertyType.Bounds: + field.bounds = p.boundsValue; + break; + case SerializedPropertyType.Vector2Int: + field.vector2Int = p.vector2IntValue; + break; + case SerializedPropertyType.Vector3Int: + field.vector3Int = p.vector3IntValue; + break; + case SerializedPropertyType.RectInt: + field.rectInt = p.rectIntValue; + break; + case SerializedPropertyType.BoundsInt: + field.boundsInt = p.boundsIntValue; + break; + case SerializedPropertyType.AnimationCurve: + field.curve = p.animationCurveValue; + break; + case SerializedPropertyType.Gradient: + // In Unity 2019.4, gradientValue is not a public API. + // It remains unchanged on the receiving side. + return null; + default: + // Generic structs are handled through their children. + // Fixed-size buffers, new Unity 7-only types, etc. are skipped. + return null; + } + return field; + } + + private static Reference CaptureReference(Object obj, CaptureContext context) + { + if (!obj) + return new Reference { kind = "null" }; + + var go = obj as GameObject; + int nodeId; + if (go && context.nodeIds.TryGetValue(go, out nodeId)) + return new Reference { kind = "hierarchy", nodeId = nodeId, componentIndex = -1 }; + + var component = obj as Component; + Reference sceneRef; + if (component && context.componentRefs.TryGetValue(component, out sceneRef)) + return sceneRef; + + string path = AssetDatabase.GetAssetPath(obj); + if (!string.IsNullOrEmpty(path)) + { + string guid; + long localId; + if (!AssetDatabase.TryGetGUIDAndLocalFileIdentifier(obj, out guid, out localId)) + { + guid = AssetDatabase.AssetPathToGUID(path); + localId = 0; + } + var type = obj.GetType(); + return new Reference + { + kind = "asset", + name = obj.name, + path = path, + guid = guid, + localFileId = localId, + typeFullName = type.FullName, + assemblyName = type.Assembly.GetName().Name + }; + } + + // Unity built-in mesh/materials/shaders sometimes have no asset path. + if (obj is Mesh || obj is Material || obj is Shader) + { + var type = obj.GetType(); + return new Reference + { + kind = "asset", + name = obj.name, + typeFullName = type.FullName, + assemblyName = type.Assembly.GetName().Name + }; + } + + return new Reference { kind = "external", name = obj.name }; + } + + private static void Paste(Transform targetParent) + { + string buffer = EditorGUIUtility.systemCopyBuffer; + if (string.IsNullOrEmpty(buffer) || !buffer.StartsWith(ClipboardHeader, StringComparison.Ordinal)) + { + Debug.LogWarning("Cross-Project Hierarchy: Clipboard has no hierarchy data. Copy in the other Unity Editor first."); + return; + } + + Package package; + try { package = JsonUtility.FromJson(buffer.Substring(ClipboardHeader.Length)); } + catch (Exception ex) + { + Debug.LogError("Cross-Project Hierarchy: Invalid clipboard JSON: " + ex.Message); + return; + } + if (package == null || package.version != FormatVersion || package.nodes == null || + package.nodes.Count == 0 || package.nodes.Count > MaximumObjects) + { + Debug.LogError("Cross-Project Hierarchy: Unsupported or invalid clipboard format."); + return; + } + + var context = new PasteContext(); + var createdRoots = new List(); + Undo.IncrementCurrentGroup(); + int undoGroup = Undo.GetCurrentGroup(); + Undo.SetCurrentGroupName("Paste Cross-Project Hierarchy"); + + try + { + // Pass 1: always recreate every GameObject and parent relationship. + foreach (var node in package.nodes) + { + if (context.nodes.ContainsKey(node.id)) + throw new InvalidOperationException("Duplicate node ID in clipboard data."); + + GameObject go = node.hasRectTransform + ? new GameObject(node.name, typeof(RectTransform)) + : new GameObject(node.name); + go.SetActive(false); + Undo.RegisterCreatedObjectUndo(go, "Paste Cross-Project Hierarchy"); + context.nodes.Add(node.id, go); + + Transform parent; + if (node.parentId < 0) + { + parent = targetParent; + createdRoots.Add(go); + } + else if (context.nodes.ContainsKey(node.parentId)) + parent = context.nodes[node.parentId].transform; + else + throw new InvalidOperationException("Invalid parent ID in clipboard data."); + + if (parent) + go.transform.SetParent(parent, false); + else if (SceneManager.GetActiveScene().IsValid() && + go.scene != SceneManager.GetActiveScene()) + SceneManager.MoveGameObjectToScene(go, SceneManager.GetActiveScene()); + + go.transform.localPosition = node.localPosition; + go.transform.localRotation = node.localRotation; + go.transform.localScale = node.localScale; + + // Pasting a source child at scene root should preserve its world pose. + // Under a selected target, preserve the original LOCAL pose instead. + if (node.parentId < 0 && !parent) + { + go.transform.position = node.worldPosition; + go.transform.rotation = node.worldRotation; + go.transform.localScale = node.worldScale; + } + + var rect = go.transform as RectTransform; + if (rect) + { + rect.anchorMin = node.anchorMin; + rect.anchorMax = node.anchorMax; + rect.pivot = node.pivot; + rect.sizeDelta = node.sizeDelta; + rect.anchoredPosition = node.anchoredPosition; + rect.localRotation = node.parentId < 0 && !parent + ? node.worldRotation : node.localRotation; + rect.localScale = node.parentId < 0 && !parent + ? node.worldScale : node.localScale; + } + + int targetLayer = string.IsNullOrEmpty(node.layerName) + ? (node.layer >= 0 && node.layer < 8 ? node.layer : 0) + : LayerMask.NameToLayer(node.layerName); + go.layer = targetLayer >= 0 ? targetLayer : 0; + if (!string.IsNullOrEmpty(node.tag)) + { + try { go.tag = node.tag; } + catch (UnityException) { /* Tag not defined in destination. */ } + } + try { GameObjectUtility.SetStaticEditorFlags(go, (StaticEditorFlags)node.staticFlags); } + catch (Exception) { /* Static flags differ between Unity versions. */ } + } + + // Pass 2: create all components BEFORE resolving scene references. + foreach (var node in package.nodes) + { + var go = context.nodes[node.id]; + var reserved = new HashSet(); + if (node.parts == null) + continue; + foreach (var part in node.parts) + { + if (part == null) + continue; + Component dest; + if (part.isTransform) + { + dest = go.transform; + } + else + { + var type = ResolveType(part.typeFullName, part.assemblyName); + if (type == null || !typeof(Component).IsAssignableFrom(type) || type.IsAbstract || + typeof(Transform).IsAssignableFrom(type)) + { + context.missingComponents++; + context.Warn("Missing component type: " + part.typeFullName); + continue; + } + dest = null; + foreach (var existing in go.GetComponents(type)) + { + if (existing && existing.GetType() == type && !reserved.Contains(existing)) + { + dest = existing; + break; + } + } + if (!dest) + { + try + { + dest = go.AddComponent(type); + context.componentsAdded++; + } + catch (Exception ex) + { + context.missingComponents++; + context.Warn("Could not add " + part.typeFullName + ": " + ex.Message); + continue; + } + } + } + reserved.Add(dest); + context.components[ComponentKey(node.id, part.componentIndex)] = dest; + } + } + + // Pass 3: apply serialized properties, including in-hierarchy links. + foreach (var node in package.nodes) + { + if (node.parts == null) + continue; + foreach (var part in node.parts) + { + if (part == null || part.isTransform) + continue; + Component dest; + if (!context.components.TryGetValue(ComponentKey(node.id, part.componentIndex), out dest)) + continue; + ApplyFields(dest, part.fields, context); + } + } + + // Pass 4: restore activeSelf AFTER all components are wired up. + // We also set it on inactive parents' children to preserve activeSelf. + foreach (var node in package.nodes) + context.nodes[node.id].SetActive(node.active); + + Selection.objects = createdRoots.Cast().ToArray(); + if (createdRoots.Count > 0) + EditorGUIUtility.PingObject(createdRoots[0]); + } + catch (Exception ex) + { + Debug.LogError("Cross-Project Hierarchy: Paste failed: " + ex); + // The created objects are still in the Undo group and can be undone. + } + finally + { + Undo.CollapseUndoOperations(undoGroup); + } + + Debug.Log(string.Format( + "Cross-Project Hierarchy: {0} GameObjects created. Components added: {1}. " + + "Missing component types: {2}. Unresolved references: {3}. Skipped fields: {4}. " + + "Source Unity: {5}. Target Unity: {6}.", + context.nodes.Count, context.componentsAdded, context.missingComponents, + context.missingReferences, context.skippedFields, + package.sourceUnityVersion, Application.unityVersion)); + foreach (var warning in context.warnings) + Debug.LogWarning("Cross-Project Hierarchy: " + warning); + } + + private static string ComponentKey(int id, int index) + { + return id.ToString() + ":" + index.ToString(); + } + + private static void ApplyFields(Component target, List fields, PasteContext context) + { + if (fields == null || fields.Count == 0) + return; + try + { + var so = new SerializedObject(target); + so.Update(); + + // Array lengths must be set from outer to inner before assigning elements. + var arrays = fields.Where(f => f.kind == "PortableArraySize") + .OrderBy(f => f.path.Length); + foreach (var field in arrays) + { + try + { + var prop = so.FindProperty(field.path); + if (prop != null && prop.isArray) + prop.arraySize = Mathf.Clamp((int)field.integerValue, 0, 100000); + } + catch (Exception) { context.skippedFields++; } + } + so.ApplyModifiedProperties(); + so.Update(); + + foreach (var field in fields) + { + if (field.kind == "PortableArraySize") + continue; + try + { + var prop = so.FindProperty(field.path); + if (prop == null || prop.propertyType.ToString() != field.kind) + { + context.skippedFields++; + continue; + } + WriteField(prop, field, context); + } + catch (Exception) + { + context.skippedFields++; + } + } + so.ApplyModifiedProperties(); + } + catch (Exception ex) + { + context.Warn("Could not restore " + target.GetType().Name + ": " + ex.Message); + } + } + + private static void WriteField(SerializedProperty prop, Field field, PasteContext context) + { + switch (prop.propertyType) + { + case SerializedPropertyType.Integer: + case SerializedPropertyType.LayerMask: + case SerializedPropertyType.Character: + prop.longValue = field.integerValue; + break; + case SerializedPropertyType.Boolean: + prop.boolValue = field.boolValue; + break; + case SerializedPropertyType.Float: + prop.doubleValue = field.doubleValue; + break; + case SerializedPropertyType.String: + prop.stringValue = field.stringValue; + break; + case SerializedPropertyType.Color: + prop.colorValue = field.color; + break; + case SerializedPropertyType.ObjectReference: + prop.objectReferenceValue = ResolveReference(field.reference, context); + break; + case SerializedPropertyType.ExposedReference: + prop.exposedReferenceValue = ResolveReference(field.reference, context); + break; + case SerializedPropertyType.Enum: + if (!string.IsNullOrEmpty(field.enumName)) + { + int index = Array.IndexOf(prop.enumNames, field.enumName); + if (index >= 0) + { + prop.enumValueIndex = index; + break; + } + } + prop.intValue = (int)field.integerValue; + break; + case SerializedPropertyType.Vector2: + prop.vector2Value = field.vector2; + break; + case SerializedPropertyType.Vector3: + prop.vector3Value = field.vector3; + break; + case SerializedPropertyType.Vector4: + prop.vector4Value = field.vector4; + break; + case SerializedPropertyType.Quaternion: + prop.quaternionValue = field.quaternion; + break; + case SerializedPropertyType.Rect: + prop.rectValue = field.rect; + break; + case SerializedPropertyType.Bounds: + prop.boundsValue = field.bounds; + break; + case SerializedPropertyType.Vector2Int: + prop.vector2IntValue = field.vector2Int; + break; + case SerializedPropertyType.Vector3Int: + prop.vector3IntValue = field.vector3Int; + break; + case SerializedPropertyType.RectInt: + prop.rectIntValue = field.rectInt; + break; + case SerializedPropertyType.BoundsInt: + prop.boundsIntValue = field.boundsInt; + break; + case SerializedPropertyType.AnimationCurve: + prop.animationCurveValue = field.curve; + break; + default: + context.skippedFields++; + break; + } + } + + private static Object ResolveReference(Reference reference, PasteContext context) + { + if (reference == null || reference.kind == "null") + return null; + if (reference.kind == "hierarchy") + { + Object obj = null; + if (reference.componentIndex < 0) + { + GameObject go; + if (context.nodes.TryGetValue(reference.nodeId, out go)) + obj = go; + } + else + { + Component part; + if (context.components.TryGetValue(ComponentKey(reference.nodeId, reference.componentIndex), out part)) + obj = part; + } + if (!obj) + context.missingReferences++; + return obj; + } + if (reference.kind != "asset") + { + context.missingReferences++; + return null; + } + + string key = (reference.guid ?? "") + "|" + reference.localFileId + "|" + + (reference.path ?? "") + "|" + (reference.name ?? "") + "|" + + (reference.typeFullName ?? ""); + Object cached; + if (context.assetCache.TryGetValue(key, out cached)) + return cached; + + Type type = ResolveType(reference.typeFullName, reference.assemblyName); + Object resolved = type == null ? null : FindAsset(reference, type); + context.assetCache[key] = resolved; + if (!resolved) + { + context.missingReferences++; + context.Warn("Asset not found: " + reference.name + " (" + reference.path + ")"); + } + return resolved; + } + + private static Object FindAsset(Reference reference, Type type) + { + // GUID is the best match when the source .meta file was transferred. + if (!string.IsNullOrEmpty(reference.guid)) + { + string path = AssetDatabase.GUIDToAssetPath(reference.guid); + var asset = FindAtPath(path, reference, type); + if (asset) + return asset; + } + + // Useful when assets were separately imported with different GUIDs. + if (!string.IsNullOrEmpty(reference.path)) + { + var asset = FindAtPath(reference.path, reference, type); + if (asset) + return asset; + } + + if (type == typeof(Shader)) + return Shader.Find(reference.name); + + if (type == typeof(Mesh) && IsBuiltinReference(reference)) + { + var mesh = FindBuiltinPrimitiveMesh(reference.name); + if (mesh) + return mesh; + } + + if (type == typeof(Material) && IsBuiltinReference(reference) && + (reference.name == "Default-Material" || reference.name == "Default Material")) + { + var material = AssetDatabase.GetBuiltinExtraResource("Default-Material.mat"); + if (material) + return material; + } + + if (!AllowUniqueAssetNameFallback || string.IsNullOrEmpty(reference.name)) + return null; + + // This fallback only accepts an exact, UNIQUE name and type match. + // Never arbitrarily bind a reference to a different asset. + string[] guids = AssetDatabase.FindAssets(reference.name + " t:" + type.Name); + Object onlyMatch = null; + foreach (string guid in guids) + { + string path = AssetDatabase.GUIDToAssetPath(guid); + if (string.IsNullOrEmpty(path)) + continue; + foreach (var asset in AssetDatabase.LoadAllAssetsAtPath(path)) + { + if (!asset || !type.IsInstanceOfType(asset) || asset.name != reference.name) + continue; + if (onlyMatch && onlyMatch != asset) + return null; + onlyMatch = asset; + } + } + return onlyMatch; + } + + private static bool IsBuiltinReference(Reference reference) + { + return string.IsNullOrEmpty(reference.path) || + reference.path.IndexOf("unity_builtin_extra", StringComparison.OrdinalIgnoreCase) >= 0 || + reference.path.IndexOf("unity default resources", StringComparison.OrdinalIgnoreCase) >= 0; + } + + private static Object FindAtPath(string path, Reference reference, Type type) + { + if (string.IsNullOrEmpty(path)) + return null; + Object nameMatch = null; + Object idMatch = null; + try + { + var assets = AssetDatabase.LoadAllAssetsAtPath(path); + foreach (var asset in assets) + { + if (!asset || !type.IsInstanceOfType(asset)) + continue; + if (reference.localFileId != 0) + { + string guid; + long fileId; + if (AssetDatabase.TryGetGUIDAndLocalFileIdentifier(asset, out guid, out fileId) + && fileId == reference.localFileId && + (guid == reference.guid || asset.name == reference.name)) + idMatch = asset; + } + if (asset.name == reference.name) + nameMatch = asset; + } + if (idMatch) + return idMatch; + if (nameMatch) + return nameMatch; + if (assets.Length == 1 && assets[0] && type.IsInstanceOfType(assets[0]) && + (string.IsNullOrEmpty(reference.name) || assets[0].name == reference.name)) + return assets[0]; + } + catch (Exception) { /* Some built-in paths are not regular asset paths. */ } + return null; + } + + private static Mesh FindBuiltinPrimitiveMesh(string name) + { + PrimitiveType primitive; + switch (name) + { + case "Cube": primitive = PrimitiveType.Cube; break; + case "Sphere": primitive = PrimitiveType.Sphere; break; + case "Capsule": primitive = PrimitiveType.Capsule; break; + case "Cylinder": primitive = PrimitiveType.Cylinder; break; + case "Plane": primitive = PrimitiveType.Plane; break; + case "Quad": primitive = PrimitiveType.Quad; break; + default: return null; + } + + GameObject temp = null; + try + { + temp = GameObject.CreatePrimitive(primitive); + var filter = temp.GetComponent(); + return filter ? filter.sharedMesh : null; + } + finally + { + if (temp) + Object.DestroyImmediate(temp); + } + } + + private static Type ResolveType(string fullName, string assemblyName) + { + if (string.IsNullOrEmpty(fullName)) + return null; + if (!string.IsNullOrEmpty(assemblyName)) + { + var type = Type.GetType(fullName + ", " + assemblyName, false); + if (type != null) + return type; + } + foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies()) + { + if (!string.IsNullOrEmpty(assemblyName) && + assembly.GetName().Name != assemblyName) + continue; + var type = assembly.GetType(fullName, false); + if (type != null) + return type; + } + // Unity built-in type locations sometimes change between versions. + foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies()) + { + var type = assembly.GetType(fullName, false); + if (type != null) + return type; + } + return null; + } + } +}