Update V2

Author: BluePixelDev

Runtime/Asset/PoolAsset.cs

@@ -2,33 +2,68 @@
 
 namespace BP.PoolIO
 {
+    /// <summary>
+    /// ScriptableObject asset representing a pool for GameObjects.
+    /// </summary>
     [CreateAssetMenu(fileName = "Pool", menuName = "Pooling/Pool")]
     public class PoolAsset : PoolResource
     {
         [SerializeField] private string poolName;
         [SerializeField] private GameObject prefab;
-        [SerializeField] private bool reuseObjects;
         [SerializeField] private int initSize;
         [SerializeField] private int maxSize;
+        [SerializeField] private bool reuseObjects;
+        [SerializeField] private bool isPersistant;
 
+        /// <summary>
+        /// Gets the name of the pool.
+        /// </summary>
         public string PoolName => poolName;
+
+        /// <summary>
+        /// Gets the prefab associated with this pool.
+        /// </summary>
         public GameObject Prefab => prefab;
-        public bool ReuseObjects => reuseObjects;
+
+        /// <summary>
+        /// Gets the initial size of the pool.
+        /// </summary>
         public int InitSize => initSize;
+        /// <summary>
+        /// Gets the maximum size of the pool.
+        /// </summary>
         public int MaxSize => maxSize;
 
-        private IPoolable poolRef;
+        /// <summary>
+        /// Gets a value indicating whether objects in the pool should be reused.
+        /// </summary>
+        public bool ReuseObjects => reuseObjects;
 
-        public override void Init()
-        {
-            if (PoolUtils.IsNull(poolRef))
-            {
-                poolRef = GetPool();
-            }
-        }
+        /// <summary>
+        /// Gets a value indicating whether the pool should persist across scene loads.
+        /// </summary>
+        public bool IsPersistant => isPersistant;
+
+        private IPool poolRef;
+
+        /// <summary>
+        /// Retrieves a GameObject from the pool.
+        /// </summary>
+        /// <returns>The pooled GameObject.</returns>
         public override GameObject Get() => GetPool().Get();
+
+        /// <summary>
+        /// Releases a GameObject back into the pool.
+        /// </summary>
+        /// <param name="gameObject">The GameObject to release.</param>
+        /// <returns>True if the object was successfully released; otherwise, false.</returns>
         public override bool Release(GameObject gameObject) => poolRef?.Release(gameObject) ?? false;
-        private IPoolable GetPool()
+
+        /// <summary>
+        /// Gets the pool instance, creating it if necessary.
+        /// </summary>
+        /// <returns>The pool instance implementing IPoolable.</returns>
+        private IPool GetPool()
         {
             if (PoolUtils.IsNull(poolRef))
             {

Runtime/Asset/PoolGroupAsset.cs

@@ -2,33 +2,49 @@
 
 namespace BP.PoolIO
 {
+    /// <summary>
+    /// Enumeration for selecting the pooling strategy.
+    /// </summary>
     public enum PoolPickMode
     {
         Random,
         Sequential,
         Back2Back
     }
 
+    /// <summary>
+    /// ScriptableObject asset representing a group of pools.
+    /// </summary>
     [CreateAssetMenu(fileName = "PoolGroup", menuName = "Pooling/PoolGroup")]
     public class PoolGroupAsset : PoolResource
     {
         [SerializeField] private string groupName;
         [SerializeField] private PoolPickMode pickMode = PoolPickMode.Random;
         [SerializeField] private PoolAsset[] pools;
+        [SerializeField] private bool isPersistent;
 
+        /// <summary>
+        /// Gets the name of the pool group.
+        /// </summary>
         public string GroupName => groupName;
+
+        /// <summary>
+        /// Gets the picking mode for selecting pools.
+        /// </summary>
         public PoolPickMode PickMode => pickMode;
+
+        /// <summary>
+        /// Gets the array of pool assets in the group.
+        /// </summary>
         public PoolAsset[] Pools => pools;
 
+        /// <summary>
+        /// Gets a value indicating whether the pool group should persist across scene loads.
+        /// </summary>
+        public bool IsPersistent => isPersistent;
+
         private PoolGroup groupRef;
 
-        public override void Init()
-        {
-            if (PoolUtils.IsNull(groupRef))
-            {
-                groupRef = GetPoolGroup();
-            }
-        }
         public override GameObject Get() => GetPoolGroup().Get();
         public override bool Release(GameObject gameObject)
         {

Runtime/Asset/PoolResource.cs

@@ -2,9 +2,8 @@
 
 namespace BP.PoolIO
 {
-    public abstract class PoolResource : ScriptableObject, IPoolable
+    public abstract class PoolResource : ScriptableObject, IPool
     {
-        public abstract void Init();
         public abstract GameObject Get();
         public abstract bool Release(GameObject gameObject);
     }

Runtime/Components/Pool.cs

@@ -25,10 +25,10 @@ public void SetAsset(PoolAsset descriptor)
             prefab = descriptor.Prefab;
             reuseObjects = descriptor.ReuseObjects;
             initSize = descriptor.InitSize;
+            dontDestroyOnLoad = descriptor.IsPersistant;
         }
 
-        private void Start() => Init();
-        public override void Init()
+        private void Start()
         {
             if (dontDestroyOnLoad)
             {
@@ -41,28 +41,38 @@ public override void Init()
                 availableQueue.Enqueue(item);
             }
         }
+
         public override GameObject Get()
         {
             GameObject item;
             if (availableQueue.Count > 0)
             {
                 item = availableQueue.Dequeue();
-                usedList.AddFirst(item);
             }
             else if (reuseObjects && usedList.Count > 0)
             {
                 item = usedList.Last.Value;
                 usedList.RemoveLast();
-                usedList.AddFirst(item);
+                PrepareForReuse(item);
             }
             else
             {
                 item = CreatePooledObject();
-                usedList.AddFirst(item);
             }
 
+            usedList.AddFirst(item);
             return item;
         }
+        private void PrepareForReuse(GameObject pooledObject)
+        {
+            if (pooledObject.TryGetComponent<IPoolable>(out var poolable))
+            {
+                poolable.OnReuse();
+            }
+
+            pooledObject.SetActive(false);
+        }
+
         private GameObject CreatePooledObject()
         {
             var go = Instantiate(prefab);
@@ -82,5 +92,14 @@ public override bool Release(GameObject gameObject)
             }
             return false;
         }
+
+        public override void MakePersistent()
+        {
+            if (!dontDestroyOnLoad)
+            {
+                dontDestroyOnLoad = true;
+                DontDestroyOnLoad(gameObject);
+            }
+        }
     }
 }

Runtime/Components/PoolComponent.cs

@@ -5,10 +5,10 @@ namespace BP.PoolIO
     /// <summary>
     /// Base class for components that implemnt IPool interface.
     /// </summary>
-    public abstract class PoolComponent : MonoBehaviour, IPoolable
+    public abstract class PoolComponent : MonoBehaviour, IPool
     {
-        public abstract void Init();
         public abstract GameObject Get();
         public abstract bool Release(GameObject gameObject);
+        public abstract void MakePersistent();
     }
 }

Runtime/Components/PoolGroup.cs

@@ -3,10 +3,14 @@
 
 namespace BP.PoolIO
 {
+    /// <summary>
+    /// Represents a group of pools that can use different selection strategies to obtain pooled GameObjects.
+    /// </summary>
     public class PoolGroup : PoolComponent
     {
         [SerializeField] private PoolPickMode pickMode = PoolPickMode.Random;
         [SerializeField] private List<PoolComponent> pools = new();
+        [SerializeField] private bool isPersistent;
 
         private int seqIndex;
         private int backIndex;
@@ -39,6 +43,7 @@ private void OnValidate()
         public void SetAsset(PoolGroupAsset poolGroupAsset)
         {
             pickMode = poolGroupAsset.PickMode;
+            isPersistent = poolGroupAsset.IsPersistent;
         }
 
         public void AddPool(PoolComponent pool)
@@ -51,6 +56,7 @@ public void AddPool(PoolComponent pool)
                 return;
             }
 
+            if (isPersistent) pool.MakePersistent();
             pools.Add(pool);
         }
         public bool RemovePool(PoolComponent pool)
@@ -72,14 +78,6 @@ public bool ContainsPool(PoolComponent targetPool)
             return false;
         }
 
-        public override void Init()
-        {
-            foreach (var pool in pools)
-            {
-                if (pool == null) continue;
-                pool.Init();
-            }
-        }
         public override GameObject Get()
         {
             return pickMode switch
@@ -126,5 +124,13 @@ public override bool Release(GameObject gameObject)
             return false;
         }
 
+
+        public override void MakePersistent()
+        {
+            foreach (var pool in pools)
+            {
+                pool.MakePersistent();
+            }
+        }
     }
 }

Runtime/Components/PoolInit.cs

@@ -1,21 +1,14 @@
 using UnityEngine;
+using UnityEngine.Events;
 
 namespace BP.PoolIO
 {
-    public enum PoolObjectMode
+    public class PoolObject : MonoBehaviour, IPoolable
     {
-        Time,
-        Disable
-    }
-    public class PoolObject : MonoBehaviour
-    {
-        [SerializeField] private PoolObjectMode mode;
-        [SerializeField] private float time;
-
-        private float timer;
-        private void Update()
+        [SerializeField] private UnityEvent Reused;
+        public void OnReuse()
         {
-
+            Reused?.Invoke();
         }
     }
 }

Runtime/Components/PoolInit.cs.meta

@@ -0,0 +1,21 @@
+using UnityEngine;
+
+namespace BP.PoolIO
+{
+    public interface IPool
+    {
+        /// <summary>
+        /// Retrieves a GameObject from the pool group.
+        /// </summary>
+        /// <returns>The pooled GameObject.</returns>
+        GameObject Get();
+
+
+        /// <summary>
+        /// Releases a GameObject back into the pool group.
+        /// </summary>
+        /// <param name="gameObject">The GameObject to release.</param>
+        /// <returns>True if the object was successfully released; otherwise, false.</returns>
+        bool Release(GameObject gameObject);
+    }
+}