com.amanotes.prefabpool 1.0.0 → 1.0.2

package/Tests/Runtime/PrefabPoolLifecycleTests.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9c6969a47577843fb977ab5e2c7c1ad2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tests/Runtime/PrefabPoolPerformanceTests.cs

@@ -0,0 +1,212 @@
+using System.Collections;
+using NUnit.Framework;
+using Unity.PerformanceTesting;
+using UnityEngine;
+using UnityEngine.TestTools;
+using UnityObject = UnityEngine.Object;
+
+namespace Amanotes.Core
+{
+    public class PrefabPoolPerformanceTests
+    {
+        private PrefabPool _pool;
+        private GameObject _testPrefab;
+        private PoolGroup _testGroup;
+        private Transform _spawnParent;
+        
+        [SetUp]
+        public void SetUp()
+        {
+            var poolObject = new GameObject("TestPool");
+            _pool = poolObject.AddComponent<PrefabPool>();
+            
+            var spawnParentObject = new GameObject("SpawnParent");
+            _spawnParent = spawnParentObject.transform;
+            
+            _testPrefab = new GameObject("TestPrefab");
+            _testPrefab.AddComponent<MockPoolPrefab>();
+            
+            _testGroup = new PoolGroup
+            {
+                id = "TestGroup",
+                entries = new System.Collections.Generic.List<PoolEntry>
+                {
+                    new PoolEntry
+                    {
+                        id = "TestPrefab",
+                        prefab = _testPrefab,
+                        prewarmCount = 10
+                    }
+                }
+            };
+            
+            _pool.RegisterGroup(_testGroup, _spawnParent);
+        }
+        
+        [TearDown]
+        public void TearDown()
+        {
+            if (_pool != null)
+            {
+                _pool.DestroyPool();
+                UnityObject.DestroyImmediate(_pool.gameObject);
+            }
+            
+            if (_spawnParent != null)
+            {
+                UnityObject.DestroyImmediate(_spawnParent.gameObject);
+            }
+            
+            if (_testPrefab != null)
+            {
+                UnityObject.DestroyImmediate(_testPrefab);
+            }
+            
+            var allObjects = UnityObject.FindObjectsOfType<GameObject>();
+            foreach (var obj in allObjects)
+            {
+                if (obj.hideFlags == HideFlags.DontSave)
+                {
+                    UnityObject.DestroyImmediate(obj);
+                }
+            }
+        }
+        
+        [UnityTest, Performance]
+        public IEnumerator Performance_GetReturnCycles()
+        {
+            yield return _pool.Initialize();
+            
+            Measure.Method(() =>
+            {
+                for (int i = 0; i < 1000; i++)
+                {
+                    var obj = _testGroup.Get("TestPrefab");
+                    _testGroup.Return(obj);
+                }
+            })
+            .WarmupCount(5)
+            .MeasurementCount(10)
+            .IterationsPerMeasurement(1)
+            .GC()
+            .Run();
+        }
+        
+        [UnityTest, Performance]
+        public IEnumerator Performance_GCAllocation()
+        {
+            yield return _pool.Initialize();
+            
+            Measure.Method(() =>
+            {
+                for (int i = 0; i < 100; i++)
+                {
+                    var obj = _testGroup.Get("TestPrefab");
+                    _testGroup.Return(obj);
+                }
+            })
+            .WarmupCount(5)
+            .MeasurementCount(10)
+            .IterationsPerMeasurement(1)
+            .GC()
+            .Run();
+        }
+        
+        [UnityTest, Performance]
+        public IEnumerator Performance_PoolExpansion()
+        {
+            yield return _pool.Initialize();
+            
+            var retrievedObjects = new System.Collections.Generic.List<GameObject>();
+            
+            for (int i = 0; i < 10; i++)
+            {
+                var obj = _testGroup.Get("TestPrefab");
+                retrievedObjects.Add(obj);
+            }
+            
+            Measure.Method(() =>
+            {
+                for (int i = 0; i < 100; i++)
+                {
+                    var obj = _testGroup.Get("TestPrefab");
+                    retrievedObjects.Add(obj);
+                }
+            })
+            .WarmupCount(2)
+            .MeasurementCount(10)
+            .IterationsPerMeasurement(1)
+            .GC()
+            .Run();
+            
+            foreach (var obj in retrievedObjects)
+            {
+                _testGroup.Return(obj);
+            }
+        }
+        
+        [UnityTest, Performance]
+        public IEnumerator Performance_ParentTransformOverhead()
+        {
+            yield return _pool.Initialize();
+            
+            var withParentTime = 0.0;
+            var withoutParentTime = 0.0;
+            
+            Measure.Method(() =>
+            {
+                for (int i = 0; i < 100; i++)
+                {
+                    var obj = _testGroup.Get("TestPrefab");
+                    _testGroup.Return(obj);
+                }
+            })
+            .WarmupCount(5)
+            .MeasurementCount(10)
+            .IterationsPerMeasurement(1)
+            .GC()
+            .Run();
+            
+            var poolObjectNoParent = new GameObject("TestPoolNoParent");
+            var poolNoParent = poolObjectNoParent.AddComponent<PrefabPool>();
+            
+            var prefabNoParent = new GameObject("TestPrefabNoParent");
+            prefabNoParent.AddComponent<MockPoolPrefab>();
+            
+            var groupNoParent = new PoolGroup
+            {
+                id = "TestGroupNoParent",
+                entries = new System.Collections.Generic.List<PoolEntry>
+                {
+                    new PoolEntry
+                    {
+                        id = "TestPrefab",
+                        prefab = prefabNoParent,
+                        prewarmCount = 10
+                    }
+                }
+            };
+            
+            poolNoParent.RegisterGroup(groupNoParent, null);
+            yield return poolNoParent.Initialize();
+            
+            Measure.Method(() =>
+            {
+                for (int i = 0; i < 100; i++)
+                {
+                    var obj = groupNoParent.Get("TestPrefab");
+                    groupNoParent.Return(obj);
+                }
+            })
+            .WarmupCount(5)
+            .MeasurementCount(10)
+            .IterationsPerMeasurement(1)
+            .GC()
+            .Run();
+            
+            poolNoParent.DestroyPool();
+            UnityObject.DestroyImmediate(poolObjectNoParent);
+            UnityObject.DestroyImmediate(prefabNoParent);
+        }
+    }
+}

package/Tests/Runtime/PrefabPoolPerformanceTests.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 16aa39925a01643c3894a56145c56a21
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tests/Runtime/PrefabPoolTestsSetup.cs

@@ -0,0 +1,14 @@
+using NUnit.Framework;
+using Amanotes.Core;
+
+namespace Amanotes.Core
+{
+    public class PrefabPoolTestsSetup
+    {
+        [Test]
+        public void TestInfrastructureVerification()
+        {
+            Assert.IsTrue(true, "PrefabPool test infrastructure is working");
+        }
+    }
+}

package/Tests/Runtime/PrefabPoolTestsSetup.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e61f89af128b84b429ac96d86bd0554f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tests/Runtime/TestHelpers/MockPoolPrefab.cs

@@ -0,0 +1,26 @@
+using UnityEngine;
+
+namespace Amanotes.Core
+{
+    public class MockPoolPrefab : MonoBehaviour, IPoolPrefab
+    {
+        public int getCallCount;
+        public int returnCallCount;
+        
+        public void OnGet()
+        {
+            getCallCount++;
+        }
+        
+        public void OnReturn()
+        {
+            returnCallCount++;
+        }
+        
+        public void ResetCounts()
+        {
+            getCallCount = 0;
+            returnCallCount = 0;
+        }
+    }
+}

package/Tests/Runtime/TestHelpers/MockPoolPrefab.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8e7402f0e0f2440338429ebbb480ffc3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tests/Runtime/TestHelpers.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 2ce9db2584cc4444f930d1ab257afcaf
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tests/Runtime.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: f4d670095ee40448b93f6f5dbc2c07e6
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tests.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 518067fd8d1ac4415b0468af746cce4a
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.amanotes.prefabpool",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "displayName": "Amanotes Prefab Pool",
   "description": "Generic object pooling system for Unity",
   "unity": "2022.3",

package/package.json.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 731d4216942564520bcc6d75236cd757
+PackageManifestImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Amanotes.PrefabPool.asmdef

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

package/Runtime/MeshRendererExtensions.cs

@@ -1,80 +0,0 @@
-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);
-        }
-    }
-}