Improved example scene, Improved documentation, Marked PoolUtils internal to simplify API, Fixed an issue where Pool would never reach max size.

Author: BluePixelDev

Runtime/Asset/PoolAsset.cs

@@ -3,49 +3,62 @@
 namespace BP.RefPool
 {
     /// <summary>
-    /// ScriptableObject asset representing a pool for GameObjects.
+    /// ScriptableObject representing a pooled GameObject resource.
+    /// This asset acts as a referenceable and configurable container for a shared object pool.
     /// </summary>
     [CreateAssetMenu(fileName = "Pool", menuName = "RefPool/Pool")]
     public class PoolAsset : PoolResource
     {
         [SerializeField] private string poolName;
         [SerializeField] private GameObject prefab;
-        [SerializeField] private int initSize;
-        [SerializeField] private int maxSize;
-        [SerializeField] private bool reuseObjects;
-        [SerializeField] private bool isPersistent;
+        [SerializeField] private int initSize = 10;
+        [SerializeField] private int maxSize = 100;
+        [SerializeField] private bool reuseObjects = true;
+        [SerializeField] private bool isPersistent = false;
+
+        private IPool poolRef;
 
         /// <summary>
-        /// Gets the name of the pool.
-        /// </summary>
-        public string PoolName => poolName;
+        /// Display name of the pool. Defaults to the prefab name if unset.
+        /// </summary>O
+        public string PoolName => string.IsNullOrEmpty(poolName) && prefab ? prefab.name : poolName;
 
         /// <summary>
-        /// Gets the prefab associated with this pool.
+        /// The prefab that will be pooled.
         /// </summary>
         public GameObject Prefab => prefab;
 
         /// <summary>
-        /// Gets the initial size of the pool.
+        /// Number of instances to preallocate at initialization.
         /// </summary>
         public int InitSize => initSize;
+
         /// <summary>
-        /// Gets the maximum size of the pool.
+        /// Maximum number of instances allowed in the pool.
         /// </summary>
         public int MaxSize => maxSize;
 
         /// <summary>
-        /// Gets a value indicating whether objects in the pool should be reused.
+        /// Whether the pool reuses released instances when max size is reached.
         /// </summary>
         public bool ReuseObjects => reuseObjects;
 
         /// <summary>
-        /// Gets a value indicating whether the pool should persist across scene loads.
+        /// Whether the pool persists across scene changes.
         /// </summary>
         public bool IsPersistent => isPersistent;
 
-        private IPool poolRef;
+        private void OnValidate()
+        {
+            if (string.IsNullOrEmpty(poolName) && prefab != null)
+            {
+                poolName = prefab.name;
+            }
+        }
 
+        /// <summary>
+        /// Initializes the internal pool if it hasn't been created yet.
+        /// </summary>
         public override void Initialize()
         {
             if (PoolUtils.IsNull(poolRef))
@@ -54,13 +67,20 @@ public override void Initialize()
                 poolRef.Initialize();
             }
         }
+
+        /// <summary>
+        /// Gets an instance from the pool, creating the pool if necessary.
+        /// </summary>
         public override GameObject Get() => GetPool().Get();
+
+        /// <summary>
+        /// Returns an instance to the pool.
+        /// </summary>
         public override bool Release(GameObject gameObject) => poolRef?.Release(gameObject) ?? false;
 
         /// <summary>
-        /// Gets the pool instance, creating it if necessary.
+        /// Ensures the pool is initialized and returns the internal pool reference.
         /// </summary>
-        /// <returns>The pool instance implementing IPoolable.</returns>
         private IPool GetPool()
         {
             Initialize();

Runtime/Asset/PoolGroupAsset.cs

@@ -3,62 +3,67 @@
 namespace BP.RefPool
 {
     /// <summary>
-    /// Enumeration for selecting the pooling strategy.
-    /// </summary>
-    public enum PoolPickMode
-    {
-        Random,
-        Sequential,
-        Back2Back
-    }
-
-    /// <summary>
-    /// ScriptableObject asset representing a group of pools.
+    /// ScriptableObject representing a referenceable group of pool assets.
+    /// Allows configuring pooled objects and pick strategy via asset.
     /// </summary>
     [CreateAssetMenu(fileName = "PoolGroup", menuName = "RefPool/Pool Group")]
     public class PoolGroupAsset : PoolResource
     {
-        [SerializeField] private string groupName;
+        [SerializeField] private string groupName = "New Group";
         [SerializeField] private PoolPickMode pickMode = PoolPickMode.Random;
         [SerializeField] private PoolAsset[] pools;
-        [SerializeField] private bool isPersistent;
+        [SerializeField] private bool isPersistent = false;
+
+        private PoolGroup groupRef;
 
         /// <summary>
-        /// Gets the name of the pool group.
+        /// Optional display name for the pool group.
         /// </summary>
         public string GroupName => groupName;
 
         /// <summary>
-        /// Gets the picking mode for selecting pools.
+        /// Strategy used to pick which pool to pull from.
         /// </summary>
         public PoolPickMode PickMode => pickMode;
 
         /// <summary>
-        /// Gets the array of pool assets in the group.
+        /// Array of pool assets that make up this group.
         /// </summary>
         public PoolAsset[] Pools => pools;
 
         /// <summary>
-        /// Gets a value indicating whether the pool group should persist across scene loads.
+        /// Whether this group should persist across scene loads.
         /// </summary>
         public bool IsPersistent => isPersistent;
 
-        private PoolGroup groupRef;
-
+        /// <summary>
+        /// Initializes the internal PoolGroup instance.
+        /// </summary>
         public override void Initialize()
         {
-            if (PoolUtils.IsNull(groupRef))
+            if (groupRef == null)
             {
                 groupRef = PoolUtils.CreatePoolGroup(this);
                 groupRef.Initialize();
             }
         }
+
+        /// <summary>
+        /// Gets a pooled object using the group strategy.
+        /// </summary>
         public override GameObject Get() => GetPoolGroup().Get();
+
+        /// <summary>
+        /// Attempts to release the GameObject to one of the internal pools.
+        /// </summary>
         public override bool Release(GameObject gameObject)
         {
-            if (PoolUtils.IsNull(groupRef)) return false;
-            return groupRef.Release(gameObject);
+            return groupRef != null && groupRef.Release(gameObject);
         }
+
+        /// <summary>
+        /// Ensures the group is initialized and returns the internal reference.
+        /// </summary>
         private PoolGroup GetPoolGroup()
         {
             Initialize();

Runtime/Components/Pool.cs

@@ -4,60 +4,87 @@
 namespace BP.RefPool
 {
     /// <summary>
-    /// A simple pool implementation.
+    /// A basic GameObject pool that supports initialization, reuse, and optional persistence across scenes.
     /// </summary>
     public class Pool : PoolComponent
     {
         [SerializeField] private GameObject prefab;
-        [SerializeField] private int initSize;
-        [SerializeField] private int maxSize;
-        [SerializeField] private bool reuseObjects;
-        [SerializeField] private bool dontDestroyOnLoad;
+        [SerializeField] private int initSize = 10;
+        [SerializeField] private int maxSize = 50;
+        [SerializeField] private bool reuseObjects = false;
+        [SerializeField] private bool dontDestroyOnLoad = false;
 
+        /// <summary>
+        /// The prefab used for pooled instances.
+        /// </summary>
         public GameObject Pooled { get => prefab; set => prefab = value; }
+
+        /// <summary>
+        /// If true, old objects will be reused when the pool exceeds its maximum size.
+        /// </summary>
         public bool ReuseObjects { get => reuseObjects; set => reuseObjects = value; }
+
+        /// <summary>
+        /// Initial number of objects to populate in the pool.
+        /// </summary>
         public int InitSize { get => initSize; set => initSize = value; }
+
+        /// <summary>
+        /// Maximum number of objects allowed in the pool.
+        /// </summary>
         public int MaxSize { get => maxSize; set => maxSize = value; }
 
         private readonly Queue<GameObject> availableQueue = new();
         private readonly LinkedList<GameObject> usedList = new();
         private bool isInitialized;
 
         private void Start() => Initialize();
+
+        /// <summary>
+        /// Configures this pool using the data from a <see cref="PoolAsset"/>.
+        /// </summary>
         public void SetAsset(PoolAsset asset)
         {
             prefab = asset.Prefab;
-            reuseObjects = asset.ReuseObjects;
             initSize = asset.InitSize;
+            maxSize = asset.MaxSize;
+            reuseObjects = asset.ReuseObjects;
             dontDestroyOnLoad = asset.IsPersistent;
         }
 
+        /// <summary>
+        /// Initializes the pool by instantiating the initial objects.
+        /// </summary>
         public override void Initialize()
         {
             if (isInitialized) return;
+
             if (dontDestroyOnLoad)
-            {
                 DontDestroyOnLoad(gameObject);
-            }
 
-            for (var i = 0; i < initSize; i++)
+            for (int i = 0; i < initSize; i++)
             {
                 var item = CreatePooledObject();
                 availableQueue.Enqueue(item);
             }
+
             isInitialized = true;
         }
+
+        /// <summary>
+        /// Retrieves a GameObject from the pool.
+        /// </summary>
         public override GameObject Get()
         {
             GameObject item;
+
             if (availableQueue.Count > 0)
             {
                 item = availableQueue.Dequeue();
             }
             else if (usedList.Count < maxSize)
             {
                 item = CreatePooledObject();
-                usedList.AddFirst(item);
             }
             else if (reuseObjects && usedList.Count > 0)
             {
@@ -73,6 +100,10 @@ public override GameObject Get()
             usedList.AddFirst(item);
             return item;
         }
+
+        /// <summary>
+        /// Returns a GameObject to the pool, if it was previously retrieved.
+        /// </summary>
         public override bool Release(GameObject gameObject)
         {
             if (usedList.Contains(gameObject))
@@ -84,6 +115,21 @@ public override bool Release(GameObject gameObject)
             return false;
         }
 
+        /// <summary>
+        /// Ensures this pool persists across scene loads.
+        /// </summary>
+        public override void MakePersistent()
+        {
+            if (!dontDestroyOnLoad)
+            {
+                dontDestroyOnLoad = true;
+                DontDestroyOnLoad(gameObject);
+            }
+        }
+
+        /// <summary>
+        /// Prepares a reused object by resetting it and disabling it.
+        /// </summary>
         private void PrepareForReuse(GameObject pooledObject)
         {
             if (pooledObject.TryGetComponent<IPoolable>(out var poolable))
@@ -93,6 +139,10 @@ private void PrepareForReuse(GameObject pooledObject)
 
             pooledObject.SetActive(false);
         }
+
+        /// <summary>
+        /// Instantiates and sets up a new pooled object.
+        /// </summary>
         private GameObject CreatePooledObject()
         {
             var go = Instantiate(prefab);
@@ -102,13 +152,5 @@ private GameObject CreatePooledObject()
             go.transform.SetParent(transform);
             return go;
         }
-        public override void MakePersistent()
-        {
-            if (!dontDestroyOnLoad)
-            {
-                dontDestroyOnLoad = true;
-                DontDestroyOnLoad(gameObject);
-            }
-        }
     }
 }

Runtime/PickMode.cs

@@ -0,0 +1,12 @@
+namespace BP.RefPool
+{
+    /// <summary>
+    /// Enumeration for selecting the pooling strategy.
+    /// </summary>
+    public enum PoolPickMode
+    {
+        Random,
+        Sequential,
+        Back2Back
+    }
+}

Runtime/PickMode.cs.meta

@@ -2,7 +2,7 @@
 
 namespace BP.RefPool
 {
-    public static class PoolUtils
+    internal static class PoolUtils
     {
         const string POOL_NAME_PREFIX = "[POOL]_";
         const string POOLGROUP_NAME_PREFIX = "[PGROUP]_";