Merge pull request #76 from RealityStop/1.4.0

Update for 1.4.0

Author: S2NX7

Editor/AOTMethodsPrebuilder.cs

@@ -10,230 +10,195 @@
 using UnityEditor;
 using System.IO;
 using Unity.VisualScripting;
+using Unity.VisualScripting.Community.Libraries.CSharp;
+using System.Reflection;
+using ParameterModifier = Unity.VisualScripting.Community.Libraries.CSharp.ParameterModifier;
+using UnityEngine.UI;
 
-public class AOTMethodsPrebuilder : IPreprocessBuildWithReport
+namespace Unity.VisualScripting.Community
 {
-    public int callbackOrder => 1;
-
-    private List<TypeGroup> typesToSupport = new();
-
-    public void OnPreprocessBuild(BuildReport report)
-    {
-        GenerateScript();
-        AssetDatabase.Refresh();
-    }
-
-
-    private void GenerateScript()
+    public class AOTMethodsPrebuilder : IPreprocessBuildWithReport
     {
-        EditorUtility.DisplayProgressBar("Generating Aot Support", "Finding Script Graphs and Scenes...", 0f);
-        typesToSupport = GetTypesForAOTMethods().Distinct().ToList();
-        typesToSupport.RemoveAll(type => type.types.Count == 0);
-        string scriptContent = GenerateScriptContent(typesToSupport);
-        string path = Application.dataPath + "/Unity.VisualScripting.Community.Generated/Scripts/AotSupportMethods.cs";
-        Debug.Log("Generated OnUnityEvent Support script at : " + path + "\nEnsure that the script stays here");
-        HUMIO.Ensure(path).Path();
-        File.WriteAllText(path, scriptContent);
-        AssetDatabase.Refresh();
-        EditorUtility.ClearProgressBar();
-    }
+        public int callbackOrder => 1;
 
-    private string GenerateScriptContent(List<TypeGroup> typeGroups)
-    {
-        HashSet<string> namespaces = new HashSet<string>();
+        private List<TypeGroup> typesToSupport = new List<TypeGroup>();
 
-        foreach (var typeGroup in typeGroups)
+        public void OnPreprocessBuild(BuildReport report)
         {
-            foreach (var type in typeGroup.types)
-            {
-                string namespaceName = type.Namespace;
-                if (!string.IsNullOrEmpty(namespaceName) && !IsIncludedNamespace(namespaceName) && AllowedNameSpace(namespaceName))
-                {
-                    namespaces.Add(namespaceName);
-                }
-            }
-
+            GenerateScript();
+            AssetDatabase.Refresh();
         }
 
-        string namespaceDeclarations = string.Join(Environment.NewLine, namespaces.Select(ns => $"using {ns};"));
-        string scriptContent = $"{namespaceDeclarations}\n";
-        scriptContent += @"using System;
-using UnityEngine.Events;
-using Unity.VisualScripting;
-using Unity.VisualScripting.Community;
-
-public static class AotSupportMethods
-{
-";
-
-        foreach (var typeGroup in typeGroups)
+        private void GenerateScript()
         {
-            string methodParameters = string.Join(", ", typeGroup.types.Select(type => CSharpName(type, true)));
-
-            string methodReturnType = "UnityAction<" + methodParameters + ">";
+            EditorUtility.DisplayProgressBar("Generating Aot Support", "Finding Script Graphs and Scenes...", 0f);
+            typesToSupport = GetTypesForAOTMethods().Distinct().ToList();
+            EditorUtility.ClearProgressBar();
+            typesToSupport.RemoveAll(type => type.types.Count == 0);
+            string scriptContent = GenerateScriptContent(typesToSupport);
+            var BasePath = Path.Combine(Application.dataPath, AssetCompiler.GeneratedPath);
+            var ScriptsPath = Path.Combine(BasePath, "Scripts");
+            Debug.Log("Generated OnUnityEvent Support script at : " + ScriptsPath + "\nEnsure that the script stays here");
+            File.WriteAllText(Application.dataPath + "/" + AssetCompiler.GeneratedPath + "/Scripts" + "/AotSupportMethods.cs", scriptContent);
+            AssetDatabase.Refresh();
+        }
 
-            scriptContent += $"    public static {methodReturnType} {string.Join("_", typeGroup.types.Select(type => CSharpName(type, false)))}Handler(GraphReference reference, OnUnityEvent onUnityEvent)\n";
-            scriptContent += "    {\n";
+        private readonly List<string> includedNamespaces = new List<string>
+        {
+            "System",
+            "UnityEngine.Events",
+            "Unity.VisualScripting",
+            "Unity.VisualScripting.Community"
+        };
+        private string GenerateScriptContent(List<TypeGroup> typeGroups)
+        {
+            HashSet<string> namespaces = new HashSet<string>(includedNamespaces);
 
-            // Construct argument list
-            List<string> args = new List<string>();
-            for (int i = 0; i < typeGroup.types.Count; i++)
+            foreach (var typeGroup in typeGroups)
             {
-                args.Add("arg" + i);
-            }
+                foreach (var type in typeGroup.types)
+                {
+                    string namespaceName = type.Namespace;
+                    if (!string.IsNullOrEmpty(namespaceName) && !IsIncludedNamespace(namespaceName) && AllowedNameSpace(type))
+                    {
+                        namespaces.Add(namespaceName);
+                    }
+                }
 
-            // Construct event data initialization
-            string eventData = "";
-            for (int i = 0; i < typeGroup.types.Count; i++)
-            {
-                eventData += $"Value{i} = arg{i},{(i != typeGroup.types.Count - 1 ? "\n" : "")}\t\t\t\t";
             }
 
-            // Append method body
-            scriptContent += @$"        return ({string.Join(", ", args)}) => 
-        {{
-            onUnityEvent.Trigger(reference, new EventData
-            {{  
-                {eventData}
-            }});
-        }};
-";
-            scriptContent += "    }\n\n";
-        }
-
-        scriptContent += "}\n";
+            var @namespace = NamespaceGenerator.Namespace("Unity.VisualScripting.Community.Generated");
+            var @class = ClassGenerator.Class(RootAccessModifier.Public, ClassModifier.Static, "AotSupportMethods", null, "", namespaces.ToList());
+            var processedGroups = new HashSet<TypeGroup>();
+            foreach (var typeGroup in typeGroups)
+            {
+                if (!processedGroups.Add(typeGroup))
+                    continue;
+                string methodParameters = string.Join(", ", typeGroup.types.Select(type => type.CSharpFullName(true)));
+                string methodReturnType = "UnityAction<" + methodParameters + ">";
+                var method = MethodGenerator.Method(AccessModifier.Public, MethodModifier.Static, methodReturnType, "UnityEngine.Events", string.Join("_", typeGroup.types.Select(type => type.HumanName(false).Replace(" ", ""))) + "Handler");
+                method.AddParameter(ParameterGenerator.Parameter("reference", typeof(GraphReference), ParameterModifier.None));
+                method.AddParameter(ParameterGenerator.Parameter("onUnityEvent", typeof(OnUnityEvent), ParameterModifier.None));
+                method.SetWarning($"Method generated from {typeGroup.parent.CSharpFullName()}");
+                List<string> args = new List<string>();
+                for (int i = 0; i < typeGroup.types.Count; i++)
+                {
+                    args.Add("arg" + i);
+                }
 
-        return scriptContent;
-    }
+                string eventData = "";
+                for (int i = 0; i < typeGroup.types.Count; i++)
+                {
+                    eventData += $"Value{i} = arg{i},{(i != typeGroup.types.Count - 1 ? "\n" : "")}\t\t";
+                }
 
 
-    private string CSharpName(Type type, bool lowerCase)
-    {
-        if (lowerCase)
-        {
-            if (type == null) return "null";
-            if (type == typeof(int)) return "int";
-            if (type == typeof(string)) return "string";
-            if (type == typeof(float)) return "float";
-            if (type == typeof(double)) return "double";
-            if (type == typeof(bool)) return "bool";
-            if (type == typeof(byte)) return "byte";
-            if (type == typeof(object) && type.BaseType == null) return "object";
-            if (type == typeof(object[])) return "object[]";
-
-            if (type.IsGenericType)
-            {
-                string genericTypeName = $"{type.Namespace}.{type.Name.Split('`')[0]}<{string.Join(", ", type.GetGenericArguments().Select(arg => CSharpName(arg, true)))}>";
-                return string.Concat(genericTypeName.Where(c => char.IsLetter(c) || c == '<' || c == '>' || c == '.' || c == ','));
+                var body = @$"return ({string.Join(", ", args)}) => 
+{{
+    onUnityEvent.Trigger(reference, new EventData
+    {{  
+        {eventData}
+    }});
+}};";
+                method.Body(body);
+                @class.AddMethod(method);
             }
-
-            return type.Namespace + "." + type.Name;
+            @namespace.AddClass(@class);
+            return @namespace.GenerateClean(0);
         }
-        else
+
+        private List<TypeGroup> GetTypesForAOTMethods()
         {
-            if (type == null) return "null";
-            if (type == typeof(int)) return "Int";
-            if (type == typeof(string)) return "String";
-            if (type == typeof(float)) return "Float";
-            if (type == typeof(double)) return "Double";
-            if (type == typeof(bool)) return "Bool";
-            if (type == typeof(byte)) return "Byte";
-            if (type == typeof(object) && type.BaseType == null) return type.Namespace + "Object";
-            if (type == typeof(object[])) return "ObjectArray";
-
-            string typeName = string.Concat(type.Name.Split('.').Select(word => char.ToUpper(word[0]) + word.Substring(1)));
-
-            if (type.IsGenericType)
-            {
-                typeName = typeName.Replace("`", "Generic");
-            }
+            List<TypeGroup> types = new List<TypeGroup>();
 
-            if (type.IsArray)
+            var allTypes = AppDomain.CurrentDomain.GetAssemblies().SelectMany(assembly => assembly.GetTypes().Where(type => typeof(UnityEventBase).IsAssignableFrom(type))).ToList();
+
+            int count = allTypes.Count;
+            for (int i = 0; i < count; i++)
             {
-                typeName = typeName.Replace("[]", "Array");
-            }
+                var currentType = allTypes[i];
+                var type = currentType.IsGenericType ? currentType : currentType.BaseType;
+                float progress = (float)i / count;
+
+                if (type.IsPublic
+                    && type.IsGenericType
+                    && EditorTypeUtility.IsRuntimeType(type)
+                    && type.GetGenericArguments().All(arg => EditorTypeUtility.IsClosedGeneric(arg)))
+                {
+                    EditorUtility.DisplayProgressBar("Generating Aot Support Methods for OnUnityEvent", $"Found {type.HumanName(true)}...", progress);
 
-            typeName = string.Concat(typeName.Where(c => char.IsLetterOrDigit(c) || c == '_'));
+                    types.Add(new TypeGroup(currentType, type.GetGenericArguments()));
+                }
+            }
 
-            return typeName;
+            return types;
         }
-    }
-
-    public List<TypeGroup> GetTypesForAOTMethods()
-    {
-        List<TypeGroup> types = new List<TypeGroup>();
 
-        foreach (var type in AppDomain.CurrentDomain.GetAssemblies().SelectMany(assembly => assembly.GetTypes().Where(type => type.Inherits(typeof(UnityEventBase)))))
+        private bool IsIncludedNamespace(string _namespace)
         {
-            if (type.BaseType.IsGenericType && !type.BaseType.GetGenericArguments().Any(arg => arg.IsGenericTypeParameter) && type.BaseType.GetGenericArguments().All(_type => _type.IsPublic && AllowedNameSpace(_type.Namespace)))
-            {
-                types.Add(new TypeGroup(type.BaseType.GetGenericArguments()));
-            }
+            if (string.IsNullOrEmpty(_namespace)) return false;
+            return includedNamespaces.Contains(_namespace);
         }
 
-        return types;
-    }
-
-    private bool IsIncludedNamespace(string _namespace)
-    {
-        if (string.IsNullOrEmpty(_namespace)) return false;
-        return _namespace == "System" || _namespace == "UnityEngine.Events" || _namespace == "Unity.VisualScripting" || _namespace == "Unity.VisualScripting.Community";
-    }
-
-    private bool AllowedNameSpace(string _namespace)
-    {
-        if (string.IsNullOrEmpty(_namespace)) return false;
-        if (_namespace.Contains("UnityEditor") || _namespace.Contains("NUnit")) return false;
-        return true;
-    }
-
-    public class TypeGroup : IEquatable<TypeGroup>
-    {
-        public TypeGroup(params Type[] types)
+        private bool AllowedNameSpace(Type type)
         {
-            this.types = types.ToList();
+            if (string.IsNullOrEmpty(type.Namespace)) return false;
+            var rootNamespace = type.RootNamespace();
+            if (rootNamespace == "UnityEditor" || rootNamespace == "UnityEditorInternal" ||
+            type.Namespace.Contains("UnityEditor") || type.Namespace.Contains("NUnit")) return false;
+            return true;
         }
 
-        public List<Type> types = new List<Type>();
-
-        public bool Equals(TypeGroup other)
+        private class TypeGroup : IEquatable<TypeGroup>
         {
-            if (other == null || other.types.Count != types.Count)
+            public TypeGroup(Type parent, params Type[] types)
             {
-                return false;
+                this.parent = parent;
+                this.types = types.ToList();
             }
 
-            for (int i = 0; i < types.Count; i++)
+            public Type parent;
+            public List<Type> types = new List<Type>();
+
+            public bool Equals(TypeGroup other)
             {
-                if (types[i] != other.types[i])
+                if (other == null || other.types.Count != types.Count)
                 {
                     return false;
                 }
-            }
 
-            return true;
-        }
+                for (int i = 0; i < types.Count; i++)
+                {
+                    if (types[i] != other.types[i])
+                    {
+                        return false;
+                    }
+                }
 
-        public override bool Equals(object obj)
-        {
-            if (obj is TypeGroup other)
+                return true;
+            }
+
+            public override bool Equals(object obj)
             {
-                return Equals(other);
+                if (obj is TypeGroup other)
+                {
+                    return Equals(other);
+                }
+                return false;
             }
-            return false;
-        }
 
-        public override int GetHashCode()
-        {
-            unchecked
+            public override int GetHashCode()
             {
-                int hash = 17;
-                foreach (var type in types)
+                unchecked
                 {
-                    hash = hash * 23 + type.GetHashCode();
+                    int hash = 17;
+                    foreach (var type in types)
+                    {
+                        hash = hash * 23 + type.GetHashCode();
+                    }
+                    return hash;
                 }
-                return hash;
             }
         }
     }
-}
+}