gg.easy.airship 0.1.2189 → 0.1.2190

package/Editor/AirshipComponentBuildImporter.cs

@@ -1,5 +1,8 @@
-using System.IO;
+using System;
+using System.IO;
+using System.Linq;
 using Luau;
+using UnityEditor;
 using UnityEditor.AssetImporters;
 using UnityEngine;
 
@@ -18,4 +21,13 @@ namespace Editor {
             ctx.SetMainObject(airshipBuild);
         }
     }
+
+    public class AirshipTypePostProcessor : AssetPostprocessor {
+        private static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets,
+            string[] movedFromAssetPaths) {
+            if (importedAssets.Contains(AirshipBuildInfo.PrimaryAssetPath)) {
+                AirshipCustomEditors.RegisterEditorsForRegisteredTypes();
+            }
+        }
+    }
 }

package/Editor/AirshipComponentEditor.cs

@@ -39,6 +39,8 @@ public class ScriptBindingEditor : UnityEditor.Editor {
     /** Maps (game object id, prop name) to ArrayDisplayInfo object (for Array properties) */
     private Dictionary<(int componentInstanceId, string propertyName), ArrayDisplayInfo> _reorderableLists = new();
 
+    private AirshipEditor editor;
+    
     public void OnEnable() {
         var comp = (Component)serializedObject.targetObject;
         var metadata = serializedObject.FindProperty("metadata");
@@ -50,6 +52,16 @@ public class ScriptBindingEditor : UnityEditor.Editor {
             var listPropType = LuauMetadataPropertySerializer.GetAirshipComponentPropertyTypeFromString(arrayType, false);
             GetOrCreateArrayDisplayInfo(comp.GetInstanceID(), serializedProperty, serializedProperty.FindPropertyRelative("name").stringValue, listPropType, itemInfo);
         }
+        
+        AirshipComponent binding = (AirshipComponent)target;
+        if (binding.script != null && binding.metadata != null) {
+            var customEditorType = AirshipCustomEditors.GetEditorTypeForTypeName(binding.metadata.name);
+            
+            if (customEditorType != null && AirshipCustomEditors.TryGetEditorForComponent(binding, customEditorType, out var editor)) {
+                editor.OnEnable();
+                this.editor = editor;
+            }
+        }
     }
 
     private void OnDisable() {
@@ -58,24 +70,89 @@ public class ScriptBindingEditor : UnityEditor.Editor {
         
         var componentInstanceId = comp.GetInstanceID();
         _componentSeenArrayProps.Remove(componentInstanceId);
+        
+        AirshipComponent binding = (AirshipComponent)target;
+        if (binding.script != null && binding.metadata != null) {
+            var customEditorType = AirshipCustomEditors.GetEditorTypeForTypeName(binding.metadata.name);
+            if (customEditorType != null) {
+                var editor = AirshipCustomEditors.GetEditorForComponent(binding, customEditorType, serializedObject);
+                editor.OnDisable();
+            }
+
+            this.editor = null;
+        }
+    }
+
+    private void OnDestroy() {
+        AirshipComponent binding = (AirshipComponent)target;
+        AirshipCustomEditors.DestroyEditor(binding);
     }
 
     private bool debugging = false;
-    
-    public override void OnInspectorGUI() {
-        serializedObject.Update();
 
-        AirshipComponent binding = (AirshipComponent)target;
+    private void OnSceneGUI() {
+        if (!AirshipCustomEditors.UseNewInspector) return;
+        if (!this.editor) return;
+        this.editor.OnSceneGUI();
+    }
 
-        if (binding.script == null && !string.IsNullOrEmpty(binding.scriptPath)) {
-            // Debug.Log("Setting Script File from Path: " + binding.scriptPath);
-            // binding.SetScriptFromPath(binding.scriptPath, LuauContext.Game);
-            if (binding.script == null) {
-                Debug.LogWarning($"Failed to load script asset: {binding.scriptPath}");
-                EditorGUILayout.HelpBox("Missing reference. This is likely from renaming a script.\n\nOld path: " + binding.scriptPath.Replace("Assets/Bundles/", ""), MessageType.Warning);
+    public override void OnPreviewGUI(Rect r, GUIStyle background) {
+        if (!AirshipCustomEditors.UseNewInspector) return;
+        if (!this.editor) return;
+        this.editor.OnPreviewGUI(r, background);
+    }
+
+    public override bool HasPreviewGUI() {
+        if (!AirshipCustomEditors.UseNewInspector) return false;
+        return this.editor != null ? this.editor.HasPreviewGUI() : false;
+    }
+
+    private bool OnAirshipInspectorGUI() {
+        if (!AirshipCustomEditors.UseNewInspector) return false;
+        
+        AirshipComponent binding = (AirshipComponent)target;
+        
+        Type customEditorType = null;
+        if (binding.script != null && binding.metadata != null) {
+            customEditorType = AirshipCustomEditors.GetEditorTypeForTypeName(binding.metadata.name);
+        }
+        
+        if (customEditorType != null && binding.script != null) {
+            var metadata = serializedObject.FindProperty("metadata");
+            var metadataName = metadata.FindPropertyRelative("name");
+            
+            if (binding.script != null && binding.script.m_metadata != null) {
+                if (ShouldReconcile(binding)) {
+                    binding.ReconcileMetadata(ReconcileSource.Inspector);
+                    serializedObject.ApplyModifiedProperties();
+                    serializedObject.Update();
+                }
+            
+                CheckDefaults(binding);
             }
+            
+            if (!string.IsNullOrEmpty(metadataName.stringValue)) {
+                var componentEditor = AirshipCustomEditors.GetEditorForComponent(binding, customEditorType, serializedObject);
+                if (this.editor == null) this.editor = componentEditor;
+                componentEditor.script = binding.script;
+                componentEditor.target = binding;
+                componentEditor.OnInspectorGUI();
+            }
+            
+            serializedObject.ApplyModifiedProperties();
+            
+            if (Application.isPlaying) {
+                var component = (AirshipComponent)target;
+                component.WriteChangedComponentProperties();
+            }
+            return true;
         }
 
+        return false;
+    }
+
+    private void OnAirshipLegacyInspectorGUI() {
+        AirshipComponent binding = (AirshipComponent)target;
         DrawScriptBindingProperties(binding);
 
         if (binding.script != null && binding.script.m_metadata != null) {
@@ -115,6 +192,23 @@ public class ScriptBindingEditor : UnityEditor.Editor {
         serializedObject.ApplyModifiedProperties();
     }
 
+    public override void OnInspectorGUI() {
+        serializedObject.Update();
+
+        AirshipComponent binding = (AirshipComponent)target;
+
+        if (binding.script == null && !string.IsNullOrEmpty(binding.scriptPath)) {
+            if (binding.script == null) {
+                Debug.LogWarning($"Failed to load script asset: {binding.scriptPath}");
+                EditorGUILayout.HelpBox("Missing reference. This is likely from renaming a script.\n\nOld path: " + binding.scriptPath.Replace("Assets/Bundles/", ""), MessageType.Warning);
+            }
+        }
+        
+        if (!OnAirshipInspectorGUI()) {
+            OnAirshipLegacyInspectorGUI();
+        }
+    }
+
 
     private Dictionary<int, HashSet<string>> _componentSeenArrayProps = new();
     private void CleanupOrphanedArrayDisplayInfos(int componentInstanceId) {
@@ -145,8 +239,6 @@ public class ScriptBindingEditor : UnityEditor.Editor {
     }
     
     private ArrayDisplayInfo GetOrCreateArrayDisplayInfo(int componentInstanceId, SerializedProperty arraySerializedProperty, string propName, AirshipComponentPropertyType listType, SerializedProperty itemInfo) {
-        
-        
         Type objType = null;
         if (listType == AirshipComponentPropertyType.AirshipObject || listType == AirshipComponentPropertyType.AirshipComponent) {
             objType = TypeReflection.GetTypeFromString(itemInfo.FindPropertyRelative("objectType").stringValue);
@@ -861,7 +953,7 @@ public class ScriptBindingEditor : UnityEditor.Editor {
                 var objOld = objectRefs.arraySize > index ? objectRefs.GetArrayElementAtIndex(index).objectReferenceValue : null;
 
                 if (objectType == typeof(Sprite) || objectType == typeof(Texture2D)) {
-                    var objNew = AirshipEditorGUI.ObjectField(rect, new GUIContent(label), objOld, objectType, true);
+                    var objNew = AirshipEditorGUI.ObjectField(rect, new GUIContent(label), objOld, objectType, true, false);
                     if (objOld != objNew) {
                         objectRefs.GetArrayElementAtIndex(index).objectReferenceValue = objNew;
                         arrayModified.boolValue = true;
@@ -1286,7 +1378,7 @@ public class ScriptBindingEditor : UnityEditor.Editor {
 
         UnityEngine.Object newObject;
         if (t == typeof(Sprite) || t == typeof(Texture2D)) {
-            newObject = AirshipEditorGUI.ObjectFieldLayout(guiContent, currentObject, t, true);
+            newObject = AirshipEditorGUI.ObjectFieldLayout(guiContent, currentObject, t, true, false);
         } else {
             newObject = EditorGUILayout.ObjectField(guiContent, currentObject, t, true);
         }

package/Editor/AirshipEditors/AirshipCustomEditors.cs

@@ -0,0 +1,319 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+using TypescriptAst;
+using Luau;
+using UnityEditor;
+using UnityEngine;
+using Object = UnityEngine.Object;
+
+/// <summary>
+/// The custom editor namespace for the Airship Editor
+/// </summary>
+public static class AirshipCustomEditors {
+    /// <summary>
+    /// Contains information about the custom Airship editor
+    /// </summary>
+    internal class CustomEditorInfo {
+        public Type EditorType { get; }
+        public AirshipType AirshipType { get; }
+        public CustomAirshipEditorAttribute EditorAttribute { get; }
+        public CustomEditorInfo(Type editorType, AirshipType airshipType, CustomAirshipEditorAttribute editorAttribute) {
+            EditorType = editorType;
+            EditorAttribute = editorAttribute;
+            AirshipType = airshipType;
+        }
+    }
+    
+    #region Fields
+    private static Dictionary<AirshipType, CustomEditorInfo> airshipTypeToCustomEditor = new();
+    private static Dictionary<int, AirshipEditor> instanceToAirshipEditor = new();
+    
+    private static Dictionary<Type, AirshipPropertyDecorator> typeToEditorPropertyDecorator = new();
+    private static Dictionary<string, Type> decoratorNameToEditorType = new();
+    
+    internal const string inspectorModeKey = "AirshipBetaInspectorMode";
+    internal const EditorInspectorMode DefaultInspectorMode = EditorInspectorMode.UseLegacyInspector;
+    #endregion
+    
+    #region Properties
+    /// <summary>
+    /// A list of the active custom editors
+    /// </summary>
+    internal static IEnumerable<CustomEditorInfo> CustomEditors {
+        get => airshipTypeToCustomEditor.Values;
+    }
+
+    /// <summary>
+    /// A list of all the active airship editors (includes the default inspectors)
+    /// </summary>
+    internal static IEnumerable<AirshipEditor> AllEditors {
+        get => instanceToAirshipEditor.Values;
+    }
+    
+    internal static EditorInspectorMode UserInspectorMode {
+        get {
+            var value = (EditorInspectorMode) EditorPrefs.GetInt(inspectorModeKey, (int) EditorInspectorMode.Default);
+            return value;
+        }
+        set {
+            var current = (EditorInspectorMode) EditorPrefs.GetInt(inspectorModeKey, (int) EditorInspectorMode.Default);
+            if (value == current) return;
+            
+            if (value == EditorInspectorMode.UseLegacyInspector) {
+                instanceToAirshipEditor.Clear();
+                airshipTypeToCustomEditor.Clear();
+            } else if (value == EditorInspectorMode.UseNewInspector || (value == EditorInspectorMode.Default &&
+                                                                        DefaultInspectorMode ==
+                                                                        EditorInspectorMode.UseNewInspector)) {
+                RegisterEditorsForRegisteredTypes();
+            }
+            
+            EditorPrefs.SetInt(inspectorModeKey, (int) value);
+        }
+    }
+    
+    internal static bool UseNewInspector {
+        get {
+            var inspector = UserInspectorMode;
+            if (inspector == EditorInspectorMode.Default) inspector = DefaultInspectorMode;
+            return inspector == EditorInspectorMode.UseNewInspector;
+        }
+    }
+    
+    #endregion
+    
+    #region Editor Registration Methods
+    
+    private static bool RegisterEditor(Type editorType, CustomAirshipEditorAttribute editorAttribute) {
+        var typeName = editorAttribute.TypeName;
+        var filePath = editorAttribute.FilePath;
+                
+        var pathType = string.IsNullOrEmpty(filePath) ? 
+            AirshipBuildInfo.Instance.GetTypeByName(typeName) :  
+            AirshipBuildInfo.Instance.GetTypeByPathAndName(filePath, typeName);
+                
+        if (pathType == null) {
+            return false;
+        }
+                
+        if (!AirshipCustomEditors.airshipTypeToCustomEditor.TryGetValue(pathType, out var _)) {
+            AirshipCustomEditors.airshipTypeToCustomEditor.Add(pathType, new CustomEditorInfo(editorType, pathType, editorAttribute));
+        }
+
+        return true;
+    }
+    
+    internal static void RegisterEditorsForRegisteredTypes() {
+        airshipTypeToCustomEditor.Clear();
+        decoratorNameToEditorType.Clear();
+        typeToEditorPropertyDecorator.Clear();
+        instanceToAirshipEditor.Clear();
+
+        var typeEditorAttributes = TypeCache.GetTypesWithAttribute<CustomAirshipEditorAttribute>();
+        
+        foreach (var editorType in typeEditorAttributes) {
+            var internalAttr = editorType.GetCustomAttribute<CustomAirshipCoreEditorAttribute>();
+            if (internalAttr != null) {
+                RegisterEditor(editorType, internalAttr);
+                continue;
+            }
+            
+            var attr = editorType.GetCustomAttribute<CustomAirshipEditorAttribute>();
+            RegisterEditor(editorType, attr);
+        }
+
+        var decoratorStatements = new List<IStatement>();
+
+        var decoratorAttributes = TypeCache.GetTypesWithAttribute<CustomAirshipDecoratorAttribute>();
+        foreach (var decoratorAttributeType in decoratorAttributes) {
+            var attr = decoratorAttributeType.GetCustomAttribute<CustomAirshipDecoratorAttribute>();
+            decoratorNameToEditorType.Add(attr.Name, decoratorAttributeType);
+            
+            var propertyDecorator = (AirshipPropertyDecorator)ScriptableObject.CreateInstance(decoratorAttributeType);
+            propertyDecorator.attribute = attr;
+            typeToEditorPropertyDecorator.Add(decoratorAttributeType, propertyDecorator);
+
+            var decoratorParams = propertyDecorator.GetFunctionDeclaration();
+            if (decoratorParams != null) {
+                decoratorStatements.Add(new TsComment() { IsJsDoc = true, Text = $"Generated editor decorator '{attr.Name}' from {decoratorAttributeType.FullName}" });
+                decoratorStatements.Add(decoratorParams);
+            }
+        }
+        
+        if (decoratorStatements.Count > 0) {
+            var sourceFile = new TsSourceFile() {
+                Statements = decoratorStatements.ToArray(),
+            };
+            
+            File.WriteAllText("Assets/decorators.d.ts", sourceFile.ToString());
+        } else if (File.Exists("Assets/decorators.d.ts")) {
+            File.Delete("Assets/decorators.d.ts");
+        }
+        
+#if AIRSHIP_INTERNAL
+        Debug.Log($"Registered {airshipTypeToCustomEditor.Count} custom editors, {decoratorNameToEditorType.Count} decorators.");
+#endif
+    }
+
+    [InitializeOnLoadMethod]
+    internal static void InitializeEditorSymbols() {
+        string currentDefines = PlayerSettings.GetScriptingDefineSymbols(
+            UnityEditor.Build.NamedBuildTarget.FromBuildTargetGroup(EditorUserBuildSettings.selectedBuildTargetGroup));
+        
+        HashSet<string> defines = new HashSet<string>(currentDefines.Split(';')) {
+            "AIRSHIP_EDITOR_API"
+        };
+        string newDefines = string.Join(";", defines);
+        
+        if (newDefines != currentDefines) {
+            PlayerSettings.SetScriptingDefineSymbols(
+                UnityEditor.Build.NamedBuildTarget.FromBuildTargetGroup(EditorUserBuildSettings.selectedBuildTargetGroup), newDefines);
+        }
+    }
+    
+    [InitializeOnLoadMethod]
+    internal static void RegisterCustomEditors() {
+        RegisterEditorsForRegisteredTypes();
+
+        EditorApplication.playModeStateChanged += change => {
+            if (change == PlayModeStateChange.ExitingEditMode || change == PlayModeStateChange.EnteredPlayMode) {
+                RegisterEditorsForRegisteredTypes();
+            }
+        };
+    }
+    
+    #endregion
+    
+    #region Custom Editor Query Methods
+    
+    /// <summary>
+    /// Gets all editors of the given custom editor info
+    /// </summary>
+    /// <param name="editorInfo">The custom editor to grab the editors from</param>
+    /// <returns>A list of Airship editors that match the given custom editor</returns>
+    internal static IEnumerable<AirshipEditor> GetEditors(CustomEditorInfo editorInfo) {
+        var instances = new List<AirshipEditor>();
+        foreach (var instance in instanceToAirshipEditor) {
+            if (instance.Value.GetType() == editorInfo.EditorType) instances.Add(instance.Value);
+        }
+
+        return instances;
+    }
+    
+    internal static Type GetEditorTypeForTypeName(string typeName) {
+        if (!UseNewInspector) return null;
+        
+        var pathType = AirshipBuildInfo.Instance.GetTypeByName(typeName);
+        if (pathType == null) return null;
+        
+        if (airshipTypeToCustomEditor.TryGetValue(pathType, out var editorType)) {
+            return editorType.EditorType;
+        }
+
+        return typeof(DefaultAirshipComponentEditor);
+    }
+
+    internal static bool TryGetEditorForComponent(AirshipComponent component, Type type, out AirshipEditor editor) {
+        return instanceToAirshipEditor.TryGetValue(component.GetInstanceID(), out editor);
+    }
+    
+    internal static AirshipEditor GetEditorForComponent(AirshipComponent component, Type type, SerializedObject serializedObject) {
+        if (instanceToAirshipEditor.TryGetValue(component.GetInstanceID(), out var editor)) {
+            editor.serializedObject ??= new AirshipSerializedObject();
+            editor.serializedObject.Update(editor, serializedObject, component.script.m_metadata);
+            return editor;
+        }
+
+        editor = (AirshipEditor) ScriptableObject.CreateInstance(type);
+        editor.serializedObject ??= new AirshipSerializedObject();
+        editor.serializedObject.Update(editor, serializedObject, component.script.m_metadata);
+        instanceToAirshipEditor.Add(component.GetInstanceID(), editor);
+        return editor;
+    }
+
+
+    internal static AirshipEditor GetComponentEditorForType(AirshipType airshipType, AirshipComponent component, AirshipSerializedObject serializedObject) {
+        if (!airshipType.AirshipBehaviour) return null;
+        var editorType = AirshipCustomEditors.GetEditorTypeForTypeName(airshipType.Name);
+        var editor = AirshipCustomEditors.GetEditorForComponent(component, editorType, serializedObject);
+        return editor;
+    }
+
+    /// <summary>
+    /// Get an AirshipEditor for the given serialized property - can be used to embed inline
+    /// </summary>
+    /// <param name="value"></param>
+    /// <returns></returns>
+    internal static AirshipEditor GetEditor(AirshipSerializedProperty value) {
+        if (!value.isAirshipType) return null;
+
+        var component = value.objectReferenceValue;
+        if (component == null) return null;
+        
+        if (component is AirshipComponent airshipComponent) {
+            return GetEditor(airshipComponent);
+        };
+        
+        // TODO: In future we'll support Serializable objects & ScriptableObjects through here too.
+        return null;
+    }
+    
+    /// <summary>
+    /// Gets the editor's property decorator for the given luau property decorator
+    /// </summary>
+    /// <param name="decorator"></param>
+    /// <param name="propertyDecorator"></param>
+    /// <returns></returns>
+    internal static bool TryGetDecorator(LuauMetadataDecoratorElement decorator, out AirshipPropertyDecorator propertyDecorator) {
+        if (decoratorNameToEditorType.TryGetValue(decorator.name, out var decoratorType)) {
+            if (!typeToEditorPropertyDecorator.TryGetValue(decoratorType, out propertyDecorator)) {
+                propertyDecorator = (AirshipPropertyDecorator)ScriptableObject.CreateInstance(decoratorType);
+                typeToEditorPropertyDecorator.Add(decoratorType, propertyDecorator);
+            }
+            
+            return true;
+        }
+
+        propertyDecorator = default;
+        return false;
+    }
+
+    /// <summary>
+    /// Get the editor for the given AirshipComponent
+    /// </summary>
+    /// <param name="component">The component to get the editor for</param>
+    /// <returns>The editor, if it exists otherwise null</returns>
+    public static AirshipEditor GetEditor(AirshipComponent component) {
+        if (component != null && component.script != null) {
+            var airshipType = component.GetAirshipType();
+            
+            var serializedObject = new AirshipSerializedObject();
+            serializedObject.Update(null, new SerializedObject(component), component.metadata);
+            
+            return GetComponentEditorForType(airshipType, component, serializedObject);
+        }
+
+        return null;
+    }
+    
+    #endregion
+    
+    private static void DestroyEditor(int editorId) {
+        if (instanceToAirshipEditor.TryGetValue(editorId, out var editor)) {
+            instanceToAirshipEditor.Remove(editorId);
+            Object.DestroyImmediate(editor);
+        }
+    }
+
+    /// <summary>
+    /// Destroy the editor for the given airship component
+    /// </summary>
+    /// <param name="component">The airship component</param>
+    internal static void DestroyEditor(AirshipComponent component) {
+        if (component.script != null && component.metadata != null && !component) {
+            DestroyEditor(component.GetInstanceID());
+        }
+    }
+}

package/Editor/AirshipEditors/AirshipCustomEditors.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: a116e7f80e094234913b006e1a0ed2e9
+timeCreated: 1759552753