com.mavrodiev.toolbox 1.0.0 → 1.1.0

package/CHANGELOG.md

@@ -1,4 +1,7 @@
 # Changelog
 
+## 1.1.0 — 2026-11-03
+The tools: camera breathing, planar reflection, reference overlay, ripple flipbook, terrain helpers, the mesh-health and texel-density windows, material from texture maps, and the shaders. Eight showcase samples, one per tool family. Needs URP and ProBuilder.
+
 ## 1.0.0 — 2026-10-27
 First version: the empty package.

package/Editor/Material-From-Texture-Maps/MaterialFromTextureMaps.cs

@@ -0,0 +1,335 @@
+// Material From Texture Maps - a folder of PBR texture maps (ambientCG, Poly Haven...) becomes one URP Lit material.
+//   1. finds the sets in the folder by their file names (colour, normal, roughness, metal, occlusion, height)
+//   2. fixes the import settings: colour sRGB on, normal map as Normal map, every data map sRGB off
+//   3. packs metallic (RGB) and smoothness = 1 - roughness (A) into <Set>_MetallicSmoothness.png
+//   4. makes M_<Set>.mat (URP Lit) with every map, tiled to the surface's real size (Tiling = 1 / real size, for metre UVs)
+// Run on selected Lit materials instead, it converts them: it finds the roughness map next to the Base Map
+// (or a roughness map sitting in the Metallic Map slot), packs it and assigns the packed map.
+// Install: Assets/_Staging/com.mavrodiev.toolbox/Editor/Material-From-Texture-Maps/MaterialFromTextureMaps.cs
+// In the package, the Editor asmdef needs: Unity.RenderPipelines.Universal.Editor, Unity.RenderPipelines.Universal.Runtime,
+// Unity.RenderPipelines.Core.Runtime.
+
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Text.RegularExpressions;
+using UnityEditor;
+using UnityEngine;
+
+namespace Mavrodiev.Toolbox.Editor
+{
+    public enum MapRole { None, Color, NormalGL, NormalDX, Roughness, Metallic, Occlusion, Height, Opacity, PackedARM }
+
+    public class MaterialFromTextureMaps : EditorWindow
+    {
+        // the role of a map, from the last word of its file name; longer words first
+        static readonly (string word, MapRole role)[] Words =
+        {
+            ("normal_gl", MapRole.NormalGL), ("normalgl", MapRole.NormalGL), ("nor_gl", MapRole.NormalGL),
+            ("normal_dx", MapRole.NormalDX), ("normaldx", MapRole.NormalDX), ("nor_dx", MapRole.NormalDX),
+            ("ambientocclusion", MapRole.Occlusion), ("ambient_occlusion", MapRole.Occlusion), ("occlusion", MapRole.Occlusion), ("ao", MapRole.Occlusion),
+            ("basecolor", MapRole.Color), ("base_color", MapRole.Color), ("albedo", MapRole.Color), ("diffuse", MapRole.Color),
+            ("diff", MapRole.Color), ("colour", MapRole.Color), ("color", MapRole.Color), ("col", MapRole.Color),
+            ("roughness", MapRole.Roughness), ("rough", MapRole.Roughness),
+            ("metalness", MapRole.Metallic), ("metallic", MapRole.Metallic), ("metal", MapRole.Metallic),
+            ("displacement", MapRole.Height), ("height", MapRole.Height), ("disp", MapRole.Height),
+            ("opacity", MapRole.Opacity), ("alpha", MapRole.Opacity),
+            ("arm", MapRole.PackedARM),
+            ("normal", MapRole.NormalGL), ("nor", MapRole.NormalGL), ("nrm", MapRole.NormalGL),
+        };
+
+        // resolution and format words left in by the download sites: _1K, -JPG, _2k, _png...
+        static readonly Regex Noise = new Regex(@"[_\- ](\d+k|jpg|jpeg|png|exr|tif|tiff)(?=[_\- ]|$)", RegexOptions.IgnoreCase);
+
+        DefaultAsset folder;
+        float realSize = 2f;
+        bool useHeight;
+        DefaultAsset outputFolder;
+        string report = "";
+        Vector2 scroll;
+
+        [MenuItem("Tools/Mavrodiev/Material From Texture Maps", false, 1000)]
+        public static void Open() => GetWindow<MaterialFromTextureMaps>("Material From Texture Maps");
+
+        [MenuItem("Assets/Mavrodiev/Material From Texture Maps", false, 1000)]
+        static void OpenOnSelection()
+        {
+            var window = GetWindow<MaterialFromTextureMaps>("Material From Texture Maps");
+            var path = AssetDatabase.GetAssetPath(Selection.activeObject);
+            if (!AssetDatabase.IsValidFolder(path)) path = Path.GetDirectoryName(path)?.Replace('\\', '/');
+            if (!string.IsNullOrEmpty(path)) window.folder = AssetDatabase.LoadAssetAtPath<DefaultAsset>(path);
+        }
+
+        void OnGUI()
+        {
+            EditorGUILayout.LabelField("Make a material from a folder of maps", EditorStyles.boldLabel);
+            folder = (DefaultAsset)EditorGUILayout.ObjectField("Maps folder", folder, typeof(DefaultAsset), false);
+            realSize = Mathf.Max(0.01f, EditorGUILayout.FloatField("Real size (m)", realSize));
+            EditorGUILayout.HelpBox("Tiling = 1 ÷ real size, for surfaces whose UVs are in metres (ProBuilder, a 1 m cube). On other meshes, set Tiling after.", MessageType.None);
+            useHeight = EditorGUILayout.Toggle("Use height map", useHeight);
+            outputFolder = (DefaultAsset)EditorGUILayout.ObjectField("Save in (empty: with the maps)", outputFolder, typeof(DefaultAsset), false);
+            using (new EditorGUI.DisabledScope(folder == null))
+                if (GUILayout.Button("Make material")) report = MakeFromFolder(AssetDatabase.GetAssetPath(folder), realSize, useHeight,
+                    outputFolder ? AssetDatabase.GetAssetPath(outputFolder) : null);
+
+            EditorGUILayout.Space();
+            EditorGUILayout.LabelField("Convert the selected Lit materials", EditorStyles.boldLabel);
+            var selected = Selection.GetFiltered<Material>(SelectionMode.Assets);
+            using (new EditorGUI.DisabledScope(selected.Length == 0))
+                if (GUILayout.Button($"Convert {selected.Length} selected material(s)")) report = Convert(selected);
+
+            EditorGUILayout.Space();
+            scroll = EditorGUILayout.BeginScrollView(scroll);
+            EditorGUILayout.HelpBox(report == "" ? "Nothing done yet." : report, MessageType.Info);
+            EditorGUILayout.EndScrollView();
+        }
+
+        // ---------- finding the maps ----------
+
+        public static (string set, MapRole role) Classify(string assetPath)
+        {
+            var name = Path.GetFileNameWithoutExtension(assetPath);
+            if (name.ToLowerInvariant().Contains("metallicsmoothness")) return (null, MapRole.None);   // our own output
+            var clean = Noise.Replace(name, "");                                     // the set name keeps its own spelling
+            var lower = clean.ToLowerInvariant().Replace('-', '_').Replace(' ', '_');   // matching ignores the separator
+            foreach (var (word, role) in Words)
+                if (lower.EndsWith("_" + word))
+                    return (clean.Substring(0, clean.Length - word.Length - 1), role);
+            return (null, MapRole.None);
+        }
+
+        static Dictionary<string, Dictionary<MapRole, string>> FindSets(string folderPath)
+        {
+            var sets = new Dictionary<string, Dictionary<MapRole, string>>();
+            foreach (var guid in AssetDatabase.FindAssets("t:Texture2D", new[] { folderPath }))
+            {
+                var path = AssetDatabase.GUIDToAssetPath(guid);
+                var (set, role) = Classify(path);
+                if (role == MapRole.None) continue;
+                var key = Path.GetDirectoryName(path).Replace('\\', '/') + "/" + set;   // a set lives in one folder
+                if (!sets.TryGetValue(key, out var maps)) sets[key] = maps = new Dictionary<MapRole, string>();
+                if (!maps.ContainsKey(role)) maps[role] = path;
+            }
+            return sets;
+        }
+
+        // ---------- 1. import settings ----------
+
+        static void FixImport(string path, MapRole role)
+        {
+            if (!(AssetImporter.GetAtPath(path) is TextureImporter importer)) return;
+            bool changed = false;
+            if (role == MapRole.NormalGL || role == MapRole.NormalDX)
+            {
+                if (importer.textureType != TextureImporterType.NormalMap) { importer.textureType = TextureImporterType.NormalMap; changed = true; }
+                bool flip = role == MapRole.NormalDX;   // DirectX normals: green points down; Unity reads OpenGL normals
+                if (importer.flipGreenChannel != flip) { importer.flipGreenChannel = flip; changed = true; }
+            }
+            else
+            {
+                if (importer.textureType != TextureImporterType.Default) { importer.textureType = TextureImporterType.Default; changed = true; }
+                bool srgb = role == MapRole.Color;       // only the colour is shown to the eye; the rest are numbers
+                if (importer.sRGBTexture != srgb) { importer.sRGBTexture = srgb; changed = true; }
+            }
+            if (changed) importer.SaveAndReimport();
+        }
+
+        // ---------- 2. packing ----------
+
+        // Reads a texture's pixels through the GPU, so the texture does not need Read/Write enabled.
+        // The data maps are sRGB off by then, so the values come through unchanged.
+        static Color[] ReadPixels(Texture texture, int width, int height)
+        {
+            var rt = RenderTexture.GetTemporary(width, height, 0, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Linear);
+            Graphics.Blit(texture, rt);
+            var previous = RenderTexture.active;
+            RenderTexture.active = rt;
+            var copy = new Texture2D(width, height, TextureFormat.RGBA32, false, true);
+            copy.ReadPixels(new Rect(0, 0, width, height), 0, 0);
+            copy.Apply();
+            RenderTexture.active = previous;
+            RenderTexture.ReleaseTemporary(rt);
+            var pixels = copy.GetPixels();
+            DestroyImmediate(copy);
+            return pixels;
+        }
+
+        // Metallic in R, G and B (white = bare metal), smoothness = 1 - roughness in A: what URP Lit's Metallic Map reads.
+        public static Texture2D Pack(string roughnessPath, string metallicPath, string outputPath)
+        {
+            var roughness = AssetDatabase.LoadAssetAtPath<Texture2D>(roughnessPath);
+            var metallic = metallicPath != null ? AssetDatabase.LoadAssetAtPath<Texture2D>(metallicPath) : null;
+            int width = roughness.width, height = roughness.height;
+            var rough = ReadPixels(roughness, width, height);
+            var metal = metallic != null ? ReadPixels(metallic, width, height) : null;
+
+            var packed = new Texture2D(width, height, TextureFormat.RGBA32, false, true);
+            var pixels = new Color[rough.Length];
+            for (int i = 0; i < pixels.Length; i++)
+            {
+                float m = metal != null ? metal[i].r : 0f;
+                pixels[i] = new Color(m, m, m, 1f - rough[i].r);
+            }
+            packed.SetPixels(pixels);
+            packed.Apply();
+            File.WriteAllBytes(outputPath, packed.EncodeToPNG());
+            DestroyImmediate(packed);
+
+            AssetDatabase.ImportAsset(outputPath, ImportAssetOptions.ForceUpdate);
+            if (AssetImporter.GetAtPath(outputPath) is TextureImporter importer)
+            {
+                importer.textureType = TextureImporterType.Default;
+                importer.sRGBTexture = false;
+                importer.alphaSource = TextureImporterAlphaSource.FromInput;
+                importer.alphaIsTransparency = false;
+                importer.SaveAndReimport();
+            }
+            return AssetDatabase.LoadAssetAtPath<Texture2D>(outputPath);
+        }
+
+        // ---------- 3. the material ----------
+
+        static void SetKeywords(Material material)
+        {
+            // URP's own keyword set-up, the same the Lit Inspector runs (verified public in URP 17.6)
+            BaseShaderGUI.SetMaterialKeywords(material, UnityEditor.Rendering.Universal.ShaderGUI.LitGUI.SetMaterialKeywords);
+        }
+
+        static Texture2D Load(Dictionary<MapRole, string> maps, MapRole role) =>
+            maps.TryGetValue(role, out var path) ? AssetDatabase.LoadAssetAtPath<Texture2D>(path) : null;
+
+        // the normal map, OpenGL or DirectX (no ?? on Unity objects: a destroyed object is not null to ??)
+        static Texture2D LoadNormal(Dictionary<MapRole, string> maps)
+        {
+            var normal = Load(maps, MapRole.NormalGL);
+            if (normal == null) normal = Load(maps, MapRole.NormalDX);
+            return normal;
+        }
+
+        public static string MakeFromFolder(string folderPath, float realSize, bool useHeight, string outputFolder)
+        {
+            var log = new StringBuilder();
+            var sets = FindSets(folderPath);
+            if (sets.Count == 0) return "No texture maps found (the names need a last word such as _Color, _NormalGL, _Roughness).";
+            var lit = Shader.Find("Universal Render Pipeline/Lit");
+
+            foreach (var pair in sets)
+            {
+                var setFolder = Path.GetDirectoryName(pair.Key).Replace('\\', '/');
+                var setName = Path.GetFileName(pair.Key);
+                var maps = pair.Value;
+                if (maps.ContainsKey(MapRole.PackedARM) && !maps.ContainsKey(MapRole.Roughness))
+                    log.AppendLine($"{setName}: a packed ARM map is not used (Lit reads occlusion from green, where ARM keeps roughness). Download the separate maps.");
+                if (!maps.ContainsKey(MapRole.Color)) { log.AppendLine($"{setName}: no colour map, skipped."); continue; }
+
+                foreach (var map in maps) FixImport(map.Value, map.Key);
+
+                Texture2D packed = null;
+                if (maps.TryGetValue(MapRole.Roughness, out var roughPath))
+                {
+                    maps.TryGetValue(MapRole.Metallic, out var metalPath);
+                    packed = Pack(roughPath, metalPath, $"{setFolder}/{setName}_MetallicSmoothness.png");
+                }
+
+                var saveFolder = string.IsNullOrEmpty(outputFolder) ? setFolder : outputFolder;
+                var materialPath = $"{saveFolder}/M_{setName}.mat";
+                var material = AssetDatabase.LoadAssetAtPath<Material>(materialPath);
+                bool isNew = material == null;
+                if (isNew) material = new Material(lit);
+
+                material.SetTexture("_BaseMap", Load(maps, MapRole.Color));
+                material.SetColor("_BaseColor", Color.white);
+                var normal = LoadNormal(maps);
+                material.SetTexture("_BumpMap", normal);
+                material.SetFloat("_BumpScale", 1f);
+                material.SetTexture("_OcclusionMap", Load(maps, MapRole.Occlusion));
+                material.SetFloat("_OcclusionStrength", 1f);
+                if (packed != null)
+                {
+                    material.SetTexture("_MetallicGlossMap", packed);
+                    material.SetFloat("_SmoothnessTextureChannel", 0f);   // smoothness from the Metallic Map's alpha
+                    material.SetFloat("_Smoothness", 1f);                 // the slider scales the map: 1 = the map as it is
+                }
+                else
+                {
+                    material.SetFloat("_Metallic", 0f);
+                    material.SetFloat("_Smoothness", 0.5f);
+                    log.AppendLine($"{setName}: no roughness map, Smoothness left at 0.5: set it by eye.");
+                }
+                var height = useHeight ? Load(maps, MapRole.Height) : null;
+                material.SetTexture("_ParallaxMap", height);
+                if (height != null) material.SetFloat("_Parallax", 0.02f);
+                material.SetTextureScale("_BaseMap", Vector2.one / realSize);   // Lit uses the Base Map's tiling for every map
+                material.SetTextureOffset("_BaseMap", Vector2.zero);
+                SetKeywords(material);
+
+                if (isNew) AssetDatabase.CreateAsset(material, materialPath);
+                else EditorUtility.SetDirty(material);
+                log.AppendLine($"{setName}: {materialPath} ({string.Join(", ", maps.Keys)}), Tiling {1f / realSize:0.###}.");
+            }
+            AssetDatabase.SaveAssets();
+            Debug.Log("Material From Texture Maps\n" + log);
+            return log.ToString();
+        }
+
+        // ---------- converting existing materials ----------
+
+        public static string Convert(IEnumerable<Material> materials)
+        {
+            var log = new StringBuilder();
+            foreach (var material in materials)
+            {
+                var shaderName = material.shader != null ? material.shader.name : "";
+                if (shaderName != "Universal Render Pipeline/Lit" && shaderName != "Universal Render Pipeline/Complex Lit")
+                {
+                    log.AppendLine($"{material.name}: not a URP Lit material ({shaderName}), skipped. Convert it to URP first.");
+                    continue;
+                }
+                var baseMap = material.GetTexture("_BaseMap");
+                if (baseMap == null) { log.AppendLine($"{material.name}: no Base Map, skipped."); continue; }
+
+                var basePath = AssetDatabase.GetAssetPath(baseMap);
+                var (setName, _) = Classify(basePath);
+                var setFolder = Path.GetDirectoryName(basePath).Replace('\\', '/');
+                var sets = FindSets(setFolder);
+                sets.TryGetValue(setFolder + "/" + setName, out var maps);
+                if (maps == null) maps = new Dictionary<MapRole, string>();
+
+                // a roughness map placed in the Metallic Map slot (it reads as reversed smoothness)
+                var inSlot = material.GetTexture("_MetallicGlossMap");
+                bool fromSlot = false;
+                if (inSlot != null && Classify(AssetDatabase.GetAssetPath(inSlot)).role == MapRole.Roughness)
+                {
+                    maps[MapRole.Roughness] = AssetDatabase.GetAssetPath(inSlot);
+                    fromSlot = true;
+                }
+
+                if (!maps.TryGetValue(MapRole.Roughness, out var roughPath))
+                {
+                    log.AppendLine($"{material.name}: no roughness map found next to its Base Map, nothing to convert.");
+                    continue;
+                }
+                foreach (var map in maps) FixImport(map.Value, map.Key);
+                maps.TryGetValue(MapRole.Metallic, out var metalPath);
+                var packedName = string.IsNullOrEmpty(setName) ? material.name : setName;
+                var packedPath = $"{setFolder}/{packedName}_MetallicSmoothness.png";
+                // the set is already packed (a library set, or a second material on the same maps): use that map
+                var packed = fromSlot ? null : AssetDatabase.LoadAssetAtPath<Texture2D>(packedPath);
+                if (packed == null) packed = Pack(roughPath, metalPath, packedPath);
+
+                material.SetTexture("_MetallicGlossMap", packed);
+                material.SetFloat("_SmoothnessTextureChannel", 0f);
+                material.SetFloat("_Smoothness", 1f);
+                if (material.GetTexture("_BumpMap") == null) material.SetTexture("_BumpMap", LoadNormal(maps));
+                if (material.GetTexture("_OcclusionMap") == null) material.SetTexture("_OcclusionMap", Load(maps, MapRole.Occlusion));
+                SetKeywords(material);
+                EditorUtility.SetDirty(material);
+                log.AppendLine($"{material.name}: {packedName}_MetallicSmoothness.png (smoothness = 1 - roughness) assigned to the Metallic Map; tiling kept.");
+            }
+            AssetDatabase.SaveAssets();
+            Debug.Log("Material From Texture Maps (convert)\n" + log);
+            return log.ToString();
+        }
+    }
+}

package/Editor/Material-From-Texture-Maps/MaterialFromTextureMaps.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: b337a620dc8eb8c4095c1a946b60e6c6

package/Editor/Material-From-Texture-Maps.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: e6c1d13240782e54da188025cc8d60fa
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Editor/Mavrodiev.Toolbox.Editor.asmdef

@@ -1,8 +1,16 @@
 {
     "name": "Mavrodiev.Toolbox.Editor",
     "rootNamespace": "Mavrodiev.Toolbox.Editor",
-    "references": [ "Mavrodiev.Toolbox" ],
-    "includePlatforms": [ "Editor" ],
+    "references": [
+        "Mavrodiev.Toolbox",
+        "Unity.RenderPipelines.Universal.Runtime",
+        "Unity.RenderPipelines.Universal.Editor",
+        "Unity.RenderPipelines.Core.Runtime",
+        "Unity.RenderPipelines.Core.Editor"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
     "excludePlatforms": [],
     "allowUnsafeCode": false,
     "overrideReferences": false,

package/Editor/MeshHealthWindow.cs

@@ -0,0 +1,154 @@
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace Mavrodiev.Toolbox.Editor
+{
+    /// <summary>
+    /// Mesh Health: select one or more objects and read what is wrong with their meshes —
+    /// holes (open edges), faces turned inside out, scale not 1, size and pivot off the grid,
+    /// missing materials, and the triangle count. It only reads; it never changes the mesh.
+    /// </summary>
+    public class MeshHealthWindow : EditorWindow
+    {
+        const float k_Grid = 0.1f;          // size and pivot are "on the grid" in 10 cm steps
+        const int k_DenseTriangles = 10000; // above this a single prop counts as dense
+
+        Vector2 m_Scroll;
+        readonly Dictionary<MeshFilter, Result> m_Cache = new Dictionary<MeshFilter, Result>();
+
+        [MenuItem("Tools/Mavrodiev/Mesh Health")]
+        public static void Open()
+        {
+            var w = GetWindow<MeshHealthWindow>();
+            w.titleContent = new GUIContent("Mesh Health");
+            w.Show();
+        }
+
+        void OnSelectionChange() { m_Cache.Clear(); Repaint(); }
+        void OnFocus() => m_Cache.Clear();
+
+        void OnGUI()
+        {
+            var targets = Selection.gameObjects;
+            if (targets.Length == 0)
+            {
+                EditorGUILayout.HelpBox("Select an object with a mesh in the Hierarchy.", MessageType.Info);
+                return;
+            }
+
+            if (GUILayout.Button("Check again")) m_Cache.Clear();
+            m_Scroll = EditorGUILayout.BeginScrollView(m_Scroll);
+            foreach (var go in targets)
+            {
+                foreach (var mf in go.GetComponentsInChildren<MeshFilter>())
+                    DrawReport(mf, m_Cache);
+            }
+            EditorGUILayout.EndScrollView();
+        }
+
+        static void DrawReport(MeshFilter mf, Dictionary<MeshFilter, Result> cache)
+        {
+            var mesh = mf.sharedMesh;
+            EditorGUILayout.Space(6);
+            EditorGUILayout.LabelField(mf.gameObject.name, EditorStyles.boldLabel);
+            if (mesh == null)
+            {
+                EditorGUILayout.HelpBox("The Mesh Filter has no mesh.", MessageType.Error);
+                return;
+            }
+            if (!cache.TryGetValue(mf, out var r)) { r = Check(mf); cache[mf] = r; }
+            Line(r.openEdges == 0, r.openEdges == 0 ? "Closed: no holes." : r.openEdges + " open edges: the mesh has holes.");
+            Line(r.signedVolume >= 0f, r.signedVolume >= 0f ? "Faces point outward." : "Faces point inward: the mesh is inside out (flipped normals).");
+            Line(r.scaleIsOne, r.scaleIsOne ? "Scale is 1, 1, 1." : "Scale is " + Vec(r.scale) + ", not 1. Fix the size in the import settings or the mesh.");
+            Line(!r.looksLikeCentimetres, r.looksLikeCentimetres ? "The mesh is " + Vec(r.meshSize) + " m: probably made in centimetres (try Scale Factor 0.01)." : "Mesh size " + Vec(r.meshSize) + " m.");
+            Line(r.sizeOnGrid, r.sizeOnGrid ? "Size is in whole 10 cm steps." : "Size is off the 10 cm grid.");
+            Line(r.pivotOnGrid, r.pivotOnGrid ? "Pivot sits on a corner, an edge midpoint or the centre of the base." : "Pivot is " + Vec(r.pivotOffset) + " m from the bottom corner: off the grid.");
+            Line(r.missingMaterials == 0, r.missingMaterials == 0 ? "Every submesh has a material." : r.missingMaterials + " submesh(es) without a material.");
+            Line(r.triangles <= k_DenseTriangles, r.triangles.ToString("N0") + " triangles, " + mesh.vertexCount.ToString("N0") + " vertices.");
+        }
+
+        static void Line(bool ok, string text)
+        {
+            var icon = EditorGUIUtility.IconContent(ok ? "TestPassed" : "console.warnicon.sml");
+            EditorGUILayout.LabelField(new GUIContent(" " + text, icon.image), EditorStyles.wordWrappedLabel);
+        }
+
+        static string Vec(Vector3 v) => v.x.ToString("0.###") + ", " + v.y.ToString("0.###") + ", " + v.z.ToString("0.###");
+
+        public struct Result
+        {
+            public int openEdges;
+            public float signedVolume;
+            public bool scaleIsOne;
+            public Vector3 scale;
+            public Vector3 meshSize;
+            public bool looksLikeCentimetres;
+            public bool sizeOnGrid;
+            public bool pivotOnGrid;
+            public Vector3 pivotOffset;
+            public int missingMaterials;
+            public int triangles;
+        }
+
+        /// <summary>Runs every check on one Mesh Filter (in the Editor every mesh can be read).</summary>
+        public static Result Check(MeshFilter mf)
+        {
+            var mesh = mf.sharedMesh;
+            var res = new Result();
+            var v = mesh.vertices;
+            var t = mesh.triangles;
+            res.triangles = t.Length / 3;
+
+            // Holes: weld vertices by position, then count edges used by exactly one triangle.
+            var weld = new Dictionary<Vector3Int, int>();
+            var id = new int[v.Length];
+            for (int i = 0; i < v.Length; i++)
+            {
+                var k = new Vector3Int(Mathf.RoundToInt(v[i].x * 1000f), Mathf.RoundToInt(v[i].y * 1000f), Mathf.RoundToInt(v[i].z * 1000f));
+                if (!weld.TryGetValue(k, out id[i])) { id[i] = weld.Count; weld.Add(k, id[i]); }
+            }
+            var edges = new Dictionary<long, int>();
+            double vol = 0;
+            for (int i = 0; i < t.Length; i += 3)
+            {
+                for (int e = 0; e < 3; e++)
+                {
+                    int a = id[t[i + e]], b = id[t[i + (e + 1) % 3]];
+                    long key = a < b ? ((long)a << 32) | (uint)b : ((long)b << 32) | (uint)a;
+                    edges.TryGetValue(key, out int n);
+                    edges[key] = n + 1;
+                }
+                vol += Vector3.Dot(v[t[i]], Vector3.Cross(v[t[i + 1]], v[t[i + 2]])) / 6.0;
+            }
+            foreach (var n in edges.Values) if (n == 1) res.openEdges++;
+            res.signedVolume = (float)vol;
+
+            // Scale and size.
+            res.scale = mf.transform.lossyScale;
+            res.scaleIsOne = Approx(res.scale.x, 1f) && Approx(res.scale.y, 1f) && Approx(res.scale.z, 1f);
+            var b0 = mesh.bounds;
+            res.meshSize = b0.size;
+            res.looksLikeCentimetres = Mathf.Max(b0.size.x, Mathf.Max(b0.size.y, b0.size.z)) > 30f;
+            res.sizeOnGrid = OnGrid(b0.size.x) && OnGrid(b0.size.y) && OnGrid(b0.size.z);
+
+            // Pivot (the mesh's origin) against the bounds: a corner, an edge midpoint or the base centre.
+            res.pivotOffset = -b0.min;
+            res.pivotOnGrid = PivotOk(b0.min.x, b0.max.x) && Approx(b0.min.y, 0f) && PivotOk(b0.min.z, b0.max.z);
+
+            // Materials.
+            var mr = mf.GetComponent<Renderer>();
+            if (mr != null)
+            {
+                var mats = mr.sharedMaterials;
+                for (int s = 0; s < mesh.subMeshCount; s++)
+                    if (s >= mats.Length || mats[s] == null) res.missingMaterials++;
+            }
+            return res;
+        }
+
+        static bool Approx(float a, float b) => Mathf.Abs(a - b) < 0.001f;
+        static bool OnGrid(float x) => Mathf.Abs(x / k_Grid - Mathf.Round(x / k_Grid)) < 0.01f;
+        static bool PivotOk(float min, float max) => Approx(min, 0f) || Approx(max, 0f) || Approx(min + max, 0f);
+    }
+}

package/Editor/MeshHealthWindow.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: adfd264297d5cce49b26af7319c4a30a