com.amanotes.prefabpool 1.0.0

package/Editor/PoolEntryDrawer.cs

@@ -0,0 +1,43 @@
+#if UNITY_EDITOR
+
+using UnityEngine;
+using UnityEditor;
+
+namespace Amanotes.Core
+{
+    [CustomPropertyDrawer(typeof(PoolEntry))]
+    internal class PoolEntryDrawer : PropertyDrawer
+    {
+        public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
+        {
+            EditorGUI.BeginProperty(position, label, property);
+            
+            var tileNameProp = property.FindPropertyRelative(nameof(PoolEntry.id));
+            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);
+            
+            EditorGUI.PropertyField(nameRect, tileNameProp, GUIContent.none);
+            EditorGUI.PropertyField(prefabRect, tilePrefabProp, GUIContent.none);
+            
+            EditorGUI.BeginChangeCheck();
+            var sliderValue = EditorGUI.IntSlider(sliderRect, prewarmProp.intValue, 0, 10);
+            if (EditorGUI.EndChangeCheck())
+            {
+                prewarmProp.intValue = sliderValue;
+            }
+            
+            EditorGUI.EndProperty();
+        }
+        
+        public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
+        {
+            return EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+        }
+    }
+}
+#endif

package/README.md

@@ -0,0 +1,105 @@
+# Prefab Pool
+
+Generic object pooling system for Unity.
+
+## Features
+
+- ✅ Simple API for Get/Return pattern
+- ✅ Automatic prefab instantiation
+- ✅ `IPoolPrefab` interface for lifecycle callbacks
+- ✅ Pre-warming support
+- ✅ Material pooling support
+- ✅ No dependencies on other packages
+
+## Installation
+
+Add to your `manifest.json`:
+```json
+{
+  "dependencies": {
+    "com.amanotes.prefabpool": "1.0.0"
+  }
+}
+```
+
+## Quick Start
+
+```csharp
+using Amanotes.PrefabPool;
+
+public class Example : MonoBehaviour
+{
+    void Start()
+    {
+        var pool = new PrefabPool();
+        var group = CreatePoolGroup();
+        pool.RegisterGroup(group, transform);
+        
+        // Get object from pool
+        var obj = pool.Get<SpriteRenderer>("enemy");
+        
+        // Return to pool when done
+        pool.Return(obj.gameObject);
+    }
+}
+```
+
+## Usage
+
+### Implement IPoolPrefab
+
+```csharp
+public class Enemy : MonoBehaviour, IPoolPrefab
+{
+    public void OnGet()
+    {
+        // Called when retrieved from pool
+        gameObject.SetActive(true);
+        ResetState();
+    }
+    
+    public void OnReturn()
+    {
+        // Called when returned to pool
+        gameObject.SetActive(false);
+    }
+}
+```
+
+### Create Pool Configuration
+
+```csharp
+var poolGroup = ScriptableObject.CreateInstance<PoolGroup>();
+poolGroup.name = "Enemies";
+poolGroup.entries = new List<PoolEntry>
+{
+    new PoolEntry
+    {
+        id = "enemy",
+        prefab = enemyPrefab,
+        prewarmCount = 10
+    }
+};
+```
+
+## API Reference
+
+### IPrefabPool Interface
+
+```csharp
+void RegisterGroup(PoolGroup group, Transform parent);
+T Get<T>(string type) where T : Component;
+void Return(GameObject obj);
+IEnumerator Initialize();
+```
+
+### IPoolPrefab Interface
+
+```csharp
+void OnGet();    // Called when retrieved
+void OnReturn(); // Called when returned
+```
+
+## License
+
+Copyright © Amanotes

package/Runtime/Amanotes.PrefabPool.asmdef

@@ -0,0 +1,14 @@
+{
+    "name": "Amanotes.PrefabPool",
+    "rootNamespace": "Amanotes.Core",
+    "references": [],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

package/Runtime/MaterialPool.cs

@@ -0,0 +1,105 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityObject = UnityEngine.Object;
+
+namespace Amanotes.Core
+{
+
+    public static class MaterialExtensions
+    {
+        public static void SetAlpha(this Material m, float a)
+        {
+            if (m == null) return;
+            var isCloned = (m.hideFlags & HideFlags.DontSave) != 0;
+            if (!isCloned) Debug.LogWarning($"Modify material directly <{m}>!");
+
+            var c = m.color;
+            c.a = a;
+            m.color = c;
+        }
+    }
+    
+    
+    public partial class MaterialPool
+    {
+        [NonSerialized] private static readonly Dictionary<int, MaterialPool> _map = new Dictionary<int, MaterialPool>();
+        [NonSerialized] private static readonly Dictionary<int, MaterialPool> _cloned = new Dictionary<int, MaterialPool>();
+        
+        private static MaterialPool GetPool(Material sourceOrClone)
+        {
+            if (sourceOrClone == null) return null;
+            var instId = sourceOrClone.GetInstanceID();
+            var isCloned = sourceOrClone.hideFlags == HideFlags.DontSave;
+            return isCloned
+                ? _cloned.GetValueOrDefault(instId)
+                : _map.GetValueOrDefault(instId);
+        }
+        
+        public static Material Take(Material sourceOrClone, int borrowId)
+        {
+            if (sourceOrClone == null) return null;
+            var pool = GetPool(sourceOrClone) ?? new MaterialPool(sourceOrClone);
+            return pool.InternalTake(borrowId);
+        }
+        
+        public static void Return(int borrowId)
+        {
+            foreach (var kvp in _map)
+            {
+                kvp.Value.InternalReturn(borrowId);
+            }
+        }
+    }
+    
+    public partial class MaterialPool
+    {
+        private readonly Material original;
+        private readonly List<Material> pool = new List<Material>();
+        private readonly Dictionary<int, Material> borrowed = new Dictionary<int, Material>();
+
+        private MaterialPool(Material source)
+        {
+            original = source;
+            _map[original.GetInstanceID()] = this;
+
+            if (source.hideFlags == HideFlags.DontSave)
+            {
+                Debug.LogWarning($"Invalid source hideFlags: {source.name} : {source.hideFlags}");
+            }
+        }
+
+        // public bool IsOriginalColor(Color c) => original.color == c;
+        // public bool IsOriginalAlpha(float a) => Mathf.Approximately(original.color.a, a);
+        
+        private Material GetOne()
+        {
+            Material result;
+            if (pool.Count <= 0)
+            {
+                result = new Material(original) { hideFlags = HideFlags.DontSave };
+                _cloned[result.GetInstanceID()] = this;
+                return result;
+            }
+            
+            result = pool[pool.Count - 1];
+            pool.RemoveAt(pool.Count - 1);
+            return result;
+        }
+
+        private Material InternalTake(int borrowId)
+        {
+            if (borrowed.TryGetValue(borrowId, out var mat)) return mat;
+            
+            var material = GetOne();
+            material.name = $"{original.name}_{borrowId}";
+            borrowed[borrowId] = material;
+            return material;
+        }
+        
+        private void InternalReturn(int borrowId)
+        {
+            if (borrowed.Remove(borrowId, out var mat)) pool.Add(mat);
+        }
+    }
+}

package/Runtime/MeshRendererExtensions.cs

@@ -0,0 +1,80 @@
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace Amanotes.Core
+{
+    public static class MeshRendererExtensions
+    {
+        public static void SetAlpha(this List<SpriteRenderer> sprites, float value)
+        {
+            for (var i = 0; i < sprites.Count; i++)
+            {
+                var sprt = sprites[i];
+                if (sprt == null) continue;
+                
+                var c = sprt.color;
+                c.a = value;
+                sprt.color = c;
+            }
+        }
+        
+        
+        public static void SetColor(this List<MeshRenderer> renderers, Color c, bool keepAlpha = true)
+        {
+            for (var i = 0; i < renderers.Count; i++)
+            {
+                renderers[i].SetColor(c, keepAlpha);
+            }
+        }
+        
+        public static void SetColor(this List<SpriteRenderer> sprites, Color c, bool keepAlpha = true)
+        {
+            for (var i = 0; i < sprites.Count; i++)
+            {
+                sprites[i].SetColor(c, keepAlpha);
+            }
+        }
+
+        public static void SetColor(this MeshRenderer renderer, Color c, bool keepAlpha = true)
+        {
+            if (renderer == null) return;
+            var m = renderer.sharedMaterial;
+            if (m == null) return;
+
+            if (keepAlpha) c.a = m.color.a; 
+            renderer.sharedMaterial.color = c;
+        }
+        
+        public static void SetColor(this SpriteRenderer sprt, Color c, bool keepAlpha = true)
+        {
+            if (sprt == null) return;
+            if (keepAlpha) c.a = sprt.color.a;
+            sprt.color = c;
+        }
+        
+        public static void SetAlpha(this SpriteRenderer sprt, float alpha)
+        {
+            if (sprt == null) return;
+            var c = sprt.color;
+            c.a = sprt.color.a;
+            sprt.color = c;
+        }
+        
+        public static void CloneAndSetAlpha(this MeshRenderer renderer, float alpha)
+        {
+            // Prevent accidentally changes to prefab's material
+#if UNITY_EDITOR
+            if (PrefabUtility.IsPartOfPrefabAsset(renderer)) return;
+            if (!Application.isPlaying) return;
+#endif
+            if (renderer == null) return;
+
+            var oMat = renderer.sharedMaterial;
+            var cMat = MaterialPool.Take(oMat, renderer.GetInstanceID());
+            renderer.sharedMaterial = cMat;
+
+            cMat.SetAlpha(alpha);
+        }
+    }
+}

package/Runtime/PrefabPool.cs

@@ -0,0 +1,413 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+using UnityObject = UnityEngine.Object;
+
+namespace Amanotes.Core
+{
+    public interface IPoolPrefab
+    {
+        void OnGet();
+        void OnReturn();
+    }
+    
+    [Serializable] public class PoolEntry
+    {
+        public string id;
+        public GameObject prefab;
+        public int prewarmCount;
+        
+        [NonSerialized] private readonly List<GameObject> _pool = new List<GameObject>();
+        [NonSerialized] private PoolGroup _parentGroup;
+        
+        public void SetParentGroup(PoolGroup parentGroup) => _parentGroup = parentGroup;
+        
+        public GameObject Get(Transform poolParent, Transform spawnParent, Vector3 localPosition)
+        {
+            GameObject resultGameObject = null;
+
+            if (prefab == null)
+            {
+                Debug.LogWarning($"Prefab pool object is null. <{id}>");
+                return null;
+            }
+            
+            if (_pool.Count > 0)
+            {
+                var lastIndex = _pool.Count - 1;
+                resultGameObject = _pool[lastIndex];
+                _pool.RemoveAt(lastIndex);
+            }
+            
+            if (resultGameObject == null)
+            {
+                // Create prefab inside the pool's transform
+                resultGameObject = UnityObject.Instantiate(prefab, poolParent.position, Quaternion.identity, poolParent);
+                resultGameObject.hideFlags = HideFlags.DontSave;
+            }
+            
+            // Move to spawn parent when retrieved
+            var t = resultGameObject.transform;
+            t.SetParent(spawnParent, false);
+            t.localPosition = localPosition;
+            t.localRotation = Quaternion.identity;
+            
+            // Call OnGet on any IPoolPrefab components
+            var poolComponents = resultGameObject.GetComponents<IPoolPrefab>();
+            foreach (var pp in poolComponents)
+            {
+                pp.OnGet();
+            }
+            
+            return resultGameObject;
+        }
+        
+        public void Return(GameObject gameObject, Transform poolParent)
+        {
+            if (gameObject == null) return;
+            
+            // Call OnReturn on any IPoolPrefab components
+            var poolComponents = gameObject.GetComponents<IPoolPrefab>();
+            foreach (var pp in poolComponents)
+            {
+                pp.OnReturn();
+            }
+            
+            var t = gameObject.transform;
+            t.SetParent(poolParent, false);
+            t.localPosition = Vector3.zero;
+            _pool.Add(gameObject);
+        }
+        
+        public void DestroyPool()
+        {
+            for (var i = 0; i < _pool.Count; i++)
+            {
+                if (_pool[i] != null)
+                {
+                    UnityObject.Destroy(_pool[i]);
+                }
+            }
+            _pool.Clear();
+        }
+        
+        public IEnumerator PreAllocate(Transform poolParent)
+        {
+            for (var i = 0; i < prewarmCount; i++)
+            {
+                var instance = UnityObject.Instantiate(prefab, poolParent.position, Quaternion.identity, poolParent);
+                instance.hideFlags = HideFlags.DontSave;
+                _pool.Add(instance);
+            }
+            
+            yield return null;
+        }
+    }
+    
+    [Serializable] public class PoolGroup
+    {
+        public string id;
+        public List<PoolEntry> entries = new List<PoolEntry>();
+        public PoolEntry fallbackEntry;
+        
+        [NonSerialized] private IPrefabPool _prefabPool;
+        [NonSerialized] private Transform _spawnParent;
+        
+        public void Register(IPrefabPool prefabPool, Transform spawnParent)
+        {
+            _prefabPool = prefabPool;
+            _spawnParent = spawnParent;
+            
+            // Set parent group reference for each entry
+            foreach (var entry in entries)
+            {
+                entry.SetParentGroup(this);
+            }
+            
+            // Set parent group reference for fallback entry
+            if (fallbackEntry != null)
+            {
+                fallbackEntry.SetParentGroup(this);
+            }
+        }
+        
+        public GameObject Get(string prefabId, Vector3 localPosition = default, Transform customParent = null)
+        {
+            return _prefabPool?.Get(this, prefabId, localPosition, customParent);
+        }
+        
+        public T Get<T>(string prefabId, Vector3 localPosition = default) where T : class
+        {
+            var go = Get(prefabId, localPosition);
+            if (go == null) return default(T);
+            var c = go.GetComponent<T>();
+            return c ?? go.GetComponentWithInterface<T>();
+        }
+        
+        public void Return(GameObject gameObject)
+        {
+            _prefabPool?.Return(this, gameObject);
+        }
+        
+        public Transform SpawnParent => _spawnParent;
+    }
+    
+    public interface IPrefabPool
+    {
+        bool IsReady { get; }
+        void RegisterGroup(PoolGroup group, Transform spawnParent);
+        void SetSpawnParent(string groupId, Transform spawnParent);
+        GameObject Get(PoolGroup group, string prefabId, Vector3 localPosition = default, Transform customParent = null);
+        void Return(PoolGroup group, GameObject gameObject);
+        IEnumerator Initialize();
+    }
+
+    public static class PrefabPoolExtensions
+    {
+        public static void DestroyLast<T>(this List<T> list)  where T : Component
+        {
+            if (list.Count == 0) return;
+            var last = list[list.Count - 1];
+            list.RemoveAt(list.Count-1);
+            if (last == null) return;
+            
+            if (Application.isPlaying)
+            {
+                UnityObject.Destroy(last.gameObject);    
+            }
+            else
+            {
+                UnityObject.DestroyImmediate(last.gameObject);
+            }
+        }
+        
+        public static T ClonePrefab<T>(this GameObject prefab, Transform parent)  where T : Component
+        {
+#if UNITY_EDITOR
+            var c = Application.isPlaying 
+                ? UnityObject.Instantiate(prefab, parent.position, Quaternion.identity, parent)
+                : (GameObject)PrefabUtility.InstantiatePrefab(prefab, parent);
+#else
+            var c = UnityObject.Instantiate(prefab, parent.position, Quaternion.identity, parent);
+#endif
+            return c.GetComponent<T>();
+        }
+        
+        public static void ResetAndClear<T>(this List<T> list, GameObject prefab, PrefabPool pool = null)
+            where T : Component
+        {
+            var usePool = pool != null;
+            
+#if UNITY_EDITOR
+            if (!Application.isPlaying) usePool = false;
+#endif
+            if (usePool)
+            {
+                pool.Resize<T>(prefab, list, 0, null);
+            }
+            else
+            {
+                while (list.Count > 0) list.DestroyLast();
+            }
+        }
+        
+        public static void Resize<T>(this List<T> list, int count, GameObject prefab, Transform parent, PrefabPool pool) where T : Component
+        {
+            var usePool = pool != null;
+            
+#if UNITY_EDITOR
+            if (!Application.isPlaying) usePool = false;
+#endif
+            if (usePool)
+            {
+                pool.Resize<T>(prefab, list, count, parent);
+            }
+            else
+            {
+                while (list.Count > count) list.DestroyLast();
+                while (list.Count < count)
+                {
+                    list.Add(prefab.ClonePrefab<T>(parent));
+                }
+                
+                for (var i = 0; i < list.Count; i++)
+                {
+                    if (list[i] != null) continue;
+                    list[i] = prefab.ClonePrefab<T>(parent);
+                }
+            }
+        }
+    }
+    
+    
+    
+    public class PrefabPool : MonoBehaviour, IPrefabPool
+    {
+        [NonSerialized] private bool _isDestroyed = false;
+        [NonSerialized] private bool _isReady = false;
+        [NonSerialized] private readonly Dictionary<string, PoolGroup> _groups = new Dictionary<string, PoolGroup>();
+        [NonSerialized] private readonly Dictionary<int, PoolEntry> _instanceTypeMap = new Dictionary<int, PoolEntry>();
+        [NonSerialized] private readonly Dictionary<GameObject, PoolEntry> _customPool = new Dictionary<GameObject, PoolEntry>();
+        
+        public void Resize<T>(GameObject prefab, List<T> list, int count, Transform parent) where T: Component
+        {
+            if (_customPool == null)
+            {
+                Debug.LogWarning("Something wrong: _customPool is null!");
+                return;
+            }
+            
+            if (prefab == null)
+            {
+                Debug.LogWarning($"Prefab is null??? {prefab}");
+                return;
+            }
+            
+            if (!_customPool.TryGetValue(prefab, out var entry))
+            {
+                entry = new PoolEntry()
+                {
+                    id = prefab.name,
+                    prefab = prefab
+                };
+                _customPool[prefab] = entry;
+            }
+            
+            while (list.Count > count)
+            {
+                var last = list[list.Count - 1];
+                if (last != null) entry.Return(last.gameObject, transform);
+                list.RemoveAt(list.Count - 1);
+            }
+
+            while (list.Count < count)
+            {
+                var c = entry.Get(transform, parent, Vector3.zero);
+                list.Add(c.GetComponent<T>());
+            }
+        }
+        
+        public bool IsReady => _isReady;
+        
+        public void RegisterGroup(PoolGroup group, Transform spawnParent)
+        {
+            if (group == null) return;
+            
+            _groups[group.id] = group;
+            group.Register(this, spawnParent);
+        }
+        
+        public void SetSpawnParent(string groupId, Transform spawnParent)
+        {
+            if (_groups.TryGetValue(groupId, out var group))
+            {
+                group.Register(this, spawnParent);
+            }
+        }
+        
+        public GameObject Get(PoolGroup group, string prefabId, Vector3 localPosition = default, Transform customParent = null)
+        {
+            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 p = customParent == null ? group.SpawnParent : customParent;
+            var result = entry.Get(transform, p, localPosition);
+            if (result != null)
+            {
+                _instanceTypeMap[result.GetInstanceID()] = entry;
+            }
+            
+            return result;
+        }
+        
+        public void Return(PoolGroup group, GameObject go)
+        {
+            if (_isDestroyed || group == null || go == null) return;
+            
+            var instanceId = go.GetInstanceID();
+            if (_instanceTypeMap.TryGetValue(instanceId, out var entry))
+            {
+                entry.Return(go, transform);
+                _instanceTypeMap.Remove(instanceId);
+            }
+        }
+        
+        public IEnumerator Initialize()
+        {
+            if (_isReady) yield break;
+            _isReady = false;
+            
+            #if UNITY_EDITOR
+            EditorApplication.playModeStateChanged -= HandlePlayModeChanged;
+            EditorApplication.playModeStateChanged += HandlePlayModeChanged;
+            #endif
+            
+            foreach (var group in _groups.Values)
+            {
+                foreach (var entry in group.entries)
+                {
+                    if (entry.prefab == null) continue;
+                    yield return entry.PreAllocate(transform);
+                }
+                
+                // Pre-allocate fallback entry if available
+                if (group.fallbackEntry != null && group.fallbackEntry.prefab != null)
+                {
+                    yield return group.fallbackEntry.PreAllocate(transform);
+                }
+            }
+            
+            _isReady = true;
+        }
+
+#if UNITY_EDITOR
+        protected void HandlePlayModeChanged(PlayModeStateChange changed)
+        {
+            if (changed == PlayModeStateChange.ExitingPlayMode)
+            {
+                DestroyPool();    
+            }
+        }
+#endif
+        
+        public void DestroyPool()
+        {
+            _isDestroyed = true;
+            
+            foreach (var group in _groups.Values)
+            {
+                foreach (var entry in group.entries)
+                {
+                    entry.DestroyPool();
+                }
+                
+                // Destroy fallback entry if available
+                if (group.fallbackEntry != null)
+                {
+                    group.fallbackEntry.DestroyPool();
+                }
+            }
+            
+            _groups.Clear();
+            
+#if UNITY_EDITOR
+            foreach (var kvp in _instanceTypeMap)
+            {
+                var obj = EditorUtility.InstanceIDToObject(kvp.Key);
+                if (obj != null) UnityObject.DestroyImmediate(obj);
+            }
+            _instanceTypeMap.Clear();
+#endif
+        }
+    }
+} 

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "com.amanotes.prefabpool",
+  "version": "1.0.0",
+  "displayName": "Amanotes Prefab Pool",
+  "description": "Generic object pooling system for Unity",
+  "unity": "2022.3",
+  "keywords": [
+    "pooling",
+    "object-pool",
+    "performance",
+    "optimization"
+  ],
+  "author": {
+    "name": "Amanotes",
+    "url": "https://amanotes.com"
+  }
+}