PoolGameObject Self Clear on Empty

duyca · duyca · commit bbd13565e7fb · 2024-02-05T10:04:33.000+07:00
diff --git a/Packages/ZBase.Foundation.Pooling/GameObjectLazyPool/Foundation/Pools/AssetRefGameObjectItemPool.cs b/Packages/ZBase.Foundation.Pooling/GameObjectLazyPool/Foundation/Pools/AssetRefGameObjectItemPool.cs
@@ -2,25 +2,25 @@
 using UnityEngine;
 using ZBase.Foundation.Pooling.AddressableAssets;
 
-namespace ZBase.Foundation.Pooling.GameObject.LazyPool
+namespace ZBase.Foundation.Pooling.GameObjectItem.LazyPool
 {
     public class AssetRefGameObjectItemPool : AssetRefGameObjectPool
     {
-        internal event Action<UnityEngine.GameObject> OnReturn;
+        internal event Action<GameObject> OnReturn;
         
         public AssetRefGameObjectItemPool(AssetRefGameObjectPrefab prefab) : base(prefab)
         {
         }
         
-        protected override void ProcessNewInstance(UnityEngine.GameObject instance)
+        protected override void ProcessNewInstance(GameObject instance)
         {
             base.ProcessNewInstance(instance);
             if (!instance.TryGetComponent<AssetRefGameObjectPoolItem>(out var poolItem))
                 poolItem = instance.AddComponent<AssetRefGameObjectPoolItem>();
             poolItem.SetUp(this, instance, Prefab);
         }
 
-        protected override void ReturnPreprocess(UnityEngine.GameObject instance)
+        protected override void ReturnPreprocess(GameObject instance)
         {
             base.ReturnPreprocess(instance);
             OnReturn?.Invoke(instance);
diff --git a/Packages/ZBase.Foundation.Pooling/GameObjectLazyPool/Foundation/Pools/GameObjectItemPool.cs b/Packages/ZBase.Foundation.Pooling/GameObjectLazyPool/Foundation/Pools/GameObjectItemPool.cs
@@ -1,25 +1,38 @@
 ﻿using System;
+using System.Collections.Generic;
+using UnityEngine;
 using ZBase.Foundation.Pooling.UnityPools;
 
-namespace ZBase.Foundation.Pooling.GameObject.LazyPool
+namespace ZBase.Foundation.Pooling.GameObjectItem.LazyPool
 {
     public sealed class GameObjectItemPool : GameObjectPool
     {
-        internal event Action<UnityEngine.GameObject> OnReturn;
-        
-        public GameObjectItemPool(GameObjectPrefab prefab) : base(prefab)
-        {
-        }
+        internal event Action<GameObject> OnReturn;
+        internal event Action<GameObjectItemPool> OnPoolEmpty;
+        private readonly List<int > _poolItems = new();
+
+        internal int ID { get; }
+
+        public GameObjectItemPool(GameObjectPrefab prefab) : base(prefab) => ID = Prefab.Source.GetInstanceID();
         
-        protected override void ProcessNewInstance(UnityEngine.GameObject instance)
+        protected override void ProcessNewInstance(GameObject instance)
         {
             base.ProcessNewInstance(instance);
             if (!instance.TryGetComponent<GameObjectPoolItem>(out var poolItem))
                 poolItem = instance.AddComponent<GameObjectPoolItem>();
             poolItem.SetUp(this, instance, Prefab);
+            poolItem.OnItemDestroy += OnItemDestroy;
+            this._poolItems.Add(instance.GetInstanceID());
         }
 
-        protected override void ReturnPreprocess(UnityEngine.GameObject instance)
+        private void OnItemDestroy(GameObject instance)
+        {
+            this._poolItems.Remove(instance.GetInstanceID());
+            if(this._poolItems.Count == 0)
+                OnPoolEmpty?.Invoke(this);
+        }
+        
+        protected override void ReturnPreprocess(GameObject instance)
         {
             base.ReturnPreprocess(instance);
             OnReturn?.Invoke(instance);
diff --git a/Packages/ZBase.Foundation.Pooling/GameObjectLazyPool/GlobalPools/Extensions/LazyAssetRefGameObjectPool.cs b/Packages/ZBase.Foundation.Pooling/GameObjectLazyPool/GlobalPools/Extensions/LazyAssetRefGameObjectPool.cs
@@ -3,26 +3,26 @@
 using UnityEngine.AddressableAssets;
 using ZBase.Foundation.Pooling.AddressableAssets;
 
-namespace ZBase.Foundation.Pooling.GameObject.LazyPool.Extensions
+namespace ZBase.Foundation.Pooling.GameObjectItem.LazyPool.Extensions
 {
     
     public static class LazyAssetRefGameObjectPool
     {
         private static GlobalAssetRefGameObjectPool GlobalGameObjectPool => SharedPool.Of<GlobalAssetRefGameObjectPool>();
 
-        public static async UniTask<UnityEngine.GameObject> Rent(AssetReferenceGameObject gameObjectReference)
+        public static async UniTask<GameObject> Rent(AssetReferenceGameObject gameObjectReference)
             => await GlobalGameObjectPool.Rent(gameObjectReference);
 
-        public static async UniTask<UnityEngine.GameObject> Rent(AssetRefGameObjectPrefab gameObjectReference)
+        public static async UniTask<GameObject> Rent(AssetRefGameObjectPrefab gameObjectReference)
             => await GlobalGameObjectPool.Rent(gameObjectReference);
         
-        public static void Return(UnityEngine.GameObject gameObject)
+        public static void Return(GameObject gameObject)
             => GlobalGameObjectPool.Return(gameObject);
         
-        public static void Return(AssetRefGameObjectPrefab gameObjectReference, UnityEngine.GameObject gameObject)
+        public static void Return(AssetRefGameObjectPrefab gameObjectReference, GameObject gameObject)
             => GlobalGameObjectPool.Return(gameObjectReference, gameObject);
         
-        public static void ReleaseInstances(int keep, System.Action<UnityEngine.GameObject> onReleased = null)
+        public static void ReleaseInstances(int keep, System.Action<GameObject> onReleased = null)
             => GlobalGameObjectPool.ReleaseInstances(keep, onReleased);
         
         [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
diff --git a/Packages/ZBase.Foundation.Pooling/GameObjectLazyPool/GlobalPools/Extensions/LazyGameObjectPool.cs b/Packages/ZBase.Foundation.Pooling/GameObjectLazyPool/GlobalPools/Extensions/LazyGameObjectPool.cs
@@ -2,24 +2,24 @@
 using UnityEngine;
 using ZBase.Foundation.Pooling.UnityPools;
 
-namespace ZBase.Foundation.Pooling.GameObject.LazyPool.Extensions
+namespace ZBase.Foundation.Pooling.GameObjectItem.LazyPool.Extensions
 {
     
     public static class LazyGameObjectPool
     {
         private static GlobalGameObjectPool GlobalGameObjectPool => SharedPool.Of<GlobalGameObjectPool>();
         
-        public static async UniTask<UnityEngine.GameObject> Rent(UnityEngine.GameObject gameObjectReference)
+        public static async UniTask<GameObject> Rent(GameObject gameObjectReference)
             => await GlobalGameObjectPool.Rent(gameObjectReference);
-        public static async UniTask<UnityEngine.GameObject> Rent(GameObjectPrefab gameObjectReference)
+        public static async UniTask<GameObject> Rent(GameObjectPrefab gameObjectReference)
             => await GlobalGameObjectPool.Rent(gameObjectReference);
-        public static void Return(UnityEngine.GameObject gameObject)
+        public static void Return(GameObject gameObject)
             => GlobalGameObjectPool.Return(gameObject);
         
-        public static void Return(GameObjectPrefab gameObjectReference, UnityEngine.GameObject gameObject)
+        public static void Return(GameObjectPrefab gameObjectReference, GameObject gameObject)
             => GlobalGameObjectPool.Return(gameObjectReference, gameObject);
         
-        public static void ReleaseInstances(int keep, System.Action<UnityEngine.GameObject> onReleased = null)
+        public static void ReleaseInstances(int keep, System.Action<GameObject> onReleased = null)
             => GlobalGameObjectPool.ReleaseInstances(keep, onReleased);
 
         [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
diff --git a/Packages/ZBase.Foundation.Pooling/GameObjectLazyPool/GlobalPools/GlobalAssetRefGameObjectPool.cs b/Packages/ZBase.Foundation.Pooling/GameObjectLazyPool/GlobalPools/GlobalAssetRefGameObjectPool.cs
@@ -5,77 +5,77 @@
 using UnityEngine.AddressableAssets;
 using ZBase.Foundation.Pooling.AddressableAssets;
 
-namespace ZBase.Foundation.Pooling.GameObject.LazyPool
+namespace ZBase.Foundation.Pooling.GameObjectItem.LazyPool
 {
     public class GlobalAssetRefGameObjectPool : IPool, IShareable
     {
         private readonly Dictionary<AssetRefGameObjectPrefab, AssetRefGameObjectItemPool> _pools =
             new(new AssetRefGameObjectPrefabEqualityComparer());
 
-        private readonly Dictionary<int, AssetRefGameObjectPrefab> _prefabToAssetReference = new();
+        private readonly Dictionary<int, AssetRefGameObjectItemPool> _dicTrackingInstancePools = new();
 
         private readonly Dictionary<AssetReferenceGameObject, AssetRefGameObjectPrefab> _poolKeyCache = new();
 
-        public async UniTask<UnityEngine.GameObject> Rent(AssetReferenceGameObject gameObjectReference)
+        public async UniTask<GameObject> Rent(AssetReferenceGameObject gameObjectReference)
         {
             if (!_poolKeyCache.TryGetValue(gameObjectReference, out var key))
                 _poolKeyCache.Add(gameObjectReference,
                     key = new AssetRefGameObjectPrefab { Source = gameObjectReference, });
             return await Rent(key);
         }
 
-        public async UniTask<UnityEngine.GameObject> Rent(AssetRefGameObjectPrefab gameObjectReference)
+        public async UniTask<GameObject> Rent(AssetRefGameObjectPrefab gameObjectReference)
         {
             if (!_pools.TryGetValue(gameObjectReference, out var pool))
             {
                 pool = new AssetRefGameObjectItemPool(gameObjectReference);
                 pool.OnReturn += OnReturnToPool;
                 this._pools.Add(gameObjectReference, pool);
             }
-            UnityEngine.GameObject item = await pool.Rent();
-            _prefabToAssetReference.Add(item.GetInstanceID(), gameObjectReference);
+            GameObject item = await pool.Rent();
+            _dicTrackingInstancePools.Add(item.GetInstanceID(), pool);
             return item;
         }
 
-        public void Return(UnityEngine.GameObject gameObject)
+        public void Return(GameObject gameObject)
         {
             if (!gameObject)
                 return;
-            if (_prefabToAssetReference.TryGetValue(gameObject.GetInstanceID(), out var assetReference))
-                Return(assetReference, gameObject);
+            if (_dicTrackingInstancePools.TryGetValue(gameObject.GetInstanceID(), out var pool))
+                pool.Return(gameObject);
             else
-                Debug.LogError($"GameObject {gameObject.name} is not registered in the pool or was already returned.");
+                Debug.LogWarning($"GameObject {gameObject.name} is not registered in the pool or was already returned.");
         }
 
-        public void Return(AssetRefGameObjectPrefab gameObjectReference, UnityEngine.GameObject gameObject)
+        public void Return(AssetRefGameObjectPrefab gameObjectReference, GameObject gameObject)
         {
             if (_pools.TryGetValue(gameObjectReference, out var pool))
                 pool.Return(gameObject);
         }
 
-        public void ReleaseInstances(int keep, System.Action<UnityEngine.GameObject> onReleased = null)
+        public void ReleaseInstances(int keep, System.Action<GameObject> onReleased = null)
         {
             foreach (var pool in _pools.Values)
                 pool.ReleaseInstances(keep, onReleased);
         }
 
-        private void OnReturnToPool(UnityEngine.GameObject gameObject) => _prefabToAssetReference.Remove(gameObject.GetInstanceID());
+        private void OnReturnToPool(GameObject gameObject) => _dicTrackingInstancePools.Remove(gameObject.GetInstanceID());
 
-        private class AssetRefGameObjectPrefabEqualityComparer : IEqualityComparer<AssetRefGameObjectPrefab>
-        {
-            public bool Equals([NotNull] AssetRefGameObjectPrefab x, [NotNull] AssetRefGameObjectPrefab y)
-                => y is { Source: not null } && x is { Source: not null } &&
-                   x.Source.AssetGUID.Equals(y.Source.AssetGUID);
-            public int GetHashCode(AssetRefGameObjectPrefab obj) => obj.Source.AssetGUID.GetHashCode();
-        }
-        
         public void Dispose()
         {
             foreach (var pool in _pools.Values)
                 pool.Dispose();
             _pools.Clear();
-            _prefabToAssetReference.Clear();
+            _dicTrackingInstancePools.Clear();
             _poolKeyCache.Clear();
         }
+        
+        private class AssetRefGameObjectPrefabEqualityComparer : IEqualityComparer<AssetRefGameObjectPrefab>
+        {
+            public bool Equals([NotNull] AssetRefGameObjectPrefab x, [NotNull] AssetRefGameObjectPrefab y)
+                => y is { Source: not null } && x is { Source: not null } &&
+                   x.Source.AssetGUID.Equals(y.Source.AssetGUID);
+            public int GetHashCode(AssetRefGameObjectPrefab obj) => obj.Source.AssetGUID.GetHashCode();
+        }
     }
 }
diff --git a/Packages/ZBase.Foundation.Pooling/GameObjectLazyPool/GlobalPools/GlobalGameObjectPool.cs b/Packages/ZBase.Foundation.Pooling/GameObjectLazyPool/GlobalPools/GlobalGameObjectPool.cs
@@ -4,23 +4,23 @@
 using UnityEngine;
 using ZBase.Foundation.Pooling.UnityPools;
 
-namespace ZBase.Foundation.Pooling.GameObject.LazyPool
+namespace ZBase.Foundation.Pooling.GameObjectItem.LazyPool
 {
     public class GlobalGameObjectPool : IPool, IShareable
     {
         private readonly Dictionary<int, GameObjectItemPool> _pools = new();
-        private readonly Dictionary<int, GameObjectPrefab> _prefabToAssetReference = new();
+        private readonly Dictionary<int, GameObjectItemPool> _dicTrackingInstancePools = new();
         private readonly Dictionary<int, GameObjectPrefab> _poolKeyCache = new();
 
-        public async UniTask<UnityEngine.GameObject> Rent(UnityEngine.GameObject gameObjectReference)
+        public async UniTask<GameObject> Rent(GameObject gameObjectReference)
         {
             var hash = gameObjectReference.GetInstanceID();
             if (!_poolKeyCache.TryGetValue(hash, out var key))
                 this._poolKeyCache.Add(hash, key = new GameObjectPrefab { Source = gameObjectReference });
             return await Rent(key);
         }
 
-        public async UniTask<UnityEngine.GameObject> Rent(GameObjectPrefab gameObjectReference)
+        public async UniTask<GameObject> Rent(GameObjectPrefab gameObjectReference)
         {
             var instanceID = gameObjectReference.Source.GetInstanceID();
             if (!_pools.TryGetValue(instanceID, out var pool))
@@ -29,44 +29,78 @@ public class GlobalGameObjectPool : IPool, IShareable
                     throw new Exception($"Non Prefab not supported {gameObjectReference.Source.name}");
                 pool = new GameObjectItemPool(gameObjectReference);
                 pool.OnReturn += OnReturnToPool;
+                pool.OnPoolEmpty += OnPoolEmpty;
                 this._pools.Add(instanceID, pool);
             }
 
-            UnityEngine.GameObject item = await pool.Rent();
-            _prefabToAssetReference.Add(item.GetInstanceID(), gameObjectReference);
+            GameObject item = await pool.Rent();
+            this._dicTrackingInstancePools.Add(item.GetInstanceID(), pool);
             return item;
         }
 
-        public void Return(UnityEngine.GameObject gameObject)
+        public void Return(GameObject gameObject)
         {
             if (!gameObject)
                 return;
-            if (_prefabToAssetReference.TryGetValue(gameObject.GetInstanceID(), out var assetReference))
-                Return(assetReference, gameObject);
+            if (this._dicTrackingInstancePools.TryGetValue(gameObject.GetInstanceID(), out var pool))
+                pool.Return(gameObject);
             else
-                Debug.LogWarning($"GameObject {gameObject.name} is not registered in the pool or was already returned.");
+                Debug.LogWarning(
+                    $"GameObject {gameObject.name} is not registered in the pool or was already returned.");
         }
 
-        public void Return(GameObjectPrefab gameObjectReference, UnityEngine.GameObject gameObject)
+        public void Return(GameObjectPrefab gameObjectReference, GameObject gameObject)
         {
             if (_pools.TryGetValue(gameObjectReference.Source.GetInstanceID(), out var pool))
                 pool.Return(gameObject);
         }
 
-        public void ReleaseInstances(int keep, Action<UnityEngine.GameObject> onReleased = null)
+        public void ReleaseInstances(int keep, Action<GameObject> onReleased = null)
         {
             foreach (var pool in _pools.Values)
                 pool.ReleaseInstances(keep, onReleased);
         }
 
-        private void OnReturnToPool(UnityEngine.GameObject gameObject) => _prefabToAssetReference.Remove(gameObject.GetInstanceID());
+        private void OnPoolEmpty(GameObjectItemPool pool)
+        {
+            pool.Dispose();
+            this._pools.Remove(pool.ID);
+            RemoveReference(pool.ID);
+            RemoveCacheKey(pool.ID);
+        }
         
+        private void RemoveReference(int poolID)
+        {
+            foreach (var keyPair in this._dicTrackingInstancePools)
+            {
+                if (keyPair.Value.ID != poolID)
+                    continue;
+                this._dicTrackingInstancePools.Remove(keyPair.Key);
+                Debug.LogWarning($"Pool {poolID} is empty and removed from tracking");
+                break;
+            }
+        }
+   
+        private void RemoveCacheKey(int poolID)
+        {
+            foreach (var keyPair in  _poolKeyCache)
+            {
+                if (keyPair.Value.Source.GetInstanceID() != poolID)
+                    continue;
+                this._poolKeyCache.Remove(keyPair.Key);
+                break;
+            }
+        }
+
+        private void OnReturnToPool(GameObject gameObject) =>
+            this._dicTrackingInstancePools.Remove(gameObject.GetInstanceID());
+
         public void Dispose()
         {
             foreach (var pool in _pools.Values)
                 pool.Dispose();
             _pools.Clear();
-            _prefabToAssetReference.Clear();
+            _dicTrackingInstancePools.Clear();
             _poolKeyCache.Clear();
         }
     }
diff --git a/Packages/ZBase.Foundation.Pooling/GameObjectLazyPool/Items/AssetRefGameObjectPoolItem.cs b/Packages/ZBase.Foundation.Pooling/GameObjectLazyPool/Items/AssetRefGameObjectPoolItem.cs
@@ -1,6 +1,6 @@
 ﻿using ZBase.Foundation.Pooling.AddressableAssets;
 
-namespace ZBase.Foundation.Pooling.GameObject.LazyPool
+namespace ZBase.Foundation.Pooling.GameObjectItem.LazyPool
 {
     public class AssetRefGameObjectPoolItem : PoolItem<UnityEngine.GameObject, AssetRefGameObjectPrefab>
     {
diff --git a/Packages/ZBase.Foundation.Pooling/GameObjectLazyPool/Items/GameObjectPoolItem.cs b/Packages/ZBase.Foundation.Pooling/GameObjectLazyPool/Items/GameObjectPoolItem.cs
@@ -1,7 +1,16 @@
-﻿using ZBase.Foundation.Pooling.UnityPools;
-namespace ZBase.Foundation.Pooling.GameObject.LazyPool
+﻿using System;
+using UnityEngine;
+using ZBase.Foundation.Pooling.UnityPools;
+namespace ZBase.Foundation.Pooling.GameObjectItem.LazyPool
 {
-    public class GameObjectPoolItem : PoolItem<UnityEngine.GameObject, GameObjectPrefab>
+    public class GameObjectPoolItem : PoolItem<GameObject, GameObjectPrefab>
     {
+        public event Action<GameObject> OnItemDestroy;
+        
+        protected override void OnDestroy()
+        {
+            base.OnDestroy();
+            this.OnItemDestroy?.Invoke(this.gameObject);
+        }
     }
 }
diff --git a/Packages/ZBase.Foundation.Pooling/GameObjectLazyPool/Items/PoolItem.cs b/Packages/ZBase.Foundation.Pooling/GameObjectLazyPool/Items/PoolItem.cs
diff --git a/Packages/ZBase.Foundation.Pooling/GameObjectLazyPool/Items/PoolItemAutoDeSpawnSetUp.cs b/Packages/ZBase.Foundation.Pooling/GameObjectLazyPool/Items/PoolItemAutoDeSpawnSetUp.cs
diff --git a/Packages/ZBase.Foundation.Pooling/package.json b/Packages/ZBase.Foundation.Pooling/package.json

Original file line number	Diff line number	Diff line change
`@@ -2,25 +2,25 @@`
`2`	`2`	`using UnityEngine;`
`3`	`3`	`using ZBase.Foundation.Pooling.AddressableAssets;`
`4`	`4`
`5`		`-namespace ZBase.Foundation.Pooling.GameObject.LazyPool`
	`5`	`+namespace ZBase.Foundation.Pooling.GameObjectItem.LazyPool`
`6`	`6`	`{`
`7`	`7`	`public class AssetRefGameObjectItemPool : AssetRefGameObjectPool`
`8`	`8`	`{`
`9`		`- internal event Action<UnityEngine.GameObject> OnReturn;`
	`9`	`+ internal event Action<GameObject> OnReturn;`
`10`	`10`
`11`	`11`	`public AssetRefGameObjectItemPool(AssetRefGameObjectPrefab prefab) : base(prefab)`
`12`	`12`	`{`
`13`	`13`	`}`
`14`	`14`
`15`		`- protected override void ProcessNewInstance(UnityEngine.GameObject instance)`
	`15`	`+ protected override void ProcessNewInstance(GameObject instance)`
`16`	`16`	`{`
`17`	`17`	`base.ProcessNewInstance(instance);`
`18`	`18`	`if (!instance.TryGetComponent<AssetRefGameObjectPoolItem>(out var poolItem))`
`19`	`19`	`poolItem = instance.AddComponent<AssetRefGameObjectPoolItem>();`
`20`	`20`	`poolItem.SetUp(this, instance, Prefab);`
`21`	`21`	`}`
`22`	`22`
`23`		`- protected override void ReturnPreprocess(UnityEngine.GameObject instance)`
	`23`	`+ protected override void ReturnPreprocess(GameObject instance)`
`24`	`24`	`{`
`25`	`25`	`base.ReturnPreprocess(instance);`
`26`	`26`	`OnReturn?.Invoke(instance);`
Original file line number	Diff line number	Diff line change
`@@ -5,77 +5,77 @@`
`5`	`5`	`using UnityEngine.AddressableAssets;`
`6`	`6`	`using ZBase.Foundation.Pooling.AddressableAssets;`
`7`	`7`
`8`		`-namespace ZBase.Foundation.Pooling.GameObject.LazyPool`
	`8`	`+namespace ZBase.Foundation.Pooling.GameObjectItem.LazyPool`
`9`	`9`	`{`
`10`	`10`	`public class GlobalAssetRefGameObjectPool : IPool, IShareable`
`11`	`11`	`{`
`12`	`12`	`private readonly Dictionary<AssetRefGameObjectPrefab, AssetRefGameObjectItemPool> _pools =`
`13`	`13`	`new(new AssetRefGameObjectPrefabEqualityComparer());`
`14`	`14`
`15`		`- private readonly Dictionary<int, AssetRefGameObjectPrefab> _prefabToAssetReference = new();`
	`15`	`+ private readonly Dictionary<int, AssetRefGameObjectItemPool> _dicTrackingInstancePools = new();`
`16`	`16`
`17`	`17`	`private readonly Dictionary<AssetReferenceGameObject, AssetRefGameObjectPrefab> _poolKeyCache = new();`
`18`	`18`
`19`		`- public async UniTask<UnityEngine.GameObject> Rent(AssetReferenceGameObject gameObjectReference)`
	`19`	`+ public async UniTask<GameObject> Rent(AssetReferenceGameObject gameObjectReference)`
`20`	`20`	`{`
`21`	`21`	`if (!_poolKeyCache.TryGetValue(gameObjectReference, out var key))`
`22`	`22`	`_poolKeyCache.Add(gameObjectReference,`
`23`	`23`	`key = new AssetRefGameObjectPrefab { Source = gameObjectReference, });`
`24`	`24`	`return await Rent(key);`
`25`	`25`	`}`
`26`	`26`
`27`		`- public async UniTask<UnityEngine.GameObject> Rent(AssetRefGameObjectPrefab gameObjectReference)`
	`27`	`+ public async UniTask<GameObject> Rent(AssetRefGameObjectPrefab gameObjectReference)`
`28`	`28`	`{`
`29`	`29`	`if (!_pools.TryGetValue(gameObjectReference, out var pool))`
`30`	`30`	`{`
`31`	`31`	`pool = new AssetRefGameObjectItemPool(gameObjectReference);`
`32`	`32`	`pool.OnReturn += OnReturnToPool;`
`33`	`33`	`this._pools.Add(gameObjectReference, pool);`
`34`	`34`	`}`
`35`		`- UnityEngine.GameObject item = await pool.Rent();`
`36`		`- _prefabToAssetReference.Add(item.GetInstanceID(), gameObjectReference);`
	`35`	`+ GameObject item = await pool.Rent();`
	`36`	`+ _dicTrackingInstancePools.Add(item.GetInstanceID(), pool);`
`37`	`37`	`return item;`
`38`	`38`	`}`
`39`	`39`
`40`		`- public void Return(UnityEngine.GameObject gameObject)`
	`40`	`+ public void Return(GameObject gameObject)`
`41`	`41`	`{`
`42`	`42`	`if (!gameObject)`
`43`	`43`	`return;`
`44`		`- if (_prefabToAssetReference.TryGetValue(gameObject.GetInstanceID(), out var assetReference))`
`45`		`- Return(assetReference, gameObject);`
	`44`	`+ if (_dicTrackingInstancePools.TryGetValue(gameObject.GetInstanceID(), out var pool))`
	`45`	`+ pool.Return(gameObject);`
`46`	`46`	`else`
`47`		`- Debug.LogError($"GameObject {gameObject.name} is not registered in the pool or was already returned.");`
	`47`	`+ Debug.LogWarning($"GameObject {gameObject.name} is not registered in the pool or was already returned.");`
`48`	`48`	`}`
`49`	`49`
`50`		`- public void Return(AssetRefGameObjectPrefab gameObjectReference, UnityEngine.GameObject gameObject)`
	`50`	`+ public void Return(AssetRefGameObjectPrefab gameObjectReference, GameObject gameObject)`
`51`	`51`	`{`
`52`	`52`	`if (_pools.TryGetValue(gameObjectReference, out var pool))`
`53`	`53`	`pool.Return(gameObject);`
`54`	`54`	`}`
`55`	`55`
`56`		`- public void ReleaseInstances(int keep, System.Action<UnityEngine.GameObject> onReleased = null)`
	`56`	`+ public void ReleaseInstances(int keep, System.Action<GameObject> onReleased = null)`
`57`	`57`	`{`
`58`	`58`	`foreach (var pool in _pools.Values)`
`59`	`59`	`pool.ReleaseInstances(keep, onReleased);`
`60`	`60`	`}`
`61`	`61`
`62`		`- private void OnReturnToPool(UnityEngine.GameObject gameObject) => _prefabToAssetReference.Remove(gameObject.GetInstanceID());`
	`62`	`+ private void OnReturnToPool(GameObject gameObject) => _dicTrackingInstancePools.Remove(gameObject.GetInstanceID());`
`63`	`63`
`64`		`- private class AssetRefGameObjectPrefabEqualityComparer : IEqualityComparer<AssetRefGameObjectPrefab>`
`65`		`- {`
`66`		`- public bool Equals([NotNull] AssetRefGameObjectPrefab x, [NotNull] AssetRefGameObjectPrefab y)`
`67`		`- => y is { Source: not null } && x is { Source: not null } &&`
`68`		`- x.Source.AssetGUID.Equals(y.Source.AssetGUID);`
`69`		`- public int GetHashCode(AssetRefGameObjectPrefab obj) => obj.Source.AssetGUID.GetHashCode();`
`70`		`- }`
`71`		`-`
`72`	`64`	`public void Dispose()`
`73`	`65`	`{`
`74`	`66`	`foreach (var pool in _pools.Values)`
`75`	`67`	`pool.Dispose();`
`76`	`68`	`_pools.Clear();`
`77`		`- _prefabToAssetReference.Clear();`
	`69`	`+ _dicTrackingInstancePools.Clear();`
`78`	`70`	`_poolKeyCache.Clear();`
`79`	`71`	`}`
	`72`	`+`
	`73`	`+ private class AssetRefGameObjectPrefabEqualityComparer : IEqualityComparer<AssetRefGameObjectPrefab>`
	`74`	`+ {`
	`75`	`+ public bool Equals([NotNull] AssetRefGameObjectPrefab x, [NotNull] AssetRefGameObjectPrefab y)`
	`76`	`+ => y is { Source: not null } && x is { Source: not null } &&`
	`77`	`+ x.Source.AssetGUID.Equals(y.Source.AssetGUID);`
	`78`	`+ public int GetHashCode(AssetRefGameObjectPrefab obj) => obj.Source.AssetGUID.GetHashCode();`
	`79`	`+ }`
`80`	`80`	`}`
`81`	`81`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`using ZBase.Foundation.Pooling.AddressableAssets;`
`2`	`2`
`3`		`-namespace ZBase.Foundation.Pooling.GameObject.LazyPool`
	`3`	`+namespace ZBase.Foundation.Pooling.GameObjectItem.LazyPool`
`4`	`4`	`{`
`5`	`5`	`public class AssetRefGameObjectPoolItem : PoolItem<UnityEngine.GameObject, AssetRefGameObjectPrefab>`
`6`	`6`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,16 @@`
`1`		`-using ZBase.Foundation.Pooling.UnityPools;`
`2`		`-namespace ZBase.Foundation.Pooling.GameObject.LazyPool`
	`1`	`+using System;`
	`2`	`+using UnityEngine;`
	`3`	`+using ZBase.Foundation.Pooling.UnityPools;`
	`4`	`+namespace ZBase.Foundation.Pooling.GameObjectItem.LazyPool`
`3`	`5`	`{`
`4`		`- public class GameObjectPoolItem : PoolItem<UnityEngine.GameObject, GameObjectPrefab>`
	`6`	`+ public class GameObjectPoolItem : PoolItem<GameObject, GameObjectPrefab>`
`5`	`7`	`{`
	`8`	`+ public event Action<GameObject> OnItemDestroy;`
	`9`	`+`
	`10`	`+ protected override void OnDestroy()`
	`11`	`+ {`
	`12`	`+ base.OnDestroy();`
	`13`	`+ this.OnItemDestroy?.Invoke(this.gameObject);`
	`14`	`+ }`
`6`	`15`	`}`
`7`	`16`	`}`