com.amanotes.prefabpool 1.1.0 → 1.3.0

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## [1.3.0] - 2026-06-12
+
+### Added
+- `MaterialPool` static class — material instance pooling with borrow/return pattern by `borrowId` (`MaterialPool.cs`)
+- `MaterialExtensions.SetAlpha(Material, float)` — convenience method for cloned material alpha modification (`MaterialPool.cs`)
+- `PoolEntryDrawer` — custom `PropertyDrawer` for compact `PoolEntry` inspector display with inline id, prefab, and prewarm count (`PoolEntryDrawer.cs`)
+- `AssemblyInfo.cs` — `InternalsVisibleTo` for test assembly (`AssemblyInfo.cs`)
+- Unit test suite: `PrefabPoolLifecycleTests`, `PrefabPoolGroupTests`, `PrefabPoolPerformanceTests` (`Tests/Runtime/`)
+
+### Changed
+- README.md rewritten with accurate API reference and quick start guide
+- `Docs/PrefabPool-API.md` — complete technical API reference
+
+## [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

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.3.0
 
 Generic object pooling system for Unity with lifecycle callbacks and material pooling support.
 
@@ -30,7 +30,7 @@ Add the package to your Unity project via `Packages/manifest.json`:
 ```json
 {
   "dependencies": {
-    "com.amanotes.prefabpool": "1.0.3"
+    "com.amanotes.prefabpool": "1.3.0"
   },
   "scopedRegistries": [
     {

package/Runtime/PoolEntryDrawer.cs

@@ -16,19 +16,24 @@ namespace Amanotes.Core
             var tilePrefabProp = property.FindPropertyRelative(nameof(PoolEntry.prefab));
             var prewarmProp = property.FindPropertyRelative(nameof(PoolEntry.prewarmCount));
             
-            var thirdWidth = position.width / 3f - 2f;
-            var nameRect = new Rect(position.x, position.y, thirdWidth, EditorGUIUtility.singleLineHeight);
-            var prefabRect = new Rect(position.x + thirdWidth + 3f, position.y, thirdWidth, EditorGUIUtility.singleLineHeight);
-            var sliderRect = new Rect(position.x + (thirdWidth + 3f) * 2, position.y, thirdWidth, EditorGUIUtility.singleLineHeight);
+            const float gap = 2f;
+            const float prewarmWidth = 80f;
+            var remaining = position.width - prewarmWidth - gap * 2;
+            var nameWidth = remaining * 0.35f;
+            var prefabWidth = remaining * 0.65f;
+            
+            var nameRect = new Rect(position.x, position.y, nameWidth, EditorGUIUtility.singleLineHeight);
+            var prefabRect = new Rect(nameRect.xMax + gap, position.y, prefabWidth, EditorGUIUtility.singleLineHeight);
+            var sliderRect = new Rect(prefabRect.xMax + gap, position.y, prewarmWidth, EditorGUIUtility.singleLineHeight);
             
             EditorGUI.PropertyField(nameRect, tileNameProp, GUIContent.none);
             EditorGUI.PropertyField(prefabRect, tilePrefabProp, GUIContent.none);
             
             EditorGUI.BeginChangeCheck();
-            var sliderValue = EditorGUI.IntSlider(sliderRect, prewarmProp.intValue, 0, 10);
+            var newValue = EditorGUI.IntField(sliderRect, prewarmProp.intValue);
             if (EditorGUI.EndChangeCheck())
             {
-                prewarmProp.intValue = sliderValue;
+                prewarmProp.intValue = Mathf.Max(0, newValue);
             }
             
             EditorGUI.EndProperty();

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);
@@ -338,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,6 +1,6 @@
 {
   "name": "com.amanotes.prefabpool",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "displayName": "[Ama] Prefab Pool",
   "description": "Generic object pooling system for Unity",
   "unity": "2022.3",