Added Clear method

Author: IntoTheDev

Runtime/Pool.cs

@@ -5,60 +5,97 @@ namespace ToolBox.Pools
 {
     internal sealed class Pool
     {
-        private readonly Poolable _prefab = null;
-        private readonly Stack<Poolable> _instances = null;
-        private readonly Quaternion _rotation = default;
-        private readonly Vector3 _scale = default;
+        private GameObject _source;
+        private Poolable _prototype;
+        private Stack<Poolable> _instances;
+        private List<GameObject> _allInstances;
+        private readonly Quaternion _rotation;
+        private readonly Vector3 _scale;
+        private readonly bool _prototypeIsNotSource;
 
         private static readonly Dictionary<GameObject, Pool> _prefabLookup = new Dictionary<GameObject, Pool>(64);
         private static readonly Dictionary<GameObject, Pool> _instanceLookup = new Dictionary<GameObject, Pool>(512);
 
-        private const int INITIAL_SIZE = 128;
+        private const int InitialSize = 128;
 
         public Pool(GameObject prefab)
         {
-            _prefab = prefab.GetComponent<Poolable>();
+            _source = prefab;
+            _prototype = prefab.GetComponent<Poolable>();
 
-            if (_prefab == null)
+            if (_prototype == null)
             {
-                _prefab = Object.Instantiate(prefab).AddComponent<Poolable>();
-                Object.DontDestroyOnLoad(_prefab);
-                _prefab.gameObject.SetActive(false);
+                _prototype = Object.Instantiate(prefab).AddComponent<Poolable>();
+                Object.DontDestroyOnLoad(_prototype);
+                _prototype.gameObject.SetActive(false);
+                _prototypeIsNotSource = true;
             }
 
-            _instances = new Stack<Poolable>(INITIAL_SIZE);
-            _prefabLookup.Add(prefab, this);
+            _instances = new Stack<Poolable>(InitialSize);
+            _allInstances = new List<GameObject>(InitialSize);
+            _prefabLookup.Add(_source, this);
 
             var transform = prefab.transform;
             _rotation = transform.rotation;
             _scale = transform.localScale;
         }
 
-        public static Pool GetPrefabPool(GameObject prefab)
+        public static Pool GetPoolByPrefab(GameObject prefab, bool create = true)
         {
-            bool hasPool = _prefabLookup.TryGetValue(prefab, out var pool);
+            var hasPool = _prefabLookup.TryGetValue(prefab, out var pool);
 
-            if (!hasPool)
+            if (!hasPool && create)
                 pool = new Pool(prefab);
 
             return pool;
         }
 
-        public static bool TryGetInstancePool(GameObject instance, out Pool pool)
+        public static bool GetPoolByInstance(GameObject instance, out Pool pool)
         {
             return _instanceLookup.TryGetValue(instance, out pool);
         }
 
+        public static void Remove(GameObject instance)
+        {
+            _instanceLookup.Remove(instance);
+        }
+
         public void Populate(int count)
         {
-            for (int i = 0; i < count; i++)
+            for (var i = 0; i < count; i++)
             {
                 var instance = CreateInstance();
                 instance.gameObject.SetActive(false);
                 _instances.Push(instance);
             }
         }
 
+        public void Clear(bool destroyActive)
+        {
+            _prefabLookup.Remove(_source);
+            
+            foreach (var instance in _allInstances)
+            {
+                if (instance == null)
+                    continue;
+
+                _instanceLookup.Remove(instance);
+                
+                if (!destroyActive && instance.activeInHierarchy)
+                    continue;
+                
+                Object.Destroy(instance);
+            }
+            
+            if (_prototypeIsNotSource)
+                Object.Destroy(_prototype.gameObject);
+
+            _source = null;
+            _prototype = null;
+            _instances = null;
+            _allInstances = null;
+        }
+
         public GameObject Reuse()
         {
             var instance = GetInstance();
@@ -121,7 +158,7 @@ public void Release(GameObject instance)
 
         private Poolable GetInstance()
         {
-            int count = _instances.Count;
+            var count = _instances.Count;
 
             if (count != 0)
             {
@@ -168,9 +205,11 @@ private Poolable GetInstance()
 
         private Poolable CreateInstance()
         {
-            var instance = Object.Instantiate(_prefab);
+            var instance = Object.Instantiate(_prototype);
             var instanceGameObject = instance.gameObject;
+            
             _instanceLookup.Add(instanceGameObject, this);
+            _allInstances.Add(instanceGameObject);
 
             return instance;
         }

Runtime/PoolHelper.cs

@@ -6,32 +6,37 @@ public static class PoolHelper
 	{
 		public static void Populate(this GameObject prefab, int count)
 		{
-			Pool.GetPrefabPool(prefab).Populate(count);
+			Pool.GetPoolByPrefab(prefab).Populate(count);
+		}
+
+		public static void Clear(this GameObject prefab, bool destroyActive)
+		{
+			Pool.GetPoolByPrefab(prefab, false)?.Clear(destroyActive);
 		}
 
 		public static GameObject Reuse(this GameObject prefab)
 		{
-			return Pool.GetPrefabPool(prefab).Reuse();
+			return Pool.GetPoolByPrefab(prefab).Reuse();
 		}
 
 		public static GameObject Reuse(this GameObject prefab, Transform parent)
 		{
-			return Pool.GetPrefabPool(prefab).Reuse(parent);
+			return Pool.GetPoolByPrefab(prefab).Reuse(parent);
 		}
 
 		public static GameObject Reuse(this GameObject prefab, Transform parent, bool worldPositionStays)
 		{
-			return Pool.GetPrefabPool(prefab).Reuse(parent, worldPositionStays);
+			return Pool.GetPoolByPrefab(prefab).Reuse(parent, worldPositionStays);
 		}
 
 		public static GameObject Reuse(this GameObject prefab, Vector3 position, Quaternion rotation)
 		{
-			return Pool.GetPrefabPool(prefab).Reuse(position, rotation);
+			return Pool.GetPoolByPrefab(prefab).Reuse(position, rotation);
 		}
 
 		public static GameObject Reuse(this GameObject prefab, Vector3 position, Quaternion rotation, Transform parent)
 		{
-			return Pool.GetPrefabPool(prefab).Reuse(position, rotation, parent);
+			return Pool.GetPoolByPrefab(prefab).Reuse(position, rotation, parent);
 		}
 
 		public static T Reuse<T>(this GameObject prefab) where T : Component
@@ -61,7 +66,7 @@ public static T Reuse<T>(this GameObject prefab, Vector3 position, Quaternion ro
 
 		public static void Release(this GameObject instance)
 		{
-			bool isPooled = Pool.TryGetInstancePool(instance, out var pool);
+			var isPooled = Pool.GetPoolByInstance(instance, out var pool);
 
 			if (isPooled)
 			{

Runtime/PoolInstaller.cs

@@ -5,11 +5,11 @@ namespace ToolBox.Pools
 	[DefaultExecutionOrder(-9999), DisallowMultipleComponent]
 	internal sealed class PoolInstaller : MonoBehaviour
 	{
-		[SerializeField] private PoolContainer[] _pools = null;
+		[SerializeField] private PoolContainer[] _pools;
 
 		private void Awake()
 		{
-			for (int i = 0; i < _pools.Length; i++)
+			for (var i = 0; i < _pools.Length; i++)
 				_pools[i].Populate();
 		}
 
@@ -19,8 +19,10 @@ private struct PoolContainer
 			[SerializeField] private GameObject _prefab;
 			[SerializeField, Min(1)] private int _startCount;
 
-			public void Populate() =>
+			public void Populate()
+			{
 				_prefab.Populate(_startCount);
+			}
 		}
 	}
 }

Runtime/Poolable.cs

@@ -7,26 +7,31 @@ namespace ToolBox.Pools
 	internal sealed class Poolable : MonoBehaviour
 	{
 		private IPoolable[] _poolables = Array.Empty<IPoolable>();
-		private bool _isInitialized = false;
+		private bool _isInitialized;
 
 		private void Awake()
 		{
 			_poolables = GetComponentsInChildren<IPoolable>(true);
 			_isInitialized = true;
 		}
 
+		private void OnDestroy()
+		{
+			Pool.Remove(gameObject);
+		}
+
 		public void OnReuse()
 		{
 			if (!_isInitialized)
 				return;
 
-			for (int i = 0; i < _poolables.Length; i++)
+			for (var i = 0; i < _poolables.Length; i++)
 				_poolables[i].OnReuse();
 		}
 
 		public void OnRelease()
 		{
-			for (int i = 0; i < _poolables.Length; i++)
+			for (var i = 0; i < _poolables.Length; i++)
 				_poolables[i].OnRelease();
 		}
 	}