Fix assets not being saved in exporter

Disunity/Disunity.Editor/Disunity.Editor.csproj

@@ -67,6 +67,7 @@
     <Compile Include="Editors\BaseSelectionEditor.cs" />
     <Compile Include="AsyncEditorTask.cs" />
     <Compile Include="Editors\BaseAssetEditor.cs" />
+    <Compile Include="Editors\BaseSettingsAssetEditor.cs" />
     <Compile Include="Fields\BasePickerField.cs" />
     <Compile Include="Fields\ClassPickerField.cs" />
     <Compile Include="Pickers\BasePicker.cs" />

Disunity/Disunity.Editor/Editors/ArtifactEditor.cs

@@ -1,11 +1,18 @@
-using UnityEditor;
-
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor;
+using UnityEngine;
 
 namespace Disunity.Editor.Editors {
 
-    internal class ArtifactEditor : BaseAssetEditor {
+    internal class ArtifactEditor : BaseSettingsAssetEditor<Object> {
+
+        protected override IEnumerable<Object> Setting {
+            get => _settings.Artifacts;
+            set => _settings.Artifacts = value.ToArray();
+        }
 
-        public ArtifactEditor(EditorWindow window, ExportSettings settings) : base(window) { }
+        public ArtifactEditor(EditorWindow window, ExportSettings settings) : base(window, settings) { }
 
         public override string Label() {
             return "Artifacts";

Disunity/Disunity.Editor/Editors/BaseSettingsAssetEditor.cs

@@ -0,0 +1,42 @@
+using Disunity.Editor.Pickers;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor;
+using UnityEngine;
+
+namespace Disunity.Editor.Editors {
+    internal abstract class BaseSettingsAssetEditor<T> : BaseAssetEditor where T : Object {
+
+        protected readonly ExportSettings _settings;
+
+        protected abstract IEnumerable<T> Setting { get; set; }
+
+        public BaseSettingsAssetEditor(EditorWindow window, ExportSettings settings) : base(window) {
+            _settings = settings;
+        }
+
+        protected override void HandleAddition(AssetEntry addition) {
+            base.HandleAddition(addition);
+            if (Setting.All(asmDef => AssetDatabase.GetAssetPath(asmDef) != addition.Value)) {
+                Setting = 
+                    Enumerable.Concat(
+                        Setting,
+                        Enumerable.Repeat(AssetDatabase.LoadAssetAtPath<T>(addition.Value), 1))
+                    .ToArray();
+            }
+        }
+
+        protected override void HandleSubtraction(AssetEntry subtraction) {
+            base.HandleSubtraction(subtraction);
+            Setting = Setting
+                .Where(asmDef => AssetDatabase.GetAssetPath(asmDef) != subtraction.Value)
+                .ToArray();
+        }
+        public override string[] GetAssetPaths() {
+            return AssetDatabase
+                .FindAssets($"t:{typeof(T).Name}")
+                .Select(AssetDatabase.GUIDToAssetPath)
+                .ToArray();
+        }
+    }
+}

Disunity/Disunity.Editor/Editors/ExportEditor.cs

@@ -1,11 +1,9 @@
 using System;
 using System.Linq;
-using Disunity.Core;
 using Disunity.Editor.Fields;
 using UnityEditor;
+using UnityEditorInternal;
 using UnityEngine;
-using Object = UnityEngine.Object;
-
 
 namespace Disunity.Editor.Editors {
 
@@ -67,25 +65,13 @@ private void DrawDetails(ExportSettings settings) {
         }
 
         private void DrawContentWarning(ExportSettings settings) {
-
-            settings.ContentTypes = 0;
-            if (settings.PreloadAssemblies.Length > 0)
-                settings.ContentTypes |= ContentType.PreloadAssemblies;
-            if (settings.RuntimeAssemblies.Length > 0)
-                settings.ContentTypes |= ContentType.RuntimeAssemblies;
-            if (settings.Prefabs.Length > 0)
-                settings.ContentTypes |= ContentType.Prefabs;
-            if (settings.Scenes.Length > 0)
-                settings.ContentTypes |= ContentType.Scenes;
-            if (settings.Artifacts.Length > 0)
-                settings.ContentTypes |= ContentType.Artifacts;
-
+            settings.UpdateContentTypes();
             if (settings.ContentTypes == 0) {
                 throw new ExportValidationError("You must include some content in your mod.");
             }
         }
 
-        private void DrawStartupSelector(ClassPickerField field, Object[] assemblies, string currentClass, string currentAssembly, Action<string, string> handler, string labelText) {
+        private void DrawStartupSelector(ClassPickerField field, AssemblyDefinitionAsset[] assemblies, string currentClass, string currentAssembly, Action<string, string> handler, string labelText) {
             if (assemblies.Length == 0) {
                 return;
             }

Disunity/Disunity.Editor/Editors/PrefabEditor.cs

@@ -1,12 +1,18 @@
-using System.Linq;
+using System.Collections.Generic;
+using System.Linq;
 using UnityEditor;
-
+using UnityEngine;
 
 namespace Disunity.Editor.Editors {
 
-    internal class PrefabEditor : BaseAssetEditor {
+    internal class PrefabEditor : BaseSettingsAssetEditor<GameObject> {
+
+        protected override IEnumerable<GameObject> Setting {
+            get => _settings.Prefabs;
+            set => _settings.Prefabs = value.ToArray();
+        }
 
-        public PrefabEditor(EditorWindow window) : base(window) { }
+        public PrefabEditor(EditorWindow window, ExportSettings settings) : base(window, settings) { }
 
         public override string Label() {
             return "Prefabs";
@@ -31,12 +37,5 @@ ScriptableObjects are non-Scene-objects which can contain data. This is useful
 but due to a limitation in how Unity serializes information, only basic types
 like strings, ints, floats, and basic arrays will work.";
         }
-
-        public override string[] GetAssetPaths() {
-            return AssetDatabase
-                .FindAssets("t:GameObject t:ScriptableObject")
-                .Select(AssetDatabase.GUIDToAssetPath)
-                .ToArray();
-        }
     }
 }

Disunity/Disunity.Editor/Editors/PreloadAssemblyEditor.cs

@@ -1,12 +1,19 @@
-using System.Linq;
+using System.Collections.Generic;
+using System.Linq;
 using UnityEditor;
-
+using UnityEditorInternal;
+using UnityEngine;
 
 namespace Disunity.Editor.Editors {
 
-    internal class PreloadAssemblyEditor : BaseAssetEditor {
+    internal class PreloadAssemblyEditor : BaseSettingsAssetEditor<AssemblyDefinitionAsset> {
+
+        protected override IEnumerable<AssemblyDefinitionAsset> Setting {
+            get => _settings.PreloadAssemblies;
+            set => _settings.PreloadAssemblies = value.ToArray();
+        }
 
-        public PreloadAssemblyEditor(EditorWindow window, ExportSettings settings) : base(window) { }
+        public PreloadAssemblyEditor(EditorWindow window, ExportSettings settings) : base(window, settings) { }
 
         public override string Label() {
             return "Preload";
@@ -32,12 +39,5 @@ Preload assemblies are defined by a Unity Assembly Definition
 <b>Assets -> Create -> Assembly Definition</b> menu.
 ";
         }
-
-        public override string[] GetAssetPaths() {
-            return AssetDatabase
-                .FindAssets("t:AssemblyDefinitionAsset")
-                .Select(AssetDatabase.GUIDToAssetPath)
-                .ToArray();
-        }
     }
 }

Disunity/Disunity.Editor/Editors/RuntimeAssemblyEditor.cs

@@ -1,12 +1,19 @@
-using System.Linq;
+using System.Collections.Generic;
+using System.Linq;
 using UnityEditor;
-
+using UnityEditorInternal;
+using UnityEngine;
 
 namespace Disunity.Editor.Editors {
 
-    internal class RuntimeAssemblyEditor : BaseAssetEditor {
+    internal class RuntimeAssemblyEditor : BaseSettingsAssetEditor<AssemblyDefinitionAsset> {
+
+        protected override IEnumerable<AssemblyDefinitionAsset> Setting {
+            get => _settings.RuntimeAssemblies;
+            set => _settings.RuntimeAssemblies = value.ToArray();
+        }
 
-        public RuntimeAssemblyEditor(EditorWindow window, ExportSettings settings) : base(window) { }
+        public RuntimeAssemblyEditor(EditorWindow window, ExportSettings settings) : base(window, settings) { }
 
         public override string Label() {
             return "Scripts";
@@ -32,13 +39,5 @@ Runtime assemblies are defined by a Unity Assembly Definition
 Asset. These can be created using the 
 <b>Assets -> Create -> Assembly Definition</b> menu.";
         }
-
-        public override string[] GetAssetPaths() {
-            return AssetDatabase
-                .FindAssets("t:AssemblyDefinitionAsset")
-                .Select(AssetDatabase.GUIDToAssetPath)
-                .ToArray();
-        }
-
     }
 }

Disunity/Disunity.Editor/Editors/SceneEditor.cs

@@ -1,12 +1,17 @@
-using System.Linq;
+using System.Collections.Generic;
+using System.Linq;
 using UnityEditor;
 
-
 namespace Disunity.Editor.Editors {
 
-    internal class SceneEditor : BaseAssetEditor {
+    internal class SceneEditor : BaseSettingsAssetEditor<SceneAsset> {
+
+        protected override IEnumerable<SceneAsset> Setting {
+            get => _settings.Scenes;
+            set => _settings.Scenes = value.ToArray();
+        }
 
-        public SceneEditor(EditorWindow window, ExportSettings settings) : base(window) { }
+        public SceneEditor(EditorWindow window, ExportSettings settings) : base(window, settings) { }
 
         public override string Label() {
             return "Scenes";
@@ -19,11 +24,5 @@ public override string Title() {
         public override string Help() {
             return "Scenes can be exported to your mod here.";
         }
-        public override string[] GetAssetPaths() {
-            return AssetDatabase
-                .FindAssets("t:Scene")
-                .Select(AssetDatabase.GUIDToAssetPath)
-                .ToArray();
-        }
     }
 }

Disunity/Disunity.Editor/Export.cs

@@ -2,12 +2,10 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Security.Cryptography;
 using Disunity.Core;
 using UnityEditor;
+using UnityEditorInternal;
 using UnityEngine;
-using Object = System.Object;
-
 
 namespace Disunity.Editor {
 
@@ -52,7 +50,7 @@ private void CreateTempDirectory() {
             Directory.CreateDirectory(_tempModDirectory);
         }
 
-        private List<string> ExportAssemblies(UnityEngine.Object[] assemblies, string folder) {
+        private List<string> ExportAssemblies(AssemblyDefinitionAsset[] assemblies, string folder) {
             var destinations = new List<string>();
             if (assemblies.Length == 0) return destinations;
             var destinationPath = Path.Combine(_tempModDirectory, folder);
@@ -79,22 +77,6 @@ private List<string> ExportAssemblies(UnityEngine.Object[] assemblies, string fo
             return destinations;
         }
 
-        private void SetContentTypes() {
-            _settings.ContentTypes = 0;
-            if (_settings.PreloadAssemblies.Length > 0) {
-                _settings.ContentTypes |= ContentType.PreloadAssemblies;
-            }
-            if (_settings.RuntimeAssemblies.Length > 0) {
-                _settings.ContentTypes |= ContentType.RuntimeAssemblies;
-            }
-            if (_settings.Prefabs.Length > 0) {
-                _settings.ContentTypes |= ContentType.Prefabs;
-            }
-            if (_settings.Scenes.Length > 0) {
-                _settings.ContentTypes |= ContentType.Scenes;
-            }
-        }
-
         private List<string> ExportRuntimeAssemblies() {
             return ExportAssemblies(_settings.RuntimeAssemblies, "runtime");
         }
@@ -162,7 +144,7 @@ public void Run() {
             var runtimeAssemblies = ExportRuntimeAssemblies();
             ExportCopyAssets();
             ExportModAssets();
-            SetContentTypes();
+            _settings.UpdateContentTypes();
             SaveMetadata(preloadAssemblies, runtimeAssemblies);
             CopyToOutput();
         }

Disunity/Disunity.Editor/ExportSettings.cs

@@ -1,11 +1,11 @@
 using Disunity.Core;
+using UnityEditor;
+using UnityEditorInternal;
 using UnityEngine;
 
-
 namespace Disunity.Editor {
 
     public class ExportSettings : ScriptableObject {
-
         /// <summary>
         ///     The Mod's name.
         /// </summary>
@@ -29,13 +29,13 @@ public class ExportSettings : ScriptableObject {
         /// <summary>
         ///     The directory to which the Mod will be exported.
         /// </summary>
-        [field: SerializeField] public Object[] PreloadAssemblies { get; set; } = { };
+        [field: SerializeField] public AssemblyDefinitionAsset[] PreloadAssemblies { get; set; } = { };
 
-        [field: SerializeField] public Object[] RuntimeAssemblies { get; set; } = { };
+        [field: SerializeField] public AssemblyDefinitionAsset[] RuntimeAssemblies { get; set; } = { };
 
         [field: SerializeField] public Object[] Artifacts { get; set; } = { };
-        [field: SerializeField] public Object[] Prefabs { get; set; } = { };
-        [field: SerializeField] public Object[] Scenes { get; set; } = { };
+        [field: SerializeField] public GameObject[] Prefabs { get; set; } = { };
+        [field: SerializeField] public SceneAsset[] Scenes { get; set; } = { };
 
         [field: SerializeField] public string OutputDirectory { get; set; }
 
@@ -49,6 +49,25 @@ public class ExportSettings : ScriptableObject {
 
         [field: SerializeField] public string PreloadAssembly { get; set; }
 
+        public void UpdateContentTypes() {
+            ContentTypes = 0;
+            if (PreloadAssemblies.Length > 0) {
+                ContentTypes |= ContentType.PreloadAssemblies;
+            }
+            if (RuntimeAssemblies.Length > 0) {
+                ContentTypes |= ContentType.RuntimeAssemblies;
+            }
+            if (Prefabs.Length > 0) {
+                ContentTypes |= ContentType.Prefabs;
+            }
+            if (Scenes.Length > 0) {
+                ContentTypes |= ContentType.Scenes;
+            }
+            if (Artifacts.Length > 0) {
+                ContentTypes |= ContentType.Artifacts;
+            }
+        }
+
     }
 
 }

Disunity/Disunity.Editor/ExporterEditorWindow.cs

@@ -37,7 +37,7 @@ private void OnEnable() {
             _runtimeAssemblyEditor = new RuntimeAssemblyEditor(this, _exportSettings.Instance);
             _preloadAssemblyEditor = new PreloadAssemblyEditor(this, _exportSettings.Instance);
             _artifactEditor = new ArtifactEditor(this, _exportSettings.Instance);
-            _prefabEditor = new PrefabEditor(this);
+            _prefabEditor = new PrefabEditor(this, _exportSettings.Instance);
             _sceneEditor = new SceneEditor(this, _exportSettings.Instance);
             _exportEditor = new ExportEditor(this, _exportSettings.Instance);
             _dependencyEditor = new DependencyEditor(this);
@@ -47,6 +47,7 @@ private void OnEnable() {
             _editorSelector.AddEditor(_sceneEditor);
             _editorSelector.AddEditor(_preloadAssemblyEditor);
             _editorSelector.AddEditor(_dependencyEditor);
+            _editorSelector.AddEditor(_artifactEditor);
             _editorSelector.AddEditor(_exportEditor);
         }