Renamed to RefPool and improved README

Author: BluePixelDev

Editor/BP.PoolIO.Editor.asmdef Editor/BP.RefPool.Editor.asmdefEditor/BP.PoolIO.Editor.asmdef renamed to Editor/BP.RefPool.Editor.asmdef

@@ -1,6 +1,6 @@
 {
-    "name": "BP.PoolIO.Editor",
-    "rootNamespace": "BP.PoolIO.Editor",
+    "name": "BP.RefPool.Editor",
+    "rootNamespace": "BP.RefPool.Editor",
     "references": [
         "GUID:5df53463e12a5c24183fa4fbd6737925"
     ],

Editor/BP.PoolIO.Editor.asmdef.meta Editor/BP.RefPool.Editor.asmdef.metaEditor/BP.PoolIO.Editor.asmdef.meta renamed to Editor/BP.RefPool.Editor.asmdef.meta

@@ -1,39 +1,49 @@
-using BP.PoolIO;
 using UnityEditor;
 using UnityEngine;
 
-public static class EditorUtil
+namespace BP.RefPool.Editor
 {
-
-    [MenuItem("GameObject/Pools/Pool", false, 10)]
-    public static void CreatePool(MenuCommand menuCommand)
+    public static class EditorUtil
     {
-        GameObject go = new("Pool");
-        go.AddComponent<Pool>();
-        EditorCreeate(menuCommand, go);
-    }
 
-    [MenuItem("GameObject/Pools/Group", false, 10)]
-    public static void CreateGroup(MenuCommand menuCommand)
-    {
-        GameObject root = new("Group", typeof(PoolGroup));
-        var rootGroup = root.GetComponent<PoolGroup>();
-        for (int i = 0; i < 3; i++)
+        [MenuItem("GameObject/RefPool/Pool", false, 10)]
+        public static void CreatePool(MenuCommand menuCommand)
         {
-            GameObject child = new($"Pool #{i + 1}", typeof(Pool));
-            child.transform.SetParent(root.transform);
-            rootGroup.AddPool(child.GetComponent<Pool>());
+            GameObject go = new("Pool");
+            go.AddComponent<Pool>();
+            EditorCreeate(menuCommand, go);
         }
-        EditorCreeate(menuCommand, root);
-    }
 
-    private static void EditorCreeate(MenuCommand menuCommand, params GameObject[] gameobjects)
-    {
-        foreach (var go in gameobjects)
+        [MenuItem("GameObject/RefPool/Group", false, 10)]
+        public static void CreateGroup(MenuCommand menuCommand)
+        {
+            GameObject root = new("Group", typeof(PoolGroup));
+            var rootGroup = root.GetComponent<PoolGroup>();
+            for (int i = 0; i < 3; i++)
+            {
+                GameObject child = new($"Pool #{i + 1}", typeof(Pool));
+                child.transform.SetParent(root.transform);
+                rootGroup.AddPool(child.GetComponent<Pool>());
+            }
+            EditorCreeate(menuCommand, root);
+        }
+
+
+        [MenuItem("GameObject/RefPool/Spawner", false, 10)]
+        public static void CreateSpawner(MenuCommand menuCommand)
+        {
+            GameObject root = new("Spawner", typeof(PoolSpawner));
+            EditorCreeate(menuCommand, root);
+        }
+
+        private static void EditorCreeate(MenuCommand menuCommand, params GameObject[] gameobjects)
         {
-            GameObjectUtility.SetParentAndAlign(go, menuCommand.context as GameObject);
-            Undo.RegisterCreatedObjectUndo(go, "Create " + go.name);
+            foreach (var go in gameobjects)
+            {
+                GameObjectUtility.SetParentAndAlign(go, menuCommand.context as GameObject);
+                Undo.RegisterCreatedObjectUndo(go, "Create " + go.name);
+            }
+            Selection.objects = gameobjects;
         }
-        Selection.objects = gameobjects;
     }
-}
+}

Editor/EditorUtil.cs

@@ -1,2 +1,98 @@
 # RefPool
-A simple unity package utilizing scriptable objects to link Pools and PoolGroups across scenes.
+[![GitHub Repo stars](https://img.shields.io/github/stars/BluePixelDev/refpool?style=flat-square)](https://github.com/BluePixelDev/refpool/stargazers)
+[![GitHub last commit](https://img.shields.io/github/last-commit/BluePixelDev/refpool?style=flat-square)](https://github.com/BluePixelDev/refpool/commits/main)
+[![GitHub issues](https://img.shields.io/github/issues/bluepixeldev/refpool?style=flat-square)](https://github.com/bluepixeldev/refpool/issues)
+[![Unity Version](https://img.shields.io/badge/unity-6.0%2B-green?style=flat-square)](https://unity.com/releases/editor)
+
+**RefPool** is a lightweight, ScriptableObject-driven pooling system for Unity 6.0 and above.  
+It enables clean, efficient reuse of GameObjects across scenes without relying on global registries.
+
+## Features
+- ScriptableObject-based pool references for cross-scene linking
+- Lazy pool initialization and automatic cleanup on unload
+- Efficient memory management through shared pooling
+- Supports runtime spawning with configurable options such as spawn rate, position overrides, and randomization
+- Clean integration with Unity’s component model
+- Extendable through custom `PoolResource` implementations for advanced pooling behaviors
+
+## Installation
+
+### Unity Package Manager (via Git URL)
+
+1. Open your Unity project
+2. Go to `Packages/manifest.json`
+3. Add the following line to the `dependencies` block:
+
+```json
+"com.bluepixeldev.refpool": "https://github.com/bluepixeldev/refpool.git"
+```
+
+### Manual Import
+
+Clone or download this repository and move the `RefPool` folder into your project's `Assets` directory.
+
+## Usage
+
+### Create a Pool Resource
+
+1. Right-click in the `Project` window
+2. Select `Create > RefPool > Pool or Pool Group`
+3. Assign the prefab and configure pool size, increment size, and other settings
+
+### Add a RefPoolSpawner
+
+1. Attach the `RefPoolSpawner` component to a GameObject
+2. Assign the `PoolResource` you created
+3. Configure spawn behavior as needed
+
+### Trigger Spawning
+
+You can trigger pooled object spawning manually or automatically:
+
+```csharp
+[SerializeField] private PoolSpawner spawner;
+
+void SomeEventTrigger()
+{
+    spawner.Spawn();
+}
+```
+
+### Extending with Custom Pool Behaviors
+
+RefPool allows you to implement custom pooling logic by extending the `PoolResource` class. This enables advanced use cases such as dynamic pool resizing, custom initialization, or specialized cleanup logic.
+
+Here’s an example of a custom `PoolResource`:
+
+```csharp
+using UnityEngine;
+
+namespace BP.RefPool
+{
+    public class CustomPoolResource : PoolResource
+    {
+        public override void Initialize()
+        {
+            // Custom initialization logic
+        }
+
+        public override GameObject Get()
+        {
+            // Custom logic for retrieving a GameObject from the pool
+            return null;
+        }
+
+        public override bool Release(GameObject gameObject)
+        {
+            // Custom logic for releasing a GameObject back to the pool
+            return true;
+        }
+    }
+}
+```
+
+This flexibility allows you to tailor the pooling system to your specific project requirements.
+
+## Contributing
+
+Pull requests and issues are welcome. If you encounter a bug or have a feature suggestion, please open an issue on GitHub.

README.md

@@ -1,19 +1,19 @@
 using UnityEngine;
 
-namespace BP.PoolIO
+namespace BP.RefPool
 {
     /// <summary>
     /// ScriptableObject asset representing a pool for GameObjects.
     /// </summary>
-    [CreateAssetMenu(fileName = "Pool", menuName = "Pooling/Pool")]
+    [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 isPersistant;
+        [SerializeField] private bool isPersistent;
 
         /// <summary>
         /// Gets the name of the pool.
@@ -42,21 +42,19 @@ public class PoolAsset : PoolResource
         /// <summary>
         /// Gets a value indicating whether the pool should persist across scene loads.
         /// </summary>
-        public bool IsPersistant => isPersistant;
+        public bool IsPersistent => isPersistent;
 
         private IPool poolRef;
 
-        /// <summary>
-        /// Retrieves a GameObject from the pool.
-        /// </summary>
-        /// <returns>The pooled GameObject.</returns>
+        public override void Initialize()
+        {
+            if (PoolUtils.IsNull(poolRef))
+            {
+                poolRef = PoolUtils.CreatePool(this);
+                poolRef.Initialize();
+            }
+        }
         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;
 
         /// <summary>
@@ -65,11 +63,7 @@ public class PoolAsset : PoolResource
         /// <returns>The pool instance implementing IPoolable.</returns>
         private IPool GetPool()
         {
-            if (PoolUtils.IsNull(poolRef))
-            {
-                poolRef = PoolUtils.CreatePool(this);
-            }
-
+            Initialize();
             return poolRef;
         }
     }

reamde.md.meta README.md.metareamde.md.meta renamed to README.md.meta

@@ -1,6 +1,6 @@
 using UnityEngine;
 
-namespace BP.PoolIO
+namespace BP.RefPool
 {
     /// <summary>
     /// Enumeration for selecting the pooling strategy.
@@ -15,7 +15,7 @@ public enum PoolPickMode
     /// <summary>
     /// ScriptableObject asset representing a group of pools.
     /// </summary>
-    [CreateAssetMenu(fileName = "PoolGroup", menuName = "Pooling/PoolGroup")]
+    [CreateAssetMenu(fileName = "PoolGroup", menuName = "RefPool/Pool Group")]
     public class PoolGroupAsset : PoolResource
     {
         [SerializeField] private string groupName;
@@ -45,6 +45,14 @@ public class PoolGroupAsset : PoolResource
 
         private PoolGroup groupRef;
 
+        public override void Initialize()
+        {
+            if (PoolUtils.IsNull(groupRef))
+            {
+                groupRef = PoolUtils.CreatePoolGroup(this);
+                groupRef.Initialize();
+            }
+        }
         public override GameObject Get() => GetPoolGroup().Get();
         public override bool Release(GameObject gameObject)
         {
@@ -53,10 +61,7 @@ public override bool Release(GameObject gameObject)
         }
         private PoolGroup GetPoolGroup()
         {
-            if (PoolUtils.IsNull(groupRef))
-            {
-                groupRef = PoolUtils.CreatePoolGroup(this);
-            }
+            Initialize();
             return groupRef;
         }
     }

Runtime/Asset/PoolAsset.cs

@@ -1,6 +1,6 @@
 {
-    "name": "BP.PoolIO",
-    "rootNamespace": "BP.PoolIO",
+    "name": "BP.RefPool",
+    "rootNamespace": "BP.RefPool",
     "references": [],
     "includePlatforms": [],
     "excludePlatforms": [],