Merge pull request #23 from badawe/feature/add-indirect-reference

add: indirect reference to the objects

Author: brunomikoski

CHANGELOG.MD

@@ -4,6 +4,13 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.2.0]
+## Changed
+ - Fixed issue with the wizzard that was not generating the target Scriptable Object
+
+## Added 
+- New type of indirect access to collectable items, this allows you use the regular editor reference, but without storing the reference, so without creating a relationship between the items, and can be lazy loaded when is needed, like addressables references for isntance.
+- Also added an option on the wizzard to automatically create the IndirectReference for every collectable item
 
 ## [1.1.9]
 ## Changed
@@ -100,6 +107,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
  - Add a setup wizzard for first time settings creation
 
+[1.2.0]: https://github.com/badawe/ScriptableObjectCollection/releases/tag/v1.2.0
 [1.1.9]: https://github.com/badawe/ScriptableObjectCollection/releases/tag/v1.1.9
 [1.1.8]: https://github.com/badawe/ScriptableObjectCollection/releases/tag/v1.1.8
 [1.1.7]: https://github.com/badawe/ScriptableObjectCollection/releases/tag/v1.1.7

Scripts/Editor/CollectableIndirectReferenceDrawer.cs

@@ -0,0 +1,45 @@
+using BrunoMikoski.ScriptableObjectCollections.Core;
+using UnityEditor;
+using UnityEngine;
+
+namespace BrunoMikoski.ScriptableObjectCollections
+{
+    [CustomPropertyDrawer(typeof(CollectableIndirectReference), true)]
+    public sealed class CollectableIndirectReferenceDrawer : PropertyDrawer
+    {
+        private const string EDITOR_ASSET_PROPERTY_PATH = "editorAsset";
+        private const string COLLECTABLE_GUID_PROPERTY_PATH = "collectableGUID";
+        private const string COLLECTION_GUID_PROPERTY_PATh = "collectionGUID";
+
+        
+        private SerializedProperty editorAssetproperty;
+        private SerializedProperty collectableGUIDProperty;
+        private SerializedProperty collectionGUIDProperty;
+
+        public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
+        {
+            editorAssetproperty = property.FindPropertyRelative(EDITOR_ASSET_PROPERTY_PATH);
+            collectableGUIDProperty = property.FindPropertyRelative(COLLECTABLE_GUID_PROPERTY_PATH);
+            collectionGUIDProperty = property.FindPropertyRelative(COLLECTION_GUID_PROPERTY_PATh);
+
+            using (EditorGUI.ChangeCheckScope scope = new EditorGUI.ChangeCheckScope())
+            {
+                EditorGUI.PropertyField(position, editorAssetproperty, label, true);
+
+                if (scope.changed)
+                {
+                    string collectableGUID = string.Empty;
+                    string collectionGUID = string.Empty;
+                        
+                    if (editorAssetproperty.objectReferenceValue != null && editorAssetproperty.objectReferenceValue is CollectableScriptableObject collectable)
+                    {
+                        collectableGUID = collectable.GUID;
+                        collectionGUID = collectable.Collection.GUID;
+                    }
+                    collectableGUIDProperty.stringValue = collectableGUID;
+                    collectionGUIDProperty.stringValue = collectionGUID;
+                }
+            }
+        }
+    }
+}

Scripts/Editor/CollectableIndirectReferenceDrawer.cs.meta

@@ -124,6 +124,7 @@ private static string LastGeneratedCollectionScriptPath
         private string collectionName = "Collection";
         private string collectableName = "Collectable";
         private static string targetFolder;
+        private bool generateIndirectAccess = true;
 
         public static CreateCollectionWizzard GetWindowInstance()
         {
@@ -151,6 +152,8 @@ private void OnGUI()
                         collectableName = EditorGUILayout.TextField("Collectable Name", collectableName);
 
                         collectionName = EditorGUILayout.TextField("Collection Name", collectionName);
+
+                        generateIndirectAccess = EditorGUILayout.Toggle("Generate Indirect Access", generateIndirectAccess);
                     }
                     using (new EditorGUILayout.VerticalScope("Box"))
                     {
@@ -206,14 +209,32 @@ private void CreateNewCollection()
             scriptsGenerated |= CreateCollectableScript();
             scriptsGenerated |= CreateCollectionScript();
 
+            if (generateIndirectAccess)
+                CreateIndirectAccess();
+            WaitingRecompileForContinue = true;
 
+            LastCollectionScriptableObjectPath = CreateCollectionObject();
             AssetDatabase.SaveAssets();
             AssetDatabase.Refresh();
 
             if (!scriptsGenerated)
                 OnAfterScriptsReloading();
         }
 
+        private void CreateIndirectAccess()
+        {
+            string folderPath = AssetDatabase.GetAssetPath(ScriptsFolder);
+            if (createFoldForThisCollectionScripts)
+                folderPath = Path.Combine(folderPath, $"{collectionName}");
+
+            CodeGenerationUtility.CreateNewEmptyScript($"{collectableName}IndirectReference", 
+                folderPath,
+                TargetNameSpace, 
+                "[Serializable]",
+                $"public sealed class {collectableName}IndirectReference : CollectableIndirectReference<{collectableName}>",
+                typeof(CollectableScriptableObject).Namespace, TargetNameSpace, "System");
+        }
+
         private string CreateCollectionObject()
         {
             ScriptableObjectCollection targetCollection = CreateInstance<ScriptableObjectCollection>();

Scripts/Editor/CreateCollectionWizzard.cs

@@ -11,7 +11,7 @@ namespace BrunoMikoski.ScriptableObjectCollections
 {
     public static class CodeGenerationUtility
     {
-        public static bool CreateNewEmptyScript(string fileName, string parentFolder, string nameSpace, string createAssetMenuInput, string classDeclarationString, params string[] directives)
+        public static bool CreateNewEmptyScript(string fileName, string parentFolder, string nameSpace, string classAttributes, string classDeclarationString, params string[] directives)
         {
             AssetDatabaseUtils.CreatePathIfDontExist(parentFolder);
             string finalFilePath = Path.Combine(parentFolder, $"{fileName}.cs");
@@ -37,8 +37,8 @@ public static bool CreateNewEmptyScript(string fileName, string parentFolder, st
                     indentation++;
                 }
 
-                if (!string.IsNullOrEmpty(createAssetMenuInput))
-                    writer.WriteLine($"{GetIndentation(indentation)}{createAssetMenuInput}");
+                if (!string.IsNullOrEmpty(classAttributes))
+                    writer.WriteLine($"{GetIndentation(indentation)}{classAttributes}");
 
                 writer.WriteLine($"{GetIndentation(indentation)}{classDeclarationString}");
                 writer.WriteLine(GetIndentation(indentation)+"{");

Scripts/Editor/Utils/CodeGenerationUtility.cs

@@ -0,0 +1,61 @@
+using System;
+using UnityEngine;
+
+namespace BrunoMikoski.ScriptableObjectCollections
+{
+    [Serializable]
+    public class CollectableIndirectReference
+    {
+#pragma warning disable 0649
+        [SerializeField]
+        private string name;
+#pragma warning restore 0649
+ 
+        [SerializeField]
+        protected string collectableGUID = String.Empty;
+
+        [SerializeField]
+        protected string collectionGUID;
+    }
+    
+    [Serializable]
+    public class CollectableIndirectReference<TObject> : CollectableIndirectReference
+        where TObject : CollectableScriptableObject
+    {
+#if UNITY_EDITOR
+        [SerializeField]
+        private TObject editorAsset;
+#endif
+        [NonSerialized]
+        private TObject cachedRef;
+        public TObject Ref
+        {
+            get
+            {
+                if (cachedRef != null)
+                    return cachedRef;
+
+                if (CollectionsRegistry.Instance.TryGetCollectionByGUID(collectableGUID,
+                    out ScriptableObjectCollection<TObject> collection))
+                {
+                    if (collection.TryGetCollectableByGUID(collectionGUID,
+                        out CollectableScriptableObject collectable))
+                    {
+                        cachedRef = collectable as TObject;
+                    }
+                }
+
+                return cachedRef;
+            }
+        }
+
+        public void FromCollectable(CollectableScriptableObject collectableScriptableObject)
+        {
+            collectableGUID = collectableScriptableObject.GUID;
+            collectionGUID = collectableScriptableObject.Collection.GUID;
+#if UNITY_EDITOR
+            editorAsset = collectableScriptableObject as TObject;
+#endif
+        }
+    }
+}

Scripts/Runtime/CollectableIndirectReference.cs

@@ -129,6 +129,18 @@ public bool TryGetCollectionByGUID(string targetGUID, out ScriptableObjectCollec
             return false;
         }
 
+        public bool TryGetCollectionByGUID<T>(string targetGUID, out ScriptableObjectCollection<T> resultCollection) where T : CollectableScriptableObject
+        {
+            if (TryGetCollectionByGUID(targetGUID, out ScriptableObjectCollection foundCollection))
+            {
+                resultCollection = foundCollection as ScriptableObjectCollection<T>;
+                return true;
+            }
+
+            resultCollection = null;
+            return false;
+        }
+        
         public void DeleteCollection(ScriptableObjectCollection collection)
         {
             if (Application.isPlaying)

Scripts/Runtime/CollectableIndirectReference.cs.meta

@@ -1,7 +1,7 @@
 {
   "name": "com.brunomikoski.scriptableobjectcollection",
   "displayName": "Scriptable Object Collection",
-  "version": "1.1.9",
+  "version": "1.2.0",
   "unity": "2018.4",
   "description": "Scriptable Object Collection",
   "keywords": [