uPools Object Pooling for Unity

If your project includes UniTask, uPools provides asynchronous pooling capabilities via AsyncObjectPool<T>, AsyncObjectPoolBase<T>, and IAsyncObjectPool<T>.

In these pools, Rent(), Prewarm(), and CreateInstance() are asynchronous operations, while other methods remain identical to the standard synchronous pools.

If your project includes UniTask, uPools provides asynchronous pooling capabilities. You can use the following types to perform asynchronous operations like Rent, Prewarm, and CreateInstance:

• AsyncObjectPool<T>
• AsyncObjectPoolBase<T>
• IAsyncObjectPool<T>

These behave similarly to the standard ObjectPool<T> but support async/await patterns.

The simplest way to implement pooling is to use SharedGameObjectPool. This allows you to replace standard Unity Instantiate() and Destroy() calls with Rent() and Return().

• Use SharedGameObjectPool.Prewarm(prefab, count) to prepare a specific number of objects in advance.
• Use SharedGameObjectPool.Rent(prefab) to retrieve an instance.
• Use SharedGameObjectPool.Return(instance) to return an instance to the pool.

using UnityEngine;
using uPools;

public class Example : MonoBehaviour
{
    [SerializeField] GameObject prefab;

    void Start()
    {
        // Pre-warm objects in advance
        SharedGameObjectPool.Prewarm(prefab, 10);

        // Retrieve objects from the pool
        var instance = SharedGameObjectPool.Rent(prefab);

        // Return the object to the pool after use
        SharedGameObjectPool.Return(instance);
    }
}

To install uPools in your Unity project, you can use the Package Manager or manually edit your Packages/manifest.json file.

Requirements:

• Unity 2019.4 or higher

Option 1: Package Manager

1. Open Window > Package Manager.
2. Click the "+" button and select Add package from git URL.
3. Enter the following URL:

https://github.com/AnnulusGames/uPools.git?path=/Assets/uPools

Option 2: manifest.json Add the following dependency to your Packages/manifest.json file:

{
    "dependencies": {
        "com.annulusgames.u-pools" : "https://github.com/AnnulusGames/uPools.git?path=/Assets/uPools"
    }
}

To install uPools, use the Unity Package Manager to add the package via its Git URL.

1. Open Window > Package Manager.
2. Click the + button and select Add package from git URL....
3. Enter the following URL: https://github.com/AnnulusGames/uPools.git?path=/Assets/uPools

Alternatively, you can manually add the dependency to your Packages/manifest.json file.

{
    "dependencies": {
        "com.annulusgames.u-pools" : "https://github.com/AnnulusGames/uPools.git?path=/Assets/uPools"
    }
}

You can implement the IPoolCallbackReceiver interface on your classes to trigger custom logic automatically during the pooling lifecycle.

• For GameObjectPool or SharedGameObjectPool: The system searches for this component on the GameObject or its children. When the object is rented or returned, OnRent() and OnReturn() are invoked.
• For ObjectPool<T> or ObjectPoolBase<T>: The callbacks are invoked if the pooled object itself implements IPoolCallbackReceiver.

Note: If you implement your own IObjectPool<T>, you are responsible for manually invoking these callback methods.

public class CallbackExample : MonoBehaviour, IPoolCallbackReceiver
{
    public void OnRent()
    {
        Debug.Log("Rented");
    }

    public void OnReturn()
    {
        Debug.Log("Returned");
    }
}

When using Unity Addressables, you can use AddressableGameObjectPool to manage the lifecycle of loaded Prefabs. It functions similarly to GameObjectPool but uses an Addressable key instead of a direct GameObject reference.

Key Features:

• Use AddressableGameObjectPool(key) to initialize.
• Supports standard Rent() and Return() methods.
• If UniTask is present, you can use AsyncAddressableGameObjectPool for asynchronous operations.

// Address of the Prefab
var key = "Address";
var pool = new AddressableGameObjectPool(key);

// Usage is the same as GameObjectPool
var instance1 = pool.Rent();
var instance2 = pool.Rent(new Vector3(1f, 2f, 3f), Quaternion.identity);

pool.Return(instance1);
pool.Return(instance2);

pool.Dispose();

Implement the IPoolCallbackReceiver interface on a component to trigger logic automatically when an object is rented or returned.

Behavior by Pool Type:

• GameObjectPool or SharedGameObjectPool: The pool searches the object and its children for components implementing IPoolCallbackReceiver and calls OnRent() or OnReturn() on them.
• ObjectPool<T> or ObjectPoolBase<T>: If the pooled object T implements IPoolCallbackReceiver, the callbacks are triggered.
• Custom IObjectPool<T>: You are responsible for manually calling these callbacks in your implementation.

public class CallbackExample : MonoBehaviour, IPoolCallbackReceiver
{
    public void OnRent()
    {
        Debug.Log("rented");
    }

    public void OnReturn()
    {
        Debug.Log("returned");
    }
}

To implement a custom pooling logic, inherit from ObjectPoolBase<T>. You must override CreateInstance() and can optionally override OnRent, OnReturn, and OnDestroy to handle lifecycle events.

class PooledObject { }

public sealed class CustomObjectPool : ObjectPoolBase<PooledObject>
{
    protected override PooledObject CreateInstance()
    {
        return new PooledObject();
    }

    protected override void OnDestroy(PooledObject instance)
    {
        // Logic for when objects are destroyed via Clear or Dispose
    }

    protected override void OnRent(PooledObject instance)
    {
        // Logic for when an object is rented
    }

    protected override void OnReturn(PooledObject instance)
    {
        // Logic for when an object is returned
    }
}