com.amanotes.prefabpool 1.0.3 → 1.2.0

package/CHANGELOG.md

@@ -1,21 +1,45 @@
 # Changelog
 
+## [1.2.0] - 2026-05-20
+
+### Added
+- `PoolEntry.EnsureCapacity(int count, Transform poolParent)` — pre-fills pool to target count without coroutine overhead
+- `PoolEntry.PoolCount` property — returns current pooled instance count
+- `PoolGroup.FindEntry(string prefabId)` — O(n) linear search replacing LINQ `Find()` with fallback support
+- `PoolGroup.IsGameplay` field — marks group for runtime instantiation warnings
+- Runtime instantiation warning in Editor/Development builds when `IsGameplay` is true
+
+### Changed
+- `PoolEntry.Get()` / `Return()` uses per-instance `IPoolPrefab[]` cache (`_poolPrefabCache`) — eliminates `GetComponents<IPoolPrefab>()` GC per Get/Return call
+- `PoolEntry.PreAllocate()` yields every 3 instances (`PreAllocBatchSize`) to spread across frames
+- `PrefabPool.Get()` uses `PoolGroup.FindEntry()` instead of LINQ lambda
+
+### Fixed
+- `PoolEntry.ReturnAll()` clears `_poolPrefabCache` to prevent stale references
+
+## [1.1.0] - 2026-04-21
+
+### Added
+- `IPrefabPool.MarkShutdown()` — marks pool as shut down so Get/Return calls no-op safely
+- `PrefabPool.MarkShutdown()` implementation — sets `_isDestroyed = true`
+
 ## [1.0.3] - 2026-04-07
 
 ### Fixed
-- `PoolEntry.Return`: renamed pooled GameObjects back to their entry `id` in Editor for easier hierarchy debugging (`PrefabPool.cs`)
+- `PoolEntry.Return` renames pooled GameObjects back to entry `id` in Editor
 
 ## [1.0.2] - 2026-04-06
 
 ### Fixed
-- `PoolEntry.Return`: deactivate GameObject before `SetParent` to prevent `Cannot set the parent of the GameObject while activating or deactivating the parent GameObject` error during scene shutdown
-- `PoolEntry.Get`: explicit `SetActive(true)` to match — objects are now consistently inactive in pool, active when in use
-- `PoolEntry.PreAllocate`: prewarm objects are now spawned inactive, consistent with the return state
-- `PrefabPool.DestroyPool`: `_customPool` (Resize<T>) entries are now properly destroyed on shutdown
-- `PrefabPool.Initialize`: added `_isInitializing` guard to prevent double-prewarm if called concurrently
-- `PoolEntry.PurgeDestroyed`: new method, called on `Register` to remove stale destroyed-object refs when a PoolGroup ScriptableObject is reused across scene loads
-- `PrefabPool.PurgeStaleInstanceMap`: cleans up `_instanceTypeMap` entries for externally-destroyed objects (Editor only)
+- `PoolEntry.Return` deactivates before `SetParent` to prevent parent activation error
+- `PoolEntry.Get` explicit `SetActive(true)` for consistent pool state
+- `PoolEntry.PreAllocate` prewarm objects spawned inactive
+- `PrefabPool.DestroyPool` properly destroys `_customPool` entries
+- `PrefabPool.Initialize` added `_isInitializing` guard against double-prewarm
+- `PoolEntry.PurgeDestroyed` removes stale refs on `Register`
+- `PrefabPool.PurgeStaleInstanceMap` cleans up externally-destroyed objects (Editor only)
 
 ## [1.0.1]
 
+### Added
 - Initial release

package/Docs/PrefabPool-API.md

@@ -1,6 +1,6 @@
 # PrefabPool API Reference
 
-**Package:** `com.amanotes.prefabpool` | **Version:** 1.0.1 | **Namespace:** `Amanotes.Core`
+**Package:** `com.amanotes.prefabpool` | **Version:** 1.2.0 | **Namespace:** `Amanotes.Core`
 
 Generic object pooling system to eliminate garbage collection spikes from frequent instantiation/destruction.
 

package/README.md

@@ -1,7 +1,7 @@
 # PrefabPool
 
 **Package:** `com.amanotes.prefabpool`  
-**Version:** 1.0.3
+**Version:** 1.2.0
 
 Generic object pooling system for Unity with lifecycle callbacks and material pooling support.
 

package/Runtime/PrefabPool.cs

@@ -22,8 +22,24 @@ namespace Amanotes.Core
         [NonSerialized] private readonly List<GameObject> _pool = new List<GameObject>();
         [NonSerialized] private PoolGroup _parentGroup;
         
+        // Per-instance IPoolPrefab cache — components don't change on pooled prefabs
+        [NonSerialized] private readonly Dictionary<int, IPoolPrefab[]> _poolPrefabCache = new Dictionary<int, IPoolPrefab[]>(32);
+        [NonSerialized] private static readonly List<IPoolPrefab> _tempPoolPrefabs = new List<IPoolPrefab>(8);
+        
         public void SetParentGroup(PoolGroup parentGroup) => _parentGroup = parentGroup;
         
+        private IPoolPrefab[] GetCachedPoolPrefabs(GameObject go)
+        {
+            var instanceId = go.GetInstanceID();
+            if (_poolPrefabCache.TryGetValue(instanceId, out var cached)) return cached;
+            
+            go.GetComponents(_tempPoolPrefabs);
+            cached = _tempPoolPrefabs.Count > 0 ? _tempPoolPrefabs.ToArray() : System.Array.Empty<IPoolPrefab>();
+            _tempPoolPrefabs.Clear();
+            _poolPrefabCache[instanceId] = cached;
+            return cached;
+        }
+        
         public GameObject Get(Transform poolParent, Transform spawnParent, Vector3 localPosition)
         {
             GameObject resultGameObject = null;
@@ -44,9 +60,12 @@ namespace Amanotes.Core
             bool fromPool = resultGameObject != null;
             if (resultGameObject == null)
             {
-                // Create prefab inside the pool's transform
                 resultGameObject = UnityObject.Instantiate(prefab, poolParent.position, Quaternion.identity, poolParent);
                 resultGameObject.hideFlags = HideFlags.DontSave;
+#if UNITY_EDITOR || DEVELOPMENT_BUILD
+                if (_parentGroup != null && _parentGroup.IsGameplay)
+                    Debug.LogWarning($"[Pool] Runtime instantiate '{id}' — prewarm undercount");
+#endif
             }
             
             var t = resultGameObject.transform;
@@ -55,11 +74,8 @@ namespace Amanotes.Core
             t.localRotation = Quaternion.identity;
             resultGameObject.SetActive(true);
             
-            var poolComponents = resultGameObject.GetComponents<IPoolPrefab>();
-            foreach (var pp in poolComponents)
-            {
-                pp.OnGet();
-            }
+            var prefabs = GetCachedPoolPrefabs(resultGameObject);
+            for (var i = 0; i < prefabs.Length; i++) prefabs[i].OnGet();
             
             return resultGameObject;
         }
@@ -68,11 +84,8 @@ namespace Amanotes.Core
         {
             if (gameObject == null) return;
             
-            var poolComponents = gameObject.GetComponents<IPoolPrefab>();
-            foreach (var pp in poolComponents)
-            {
-                pp.OnReturn();
-            }
+            var prefabs = GetCachedPoolPrefabs(gameObject);
+            for (var i = 0; i < prefabs.Length; i++) prefabs[i].OnReturn();
             
             var t = gameObject.transform;
             gameObject.SetActive(false);
@@ -94,10 +107,26 @@ namespace Amanotes.Core
                 }
             }
             _pool.Clear();
+            _poolPrefabCache.Clear();
         }
         
         public void PurgeDestroyed() => _pool.RemoveAll(obj => obj == null);
         
+        public int PoolCount => _pool.Count;
+        
+        public void EnsureCapacity(int count, Transform poolParent)
+        {
+            while (_pool.Count < count)
+            {
+                var instance = UnityObject.Instantiate(prefab, poolParent.position, Quaternion.identity, poolParent);
+                instance.hideFlags = HideFlags.DontSave;
+                instance.SetActive(false);
+                _pool.Add(instance);
+            }
+        }
+        
+        private const int PreAllocBatchSize = 3;
+        
         public IEnumerator PreAllocate(Transform poolParent)
         {
             for (var i = 0; i < prewarmCount; i++)
@@ -106,6 +135,9 @@ namespace Amanotes.Core
                 instance.hideFlags = HideFlags.DontSave;
                 instance.SetActive(false);
                 _pool.Add(instance);
+                
+                if ((i + 1) % PreAllocBatchSize == 0)
+                    yield return null;
             }
             
             yield return null;
@@ -120,6 +152,7 @@ namespace Amanotes.Core
         
         [NonSerialized] private IPrefabPool _prefabPool;
         [NonSerialized] private Transform _spawnParent;
+        [NonSerialized] public bool IsGameplay;
         
         public void Register(IPrefabPool prefabPool, Transform spawnParent)
         {
@@ -144,6 +177,13 @@ namespace Amanotes.Core
             return _prefabPool?.Get(this, prefabId, localPosition, customParent);
         }
         
+        public PoolEntry FindEntry(string prefabId)
+        {
+            for (var i = 0; i < entries.Count; i++)
+                if (entries[i].id == prefabId) return entries[i];
+            return fallbackEntry;
+        }
+        
         public T Get<T>(string prefabId, Vector3 localPosition = default) where T : class
         {
             var go = Get(prefabId, localPosition);
@@ -168,6 +208,12 @@ namespace Amanotes.Core
         GameObject Get(PoolGroup group, string prefabId, Vector3 localPosition = default, Transform customParent = null);
         void Return(PoolGroup group, GameObject gameObject);
         IEnumerator Initialize();
+        /// <summary>
+        /// Marks the pool as shut down so all subsequent Get/Return calls no-op safely.
+        /// Call this before detaching tiles during game shutdown to prevent SetParent errors
+        /// when the pool's hierarchy is being deactivated.
+        /// </summary>
+        void MarkShutdown();
     }
 
     public static class PrefabPoolExtensions
@@ -308,6 +354,8 @@ namespace Amanotes.Core
         
         public bool IsReady => _isReady;
         
+        public void MarkShutdown() => _isDestroyed = true;
+        
         public void RegisterGroup(PoolGroup group, Transform spawnParent)
         {
             if (group == null) return;
@@ -330,13 +378,8 @@ namespace Amanotes.Core
             if (_isDestroyed || group == null) return null;
             if (string.IsNullOrEmpty(prefabId)) return null;
             
-            var entry = group.entries.Find(e => e.id == prefabId);
-            if (entry == null)
-            {
-                // Try fallback entry if available
-                entry = group.fallbackEntry;
-                if (entry == null) return null;
-            }
+            var entry = group.FindEntry(prefabId);
+            if (entry == null) return null;
             
             var p = customParent == null ? group.SpawnParent : customParent;
             var result = entry.Get(transform, p, localPosition);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "com.amanotes.prefabpool",
-  "version": "1.0.3",
-  "displayName": "Amanotes Prefab Pool",
+  "version": "1.2.0",
+  "displayName": "[Ama] Prefab Pool",
   "description": "Generic object pooling system for Unity",
   "unity": "2022.3",
   "keywords": [