v1.0.0

Author: sator-imaging

Editor.meta

@@ -0,0 +1,16 @@
+using System;
+
+namespace SatorImaging.UnitySourceGenerator
+{
+    ///<summary>NOTE: Implement "IUnitySourceGenerator" (C# 11.0)</summary>
+    [AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
+    public sealed class UnitySourceGeneratorAttribute : Attribute
+    {
+        public UnitySourceGeneratorAttribute()
+        {
+        }
+
+        public bool OverwriteIfFileExists { get; set; } = false;
+
+    }
+}

Editor/Attributes.cs

@@ -0,0 +1,14 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+
+namespace SatorImaging.UnitySourceGenerator
+{
+    public class USGContext
+    {
+        public string AssetPath;
+        public string OutputPath;
+
+    }
+}

Editor/Attributes.cs.meta

@@ -0,0 +1,305 @@
+#if UNITY_EDITOR
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using UnityEditor;
+using UnityEngine;
+
+
+namespace SatorImaging.UnitySourceGenerator
+{
+    public class USGEngine : AssetPostprocessor
+    {
+        ///<summary>This will be disabled after import event automatically.</summary>
+        public static bool IgnoreOverwriteSettingByAttribute = false;
+
+
+        const string GENERATOR_PREFIX = ".";
+        const string GENERATOR_EXT = ".g";
+        const string GENERATOR_DIR = @"/USG.g";   // don't append last slash. this is used by .EndsWith()
+        const string ASSETS_DIR_NAME = "Assets";
+        const string ASSETS_DIR_SLASH = "Assets/";
+        const string TARGET_FILE_EXT = @".cs";
+        const string PATH_PREFIX_TO_IGNORE = @"Packages/";
+        readonly static char[] DIR_SEPARATORS = new char[] { '\\', '/' };
+
+        readonly static string s_projectDirPath;
+        static USGEngine()
+        {
+            s_projectDirPath = Application.dataPath.TrimEnd(DIR_SEPARATORS);
+            if (s_projectDirPath.EndsWith(ASSETS_DIR_NAME))
+                s_projectDirPath = s_projectDirPath.Substring(0, s_projectDirPath.Length - ASSETS_DIR_NAME.Length);
+        }
+
+        readonly static HashSet<string> s_targetFilePaths = new();
+        static void AddAppropriateTarget(string filePath)
+        {
+            if (!filePath.EndsWith(TARGET_FILE_EXT) ||
+                !filePath.StartsWith(ASSETS_DIR_SLASH))
+            {
+                return;
+            }
+            s_targetFilePaths.Add(filePath);
+        }
+
+
+        void OnPreprocessAsset()
+        {
+            AddAppropriateTarget(assetPath);
+        }
+
+
+        // NOTE: To avoid event invoked twice on file deletion.
+        static bool s_processingJobQueued = false;
+
+        static void OnPostprocessAllAssets(
+            string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths)
+        {
+            for (int i = 0; i < importedAssets.Length; i++)
+            {
+                AddAppropriateTarget(importedAssets[i]);
+            }
+
+            // NOTE: Do NOT handle deleted assets because Unity tracking changes perfectly.
+            //       Even if delete file while Unity shutted down, asset deletion event happens on next Unity launch.
+            //       As a result, delete/import event loops infinitely and file cannot be deleted.
+            if (s_processingJobQueued) return;
+            s_processingJobQueued = true;
+
+            AssetDatabase.Refresh();  // load updated generator class script before event
+            EditorApplication.delayCall += ProcessingFiles;
+        }
+
+        static void ProcessingFiles()
+        {
+            foreach (string path in s_targetFilePaths)
+            {
+                ProcessFile(path);
+            }
+
+            if (s_targetFilePaths.Count() > 0) AssetDatabase.Refresh();
+            s_targetFilePaths.Clear();
+
+            IgnoreOverwriteSettingByAttribute = false;  // always turn it off.
+            s_processingJobQueued = false;
+        }
+
+
+        ///<summary>This method respects "OverwriteIfFileExists" attribute setting.</summary>
+        ///<param name="assetsRelPath">Path need to be started with "Assets/"</param>
+        public static void ProcessFile(string assetsRelPath)
+        {
+            if (!File.Exists(assetsRelPath)) throw new FileNotFoundException(assetsRelPath);
+
+
+            var clsName = Path.GetFileNameWithoutExtension(assetsRelPath);
+
+            if (!s_typeNameToInfo.ContainsKey(clsName))
+            {
+                if (!clsName.EndsWith(GENERATOR_EXT))
+                    return;
+
+                // try find generator
+                clsName = Path.GetFileNameWithoutExtension(clsName);
+                clsName = Path.GetExtension(clsName);
+
+                if (clsName.Length == 0) return;
+                clsName = clsName.Substring(1);
+
+                if (!s_typeNameToInfo.ContainsKey(clsName))
+                    return;
+            }
+
+
+            var info = s_typeNameToInfo[clsName];
+            if (info == null) return;
+
+
+            // build path
+            string outputPath = Path.Combine(s_projectDirPath, Path.GetDirectoryName(assetsRelPath)).Replace('\\', '/');
+            if (!outputPath.EndsWith(GENERATOR_DIR)) outputPath += GENERATOR_DIR;
+
+            outputPath = Path.Combine(outputPath, info.OutputFileName);
+
+
+            var context = new USGContext
+            {
+                AssetPath = assetsRelPath.Replace('\\', '/'),
+                OutputPath = outputPath.Replace('\\', '/'),
+            };
+
+
+            // do it.
+            var sb = new StringBuilder();
+            sb.AppendLine($"// <auto-generated>{info.Type.Name}</auto-generated>");
+
+            var isSaveFile = false;
+            try
+            {
+                isSaveFile = (bool)info.EmitMethod.Invoke(null, new object[] { context, sb });
+            }
+            catch
+            {
+                Debug.LogError($"[{nameof(UnitySourceGenerator)}] Unhandled Error on Emit(): {info.Type}");
+                throw;
+            }
+
+            if (!isSaveFile || sb == null || string.IsNullOrWhiteSpace(context.OutputPath))
+                return;
+
+
+            //file check
+            var outputDir = Path.GetDirectoryName(context.OutputPath);
+            if (!Directory.Exists(outputDir)) Directory.CreateDirectory(outputDir);
+
+
+            if (File.Exists(context.OutputPath) &&
+                (!info.OverwriteIfFileExists && !IgnoreOverwriteSettingByAttribute)
+                )
+            {
+                return;
+            }
+
+
+            File.WriteAllText(context.OutputPath, sb.ToString());
+            Debug.Log($"[{nameof(UnitySourceGenerator)}] Generated: {context.OutputPath}");
+
+        }
+
+
+
+        //internals----------------------------------------------------------------------
+
+        static readonly BindingFlags METHOD_FLAGS =
+                                        BindingFlags.NonPublic |
+                                        BindingFlags.Public |
+                                        BindingFlags.Static
+                                        ;
+
+        class CachedTypeInfo
+        {
+            public Type Type;
+
+            //from attribute
+            public bool OverwriteIfFileExists;
+
+            //from method
+            public MethodInfo EmitMethod;
+            public string OutputFileName;
+        }
+
+
+        readonly static Dictionary<string, CachedTypeInfo> s_typeNameToInfo = new();
+
+        [InitializeOnLoadMethod]
+        static void CollectTargets()
+        {
+            /* NOTE: truncate unnecessary DLLs.
+            //       build LINQ here and copy paste resulting .Where() below
+            var assems = AppDomain.CurrentDomain.GetAssemblies()
+                .Where(static x =>
+                {
+                    var n = x.GetName().Name;
+                    if ( //total 234files
+                        n.StartsWith("Unity") ||    // truncate to 95
+                        n.StartsWith("System.") ||  // truncate to 225
+                        n.StartsWith("Mono.") ||    // truncate to 229
+                        n == "mscorlib" ||          // tons of types inside
+                        n == "System"               // tons of types inside
+                    )
+                        return false;
+                    return true;
+                })
+                .Select(static x => x.GetName().Name + ": " + x.GetTypes().Count())
+                ;
+            Debug.Log($"#{assems.Count()} " + string.Join("\n", assems));
+            */
+
+
+            var infos = AppDomain.CurrentDomain.GetAssemblies()
+                .Where(static x =>
+                {
+                    var n = x.GetName().Name;
+                    if (
+                        n.StartsWith("Unity") ||    // truncate 234 files to 95
+                        n.StartsWith("System.") ||  // these have tons of types inside
+                        n.StartsWith("Mono.") ||
+                        n == "System" ||
+                        n == "mscorlib"
+                    )
+                        return false;
+                    return true;
+                })
+                .SelectMany(static a => a.GetTypes())
+                .Where(static t =>
+                    t.GetCustomAttribute<UnitySourceGeneratorAttribute>(false) != null &&
+                    // waiting for C# 11.0 //typeof(IUnitySourceGenerator).IsAssignableFrom(t) &&
+                    !s_typeNameToInfo.ContainsKey(t.Name)
+                    )
+                .Select(static t =>
+                {
+                    var attr = t.GetCustomAttribute<UnitySourceGeneratorAttribute>(false);
+                    return new CachedTypeInfo
+                    {
+                        Type = t,
+                        OverwriteIfFileExists = attr.OverwriteIfFileExists,
+                    };
+                })
+                ;
+
+
+            // TODO: Export constants definition
+            foreach (var info in infos)
+            {
+                //Debug.Log($"[{nameof(UnitySourceGenerator)}] Processing...: {info.ClassName}");
+
+                var outputMethod = info.Type.GetMethod("OutputFileName", METHOD_FLAGS, null, Type.EmptyTypes, null);
+                var emitMethod = info.Type.GetMethod("Emit", METHOD_FLAGS, null, new Type[] { typeof(USGContext), typeof(StringBuilder) }, null);
+
+                if (outputMethod == null || emitMethod == null)
+                {
+                    Debug.LogError($"[{nameof(UnitySourceGenerator)}] Required static method(s) not found: {info.Type}");
+                    continue;
+                }
+
+
+                info.EmitMethod = emitMethod;
+
+                //filename??
+                info.OutputFileName = (string)outputMethod.Invoke(null, null);
+                if (string.IsNullOrWhiteSpace(info.OutputFileName))
+                {
+                    Debug.LogError($"[{nameof(UnitySourceGenerator)}] Output file name is invalid: {info.OutputFileName}");
+                    continue;
+                }
+
+
+                //build filename
+                string fileName = Path.GetFileNameWithoutExtension(info.OutputFileName);
+                string fileExt = Path.GetExtension(info.OutputFileName);
+                string outputFileName = fileName + GENERATOR_PREFIX + info.Type.Name + GENERATOR_EXT + fileExt;
+
+                info.OutputFileName = outputFileName;
+
+                //once again
+                if (string.IsNullOrWhiteSpace(info.OutputFileName))
+                {
+                    Debug.LogError($"[{nameof(UnitySourceGenerator)}] Output file name is invalid: {info.OutputFileName}");
+                    continue;
+                }
+
+                s_typeNameToInfo.TryAdd(info.Type.Name, info);
+
+
+            }//foreach
+        }
+
+
+    }
+}
+#endif