feat: Made possible to inherit from simple ScriptableObject instead of GenericScriptableObject to create generic assets

SolidAlloy · SolidAlloy · commit 0c4ac2d9b1b6 · 2022-06-19T15:57:51.000+03:00
diff --git a/.GenericUnityInternals/GenericUnityEditorInternals/GenericTypeHelper.cs b/.GenericUnityInternals/GenericUnityEditorInternals/GenericTypeHelper.cs
@@ -34,15 +34,15 @@ public static Type GetConcreteType(Type genericType)
                     : genericType;
             }
 
-            if (typeof(GenericScriptableObject).IsAssignableFrom(genericType))
+            if (typeof(ScriptableObject).IsAssignableFrom(genericType))
             {
                 return ScriptableObjectsDatabase.TryGetConcreteType(genericType, out Type concreteType)
                     ? concreteType
                     : genericType;
             }
 
             throw new ArgumentException(
-                $"Expected a type derived from MonoBehaviour or GenericScriptableObject. Got {genericType} instead.");
+                $"Expected a type derived from MonoBehaviour or ScriptableObject. Got {genericType} instead.");
         }
     }
 }
diff --git a/.GenericUnityInternals/GenericUnityEditorInternals/GenericUnityEventDrawer.cs b/.GenericUnityInternals/GenericUnityEditorInternals/GenericUnityEventDrawer.cs
@@ -296,7 +296,7 @@ public static string GetTypeName(Object unityObject, bool onlyShort)
                 {
                     shortName = unityObject is MonoBehaviour
                         ? GetBehaviourShortName(unityObjectType)
-                        : GetScriptableObjectShortName(unityObject, unityObjectType);
+                        : GetScriptableObjectShortName(unityObjectType);
 
                     _typeNameCache.Add(unityObjectType, shortName);
                 }
@@ -320,9 +320,9 @@ private static string GetBehaviourShortName(Type unityObjectType)
                     componentAttribute.componentMenu.Split('/').Last();
             }
 
-            private static string GetScriptableObjectShortName(Object unityObject, Type unityObjectType)
+            private static string GetScriptableObjectShortName(Type unityObjectType)
             {
-                return unityObject is GenericScriptableObject ? TypeUtility.GetNiceNameOfGenericType(unityObjectType.BaseType) : unityObjectType.Name;
+                return ((unityObjectType is GenericScriptableObject) || unityObjectType.BaseType.IsGenericType) ? TypeUtility.GetNiceNameOfGenericType(unityObjectType.BaseType) : unityObjectType.Name;
             }
         }
     }
diff --git a/Editor/Drawers/CreatableObjectDrawer.cs b/Editor/Drawers/CreatableObjectDrawer.cs
@@ -4,8 +4,8 @@
     using System.IO;
     using System.Reflection;
     using ScriptableObjects;
-    using SolidUtilities.Editor;
     using SolidUtilities;
+    using SolidUtilities.Editor;
     using SolidUtilities.UnityEditorInternals;
     using UnityEditor;
     using UnityEngine;
@@ -66,7 +66,7 @@ private ScriptableObject CreateAsset(SerializedProperty property, Type type)
         {
             var folderPath = ProjectWindowUtilProxy.GetActiveFolderPath();
 
-            bool isGeneric = type.InheritsFrom(typeof(GenericScriptableObject));
+            bool isGeneric = type.InheritsFrom(typeof(ScriptableObject)) && type.IsGenericType && !type.IsAbstract;
 
             string fileName = isGeneric
                 ? type.GetCustomAttribute<CreateGenericAssetMenuAttribute>()?.FileName
diff --git a/Editor/Drawers/GenericHeaderUtility.cs b/Editor/Drawers/GenericHeaderUtility.cs
@@ -9,7 +9,7 @@
     using Object = UnityEngine.Object;
 
     /// <summary>
-    /// An extension of Editor that changes name of <see cref="GenericScriptableObject"/> assets in the Inspector header.
+    /// An extension of Editor that changes name of generic <see cref="ScriptableObject"/> assets in the Inspector header.
     /// For all other assets, it draws header like before.
     /// </summary>
     public static class GenericHeaderUtility
@@ -91,7 +91,7 @@ private static string GetMixedTitle(Type genericType, Object[] targets)
         {
             if (genericType?.IsGenericType != true)
                 return targets.Length + " " + ObjectNames.NicifyVariableName(GetTypeName(targets[0])) + "s";
-            
+
             return $"{targets.Length} objects of type {GetGenericTypeName(genericType)}";
         }
 
diff --git a/Editor/Drawers/GenericUnityObjectDrawer.cs b/Editor/Drawers/GenericUnityObjectDrawer.cs
@@ -14,8 +14,8 @@ public override void OnGUI(Rect position, SerializedProperty property, GUIConten
             GenericObjectDrawer.ObjectField(position, property, label);
         }
     }
-    
-    [CustomPropertyDrawer(typeof(GenericScriptableObject), true)]
+
+    [CustomPropertyDrawer(typeof(ScriptableObject), true)]
 #if ODIN_INSPECTOR
     [DrawerPriority(0, 0, 2)]
 #endif
diff --git a/Editor/GenerationDatabase/GenerationDatabase.cs b/Editor/GenerationDatabase/GenerationDatabase.cs
@@ -16,7 +16,7 @@
     /// </summary>
     /// <typeparam name="TUnityObject">
     /// Type derived from <see cref="UnityEngine.Object"/>. Currently supports only
-    /// <see cref="GenericScriptableObject"/> and <see cref="MonoBehaviour"/>.
+    /// <see cref="ScriptableObject"/> and <see cref="MonoBehaviour"/>.
     /// </typeparam>
     /// <remarks>
     /// The database utilizes two dictionaries: [Argument, List{GenericType}] and [GenericType, List{Argument[]}].
diff --git a/Editor/GenerationDatabase/SOGenerationDatabase.cs b/Editor/GenerationDatabase/SOGenerationDatabase.cs
@@ -7,7 +7,7 @@
     /// <summary>
     /// All the work is done in the parent class. This is implemented just to create a ScriptableObject asset.
     /// </summary>
-    internal class SOGenerationDatabase : GenerationDatabase<GenericScriptableObject>
+    internal class SOGenerationDatabase : GenerationDatabase<ScriptableObject>
     {
         [SerializeField] private Collection<GenericTypeInfo>[] _genericTypeValues;
         [SerializeField] private GenericTypeInfo[] _genericTypeKeys;
diff --git a/Editor/GenericTypesAnalyzer/GenericTypesAnalyzer.cs b/Editor/GenericTypesAnalyzer/GenericTypesAnalyzer.cs
@@ -48,14 +48,14 @@ public static void AnalyzeGenericTypes()
                 UpdateGeneratedAssemblies();
                 // We don't check missing selector assemblies because a new one would be created in
                 // UpdateGeneratedAssemblies anyway if a generic type exists in the project and is missing from the database.
-                AddMissingConcreteClassesToDatabase<GenericScriptableObject>();
+                AddMissingConcreteClassesToDatabase<ScriptableObject>();
                 AddMissingConcreteClassesToDatabase<MonoBehaviour>();
             }
 
             if (FailedAssembliesChecker.FailedAssemblyPaths.Count == 0)
             {
                 DictInitializer<MonoBehaviour>.Initialize();
-                DictInitializer<GenericScriptableObject>.Initialize();
+                DictInitializer<ScriptableObject>.Initialize();
             }
 
             CompilationHelper.CompilationNotNeeded();
@@ -163,7 +163,7 @@ private static void UpdateGeneratedAssemblies()
                     | behavioursChecker.Check();
 
                 scriptableObjectsNeedDatabaseRefresh =
-                    ArgumentsChecker<GenericScriptableObject>.Check(scriptableObjectsChecker)
+                    ArgumentsChecker<ScriptableObject>.Check(scriptableObjectsChecker)
                     | scriptableObjectsChecker.Check()
                     | MenuItemsChecker.Check();
             }
@@ -177,9 +177,9 @@ private static void FlushConfigChangesToDisk()
             // AssetDatabase.SaveAssetIfDirty was added in Unity 2020.3.16 and Unity 2021.1.17
 #if UNITY_2020_3_16_OR_NEWER || UNITY_2021_1_17_OR_NEWER || UNITY_2021_2_OR_NEWER
             AssetDatabase.SaveAssetIfDirty(GenerationDatabase<MonoBehaviour>.Instance);
-            AssetDatabase.SaveAssetIfDirty(GenerationDatabase<GenericScriptableObject>.Instance);
+            AssetDatabase.SaveAssetIfDirty(GenerationDatabase<ScriptableObject>.Instance);
             AssetDatabase.SaveAssetIfDirty(GenericTypesDatabase<MonoBehaviour>.Instance);
-            AssetDatabase.SaveAssetIfDirty(GenericTypesDatabase<GenericScriptableObject>.Instance);
+            AssetDatabase.SaveAssetIfDirty(GenericTypesDatabase<ScriptableObject>.Instance);
 #else
             AssetDatabase.SaveAssets();
 #endif
diff --git a/Editor/GenericTypesAnalyzer/MenuItemsChecker.cs b/Editor/GenericTypesAnalyzer/MenuItemsChecker.cs
@@ -8,10 +8,11 @@
     using SolidUtilities;
     using SolidUtilities.Editor;
     using UnityEditor;
+    using UnityEngine;
     using Util;
 
     /// <summary>
-    /// Gathers types that inherit from <see cref="GenericScriptableObject"/> and have
+    /// Gathers types that inherit from <see cref="ScriptableObject"/> and have
     /// <see cref="CreateGenericAssetMenuAttribute"/>, then generates a class with methods marked as
     /// <see cref="MenuItemMethod"/> so that they appear in the Assets/Create menu.
     /// </summary>
@@ -21,7 +22,7 @@ public static class MenuItemsChecker
 
         public static bool Check()
         {
-            var newScriptableObjects = TypeCache.GetTypesDerivedFrom<GenericScriptableObject>()
+            var newScriptableObjects = TypeCache.GetTypesDerivedFrom<ScriptableObject>()
                 .Where(type => type.IsGenericType && ! type.IsAbstract)
                 .ToArray();
 
diff --git a/Editor/GenericTypesAnalyzer/ScriptableObjectsChecker.cs b/Editor/GenericTypesAnalyzer/ScriptableObjectsChecker.cs
@@ -2,13 +2,14 @@
 {
     using System;
     using GeneratedTypesDatabase;
+    using UnityEngine;
 
     /// <summary>
-    /// Checks if any generic <see cref="GenericScriptableObject"/> types were changed, removed, or updated, and
+    /// Checks if any generic <see cref="ScriptableObject"/> types were changed, removed, or updated, and
     /// regenerates DLLs if needed. Most of the work is done in the parent type. This class contains only methods
-    /// where a task needs to be done differently for GenericScriptableObject compared to MonoBehaviour.
+    /// where a task needs to be done differently for ScriptableObject compared to MonoBehaviour.
     /// </summary>
-    internal class ScriptableObjectsChecker : GenericTypesChecker<GenericScriptableObject>
+    internal class ScriptableObjectsChecker : GenericTypesChecker<ScriptableObject>
     {
         protected override bool AddNewGenericTypes(GenericTypeInfo[] genericTypes)
         {
diff --git a/Editor/ScriptableObjects/GenericSOCreator.cs b/Editor/ScriptableObjects/GenericSOCreator.cs
@@ -114,7 +114,7 @@ public static void CreateAssetInteractively(Type genericTypeWithoutArgs, Type[]
             PersistentStorage.SaveData(FileNameKey, fileName);
             PersistentStorage.ExecuteOnScriptsReload(FinishSOCreationInteractively);
 
-            ConcreteClassCreator<GenericScriptableObject>.CreateConcreteClass(genericTypeWithoutArgs, genericArgs);
+            ConcreteClassCreator<ScriptableObject>.CreateConcreteClass(genericTypeWithoutArgs, genericArgs);
             AssetDatabase.Refresh();
         }
 
@@ -130,7 +130,7 @@ public static ScriptableObject CreateAssetAtPath(SerializedProperty property, Ty
             SaveProperty(property);
             PersistentStorage.ExecuteOnScriptsReload(FinishSOCreationAtPath);
 
-            ConcreteClassCreator<GenericScriptableObject>.CreateConcreteClass(genericType.GetGenericTypeDefinition(), genericType.GenericTypeArguments);
+            ConcreteClassCreator<ScriptableObject>.CreateConcreteClass(genericType.GetGenericTypeDefinition(), genericType.GenericTypeArguments);
             AssetDatabase.Refresh();
             // At this point the domain is reloaded, so the method doesn't return.
             return null;
diff --git a/Editor/Util/ConcreteClassCreator.cs b/Editor/Util/ConcreteClassCreator.cs
@@ -8,6 +8,7 @@
     using SolidUtilities;
     using SolidUtilities.Editor;
     using UnityEditor;
+    using UnityEngine;
     using Object = UnityEngine.Object;
 
     /// <summary>
@@ -30,7 +31,7 @@ public static void CreateConcreteClass(Type genericTypeWithoutArgs, Type[] argum
             string assemblyGUID = CreateConcreteClassAssembly(genericTypeWithoutArgs, argumentTypes);
             var genericTypeInfo = GenericTypeInfo.Instantiate<TObject>(genericTypeWithoutArgs);
 
-            IconSetter.AddAssemblyForIconChange(genericTypeInfo.GUID, assemblyGUID, typeof(TObject) == typeof(GenericScriptableObject));
+            IconSetter.AddAssemblyForIconChange(genericTypeInfo.GUID, assemblyGUID, typeof(TObject) == typeof(ScriptableObject));
 
             AddToDatabase(genericTypeInfo, argumentTypes, assemblyGUID);
 
@@ -60,11 +61,9 @@ public static void UpdateConcreteClassAssembly(Type genericType, Type[] argument
             string newAssemblyPath = CreateConcreteClassAssembly(genericType, argumentTypes, newAssemblyName, concreteClass.AssemblyGUID);
             assemblyReplacer.FinishReplacement(newAssemblyPath);
 
-            IconSetter.AddAssemblyForIconChange(genericTypeGUID, concreteClass.AssemblyGUID, typeof(TObject) == typeof(GenericScriptableObject));
+            IconSetter.AddAssemblyForIconChange(genericTypeGUID, concreteClass.AssemblyGUID, typeof(TObject) == typeof(ScriptableObject));
         }
 
-
-
         private static string CreateConcreteClassAssembly(Type genericTypeWithoutArgs, Type[] argumentTypes,
             string newAssemblyName, string assemblyGUID)
         {
diff --git a/GenericUnityEditorInternals.dll b/GenericUnityEditorInternals.dll
diff --git a/GenericUnityEditorInternals.pdb b/GenericUnityEditorInternals.pdb
diff --git a/OdinInternals.dll b/OdinInternals.dll
diff --git a/OdinInternals.pdb b/OdinInternals.pdb
diff --git a/Runtime/CreateGenericAssetMenuAttribute.cs b/Runtime/CreateGenericAssetMenuAttribute.cs
@@ -2,13 +2,14 @@
 {
     using System;
     using JetBrains.Annotations;
+    using UnityEngine;
 
     /// <summary>
-    /// Marks a GenericScriptableObject-derived type to be automatically listed in the Assets/Create submenu, so that
+    /// Marks a ScriptableObject-derived type to be automatically listed in the Assets/Create submenu, so that
     /// instances of the type can be easily created and stored in the project as ".asset" files.
     /// </summary>
     [AttributeUsage(AttributeTargets.Class, Inherited = false)]
-    [BaseTypeRequired(typeof(GenericScriptableObject))]
+    [BaseTypeRequired(typeof(ScriptableObject))]
     public class CreateGenericAssetMenuAttribute : Attribute
     {
         /// <summary>The default file name used by newly created instances of this type.</summary>
diff --git a/Runtime/Util/Config.cs b/Runtime/Util/Config.cs
@@ -20,7 +20,7 @@ internal static class Config
 
         public static string GetAssemblyPathForType(Type parentType)
         {
-            if (typeof(GenericScriptableObject).IsAssignableFrom(parentType))
+            if (typeof(ScriptableObject).IsAssignableFrom(parentType))
             {
                 return ScriptableObjectsPath;
             }
diff --git a/Runtime/Util/GenericTypesDatabase/GenericTypesDatabase.cs b/Runtime/Util/GenericTypesDatabase/GenericTypesDatabase.cs
@@ -15,7 +15,7 @@
     /// </summary>
     /// <typeparam name="TObject">
     /// A class derived from <see cref="UnityEngine.Object"/>. Currently supports only
-    /// <see cref="GenericScriptableObject"/> and <see cref="MonoBehaviour"/>.
+    /// <see cref="ScriptableObject"/> and <see cref="MonoBehaviour"/>.
     /// </typeparam>
     internal abstract class GenericTypesDatabase<TObject> : SingletonScriptableObject<GenericTypesDatabase<TObject>>, ISerializationCallbackReceiver, ICanBeInitialized
     where TObject : Object
diff --git a/Runtime/Util/GenericTypesDatabase/ScriptableObjectsDatabase.cs b/Runtime/Util/GenericTypesDatabase/ScriptableObjectsDatabase.cs
@@ -1,7 +1,9 @@
 ﻿namespace GenericUnityObjects.Util
 {
+    using UnityEngine;
+
     /// <summary>
     /// All the work is done in the parent class. This is implemented just to create a ScriptableObject asset.
     /// </summary>
-    internal class ScriptableObjectsDatabase : GenericTypesDatabase<GenericScriptableObject> { }
+    internal class ScriptableObjectsDatabase : GenericTypesDatabase<ScriptableObject> { }
 }

Original file line number	Diff line number	Diff line change
`@@ -34,15 +34,15 @@ public static Type GetConcreteType(Type genericType)`
`34`	`34`	`: genericType;`
`35`	`35`	`}`
`36`	`36`
`37`		`- if (typeof(GenericScriptableObject).IsAssignableFrom(genericType))`
	`37`	`+ if (typeof(ScriptableObject).IsAssignableFrom(genericType))`
`38`	`38`	`{`
`39`	`39`	`return ScriptableObjectsDatabase.TryGetConcreteType(genericType, out Type concreteType)`
`40`	`40`	`? concreteType`
`41`	`41`	`: genericType;`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`throw new ArgumentException(`
`45`		`- $"Expected a type derived from MonoBehaviour or GenericScriptableObject. Got {genericType} instead.");`
	`45`	`+ $"Expected a type derived from MonoBehaviour or ScriptableObject. Got {genericType} instead.");`
`46`	`46`	`}`
`47`	`47`	`}`
`48`	`48`	`}`
Original file line number	Diff line number	Diff line change
`@@ -296,7 +296,7 @@ public static string GetTypeName(Object unityObject, bool onlyShort)`
`296`	`296`	`{`
`297`	`297`	`shortName = unityObject is MonoBehaviour`
`298`	`298`	`? GetBehaviourShortName(unityObjectType)`
`299`		`- : GetScriptableObjectShortName(unityObject, unityObjectType);`
	`299`	`+ : GetScriptableObjectShortName(unityObjectType);`
`300`	`300`
`301`	`301`	`_typeNameCache.Add(unityObjectType, shortName);`
`302`	`302`	`}`
`@@ -320,9 +320,9 @@ private static string GetBehaviourShortName(Type unityObjectType)`
`320`	`320`	`componentAttribute.componentMenu.Split('/').Last();`
`321`	`321`	`}`
`322`	`322`
`323`		`- private static string GetScriptableObjectShortName(Object unityObject, Type unityObjectType)`
	`323`	`+ private static string GetScriptableObjectShortName(Type unityObjectType)`
`324`	`324`	`{`
`325`		`- return unityObject is GenericScriptableObject ? TypeUtility.GetNiceNameOfGenericType(unityObjectType.BaseType) : unityObjectType.Name;`
	`325`	`+ return ((unityObjectType is GenericScriptableObject) \|\| unityObjectType.BaseType.IsGenericType) ? TypeUtility.GetNiceNameOfGenericType(unityObjectType.BaseType) : unityObjectType.Name;`
`326`	`326`	`}`
`327`	`327`	`}`
`328`	`328`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,8 +14,8 @@ public override void OnGUI(Rect position, SerializedProperty property, GUIConten`
`14`	`14`	`GenericObjectDrawer.ObjectField(position, property, label);`
`15`	`15`	`}`
`16`	`16`	`}`
`17`		`-`
`18`		`- [CustomPropertyDrawer(typeof(GenericScriptableObject), true)]`
	`17`	`+`
	`18`	`+ [CustomPropertyDrawer(typeof(ScriptableObject), true)]`
`19`	`19`	`#if ODIN_INSPECTOR`
`20`	`20`	`[DrawerPriority(0, 0, 2)]`
`21`	`21`	`#endif`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@`
`7`	`7`	`/// <summary>`
`8`	`8`	`/// All the work is done in the parent class. This is implemented just to create a ScriptableObject asset.`
`9`	`9`	`/// </summary>`
`10`		`- internal class SOGenerationDatabase : GenerationDatabase<GenericScriptableObject>`
	`10`	`+ internal class SOGenerationDatabase : GenerationDatabase<ScriptableObject>`
`11`	`11`	`{`
`12`	`12`	`[SerializeField] private Collection<GenericTypeInfo>[] _genericTypeValues;`
`13`	`13`	`[SerializeField] private GenericTypeInfo[] _genericTypeKeys;`
Original file line number	Diff line number	Diff line change
`@@ -2,13 +2,14 @@`
`2`	`2`	`{`
`3`	`3`	`using System;`
`4`	`4`	`using GeneratedTypesDatabase;`
	`5`	`+ using UnityEngine;`
`5`	`6`
`6`	`7`	`/// <summary>`
`7`		`- /// Checks if any generic <see cref="GenericScriptableObject"/> types were changed, removed, or updated, and`
	`8`	`+ /// Checks if any generic <see cref="ScriptableObject"/> types were changed, removed, or updated, and`
`8`	`9`	`/// regenerates DLLs if needed. Most of the work is done in the parent type. This class contains only methods`
`9`		`- /// where a task needs to be done differently for GenericScriptableObject compared to MonoBehaviour.`
	`10`	`+ /// where a task needs to be done differently for ScriptableObject compared to MonoBehaviour.`
`10`	`11`	`/// </summary>`
`11`		`- internal class ScriptableObjectsChecker : GenericTypesChecker<GenericScriptableObject>`
	`12`	`+ internal class ScriptableObjectsChecker : GenericTypesChecker<ScriptableObject>`
`12`	`13`	`{`
`13`	`14`	`protected override bool AddNewGenericTypes(GenericTypeInfo[] genericTypes)`
`14`	`15`	`{`