Fixed objects not getting unpooled when they were reactivated without going through the component pool API (enabling component or activating game object)

Author: jeffbert

CHANGELOG.md

@@ -4,6 +4,12 @@ All notable changes to this package will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
+## [1.0.9] - 2024-02-11
+
+### Fixed
+
+- Fixed objects not getting unpooled when they were reactivated without going through the component pool API (enabling component or activating game object).
+
 ## [1.0.8] - 2024-02-01
 
 ### Changes
@@ -16,12 +22,6 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 - Added preprocessor directives for unit tests.
 
-## [1.0.6] - 2024-01-23
-
-### Fixed
-
-- Fixed objects not getting unpooled when they were reactivated without going through the component pool API (enabling component or activating game object).
-
 ## [1.0.3] - 2022-11-21
 
 ### Fixed

Editor/CustomEditors.meta

@@ -7,11 +7,11 @@ namespace Bert.Pool.Internal
     /// Pool of <see cref="PoolObject"/> instances.
     /// </summary>
     /// <typeparam name="T">Type of component.</typeparam>
-    internal sealed class PoolContainer<T> : IPoolObjectManager 
+    internal sealed class PoolContainer<T> : IPoolObjectManager
         where T : Component
     {
         private static readonly string PoolInstanceSuffix = $" (Pool: {typeof(T).Name})";
-        
+
         private const int DefaultCapacity = 8;
 
         private readonly List<(PoolObject poolInstance, T component)> _instances = new List<(PoolObject, T)>(DefaultCapacity);
@@ -55,17 +55,17 @@ public T GetInstance(T source, Vector3 position, Quaternion rotation, Transform
         /// </summary>
         public T CreateInstance(Object source, Vector3 position, Quaternion rotation, Transform parent)
         {
-            T instance = (T) Object.Instantiate(source, position, rotation, parent);
+            T instance = (T)Object.Instantiate(source, position, rotation, parent);
             instance.gameObject.SetActive(true);
-            
+
 #if UNITY_EDITOR
             instance.name = GetPoolInstanceName(instance.name);
 #endif
 
             var poolObject = instance.gameObject.AddComponent<PoolObject>();
             poolObject.SetManager(this);
             poolObject.Index = _instances.Count;
-            
+
             _instances.Add((poolObject, instance));
 
             return instance;
@@ -89,29 +89,33 @@ public void DestroyInstances()
         /// <inheritdoc />
         public void UnPool(PoolObject poolObject)
         {
+            // Un-pooled object's position in the list will be swapped with the first pooled instance.
+            int swapIndex = _instances.Count - _poolCount;
+
             --_poolCount;
+
+            // Manually un-pooling objects without going through the API should be less common, so an extra check is added to avoid unnecessary swaps.
+            if (poolObject.Index != swapIndex)
+            {
+                Swap(poolObject.Index, swapIndex);
+            }
         }
 
         /// <inheritdoc />
         public void Pool(PoolObject poolObject)
         {
             ++_poolCount;
-            int targetIndex = _instances.Count - _poolCount;
-            int activeIndex = poolObject.Index;
-            
+
             // Swap pooled object with last active instance in the list.
-            (_instances[activeIndex], _instances[targetIndex]) = (_instances[targetIndex], _instances[activeIndex]);
-            
-            _instances[activeIndex].poolInstance.Index = activeIndex;
-            _instances[targetIndex].poolInstance.Index = targetIndex;
+            Swap(poolObject.Index, _instances.Count - _poolCount);
         }
 
         /// <inheritdoc />
         public void Destroy(PoolObject poolObject)
         {
             // Instances are pooled on disable so they need to be un-pooled here.
             --_poolCount;
-            
+
             int destroyedIndex = poolObject.Index;
             int lastIndex = _instances.Count - 1;
 
@@ -121,6 +125,14 @@ public void Destroy(PoolObject poolObject)
             _instances.RemoveAt(lastIndex);
         }
 
+        private void Swap(int x, int y)
+        {
+            (_instances[x], _instances[y]) = (_instances[y], _instances[x]);
+
+            _instances[x].poolInstance.Index = x;
+            _instances[y].poolInstance.Index = y;
+        }
+
         private static string GetPoolInstanceName(string name)
         {
             int endIndex = name.Length - "(Clone)".Length;
@@ -130,4 +142,4 @@ private static string GetPoolInstanceName(string name)
             return name.Substring(0, endIndex) + PoolInstanceSuffix;
         }
     }
-}
+}

Editor/PropertyDrawers.meta

@@ -13,14 +13,14 @@ internal class PoolContainerTests
     {
         private PoolContainer<MockMonoBehaviour> _container;
         private MockMonoBehaviour _source;
-        
+
         private MockMonoBehaviour GetInstance() => _container.GetInstance(_source, Vector3.zero, Quaternion.identity, null);
-        
+
         [SetUp]
         public void Setup()
         {
             _container = new PoolContainer<MockMonoBehaviour>();
-            _source =  new GameObject(nameof(MockMonoBehaviour)).AddComponent<MockMonoBehaviour>();
+            _source = new GameObject(nameof(MockMonoBehaviour)).AddComponent<MockMonoBehaviour>();
         }
 
         [TearDown]
@@ -96,23 +96,40 @@ public void DeactivatingGameObject_PoolsInstance()
 
             Object.DestroyImmediate(instance.gameObject);
         }
-        
+
         [UnityTest]
-        public IEnumerator ActivatingGameObject_ShouldUnPoolInstance()
+        public IEnumerator ActivatingGameObjectManually_ShouldUnPool_InstanceFromPool()
         {
-            var instance = GetInstance();
-            instance.gameObject.SetActive(false);
+            var instance1 = GetInstance();
+            var instance2 = GetInstance();
+            var instance3 = GetInstance();
+
+            // Deactivating the instances in reverse order will preserves their order in the collection.
+            instance3.gameObject.SetActive(false);
+            instance2.gameObject.SetActive(false);
+            instance1.gameObject.SetActive(false);
 
             yield return null;
 
-            instance.gameObject.SetActive(true);
-            
-            // New instance should be created since the previous instance was un-pooled.
-            var newInstance = GetInstance();
-            UnityEngine.Assertions.Assert.AreNotEqual(instance, newInstance);
+            // Activating the instance without going through the API should still un-pool it.
+            instance2.gameObject.SetActive(true);
+
+            // Ensures that the correct instance is returned after un-pooling the other instance manually.
+            var expected1 = GetInstance();
+            var expected3 = GetInstance();
+
+            // Ensure the manually un-pooled instance doesn't get returned.
+            var instance4 = GetInstance();
 
-            Object.DestroyImmediate(instance.gameObject);
-            Object.DestroyImmediate(newInstance.gameObject);
+            UnityEngine.Assertions.Assert.AreEqual(instance1, expected1);
+            UnityEngine.Assertions.Assert.AreEqual(instance3, expected3);
+            UnityEngine.Assertions.Assert.AreNotEqual(instance3, instance4);
+            Assert.That(_container.InstanceCount, Is.EqualTo(4));
+
+            Object.DestroyImmediate(instance1.gameObject);
+            Object.DestroyImmediate(instance2.gameObject);
+            Object.DestroyImmediate(instance3.gameObject);
+            Object.DestroyImmediate(instance4.gameObject);
         }
 
         [Test]
@@ -155,4 +172,4 @@ public IEnumerator DestroyInstances_ShouldDestroyInstances()
     }
 }
 
-#endif
+#endif

Runtime/Internal/PoolContainer.cs

@@ -1,6 +1,6 @@
 {
   "name": "com.jeffbert.unity-component-pool",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "displayName": "Component Pool",
   "description": "Pooling system designed to work with Unity components. Reduces memory allocations by reusing disabled components.",
   "unity": "2019.4",