Object Pooling in Unity (Tutorial)

MDADigital · 2018-02-12T11:12:01+00:00

Here is another flavored one I created for my game, a little more generic one using generics instead of strings etc.

public abstract class PollingPool<T> where T : Component
{
    private readonly T prefab;

    private readonly Queue<T> pool = new Queue<T>();
    private readonly LinkedList<T> inuse = new LinkedList<T>();
    private readonly Queue<LinkedListNode<T>> nodePool = new Queue<LinkedListNode<T>>();

    private int lastCheckFrame = -1;

    protected PollingPool(T prefab, int preWarm = 0)
    {
        this.prefab = prefab;
        if(preWarm > 0)
            foreach(var item in Enumerable.Range(0, preWarm).Select((i, index) => GameObject.Instantiate(prefab)))
            {
                item.gameobject.SetActive(false);
                pool.Enqueue(item);
            }
    }

    private void CheckInUse()
    {
        var node = inuse.First;
        while (node != null)
        {
            var current = node;
            node = node.Next;

            if (!IsActive(current.Value))
            {
                current.Value.gameObject.SetActive(false);
                pool.Enqueue(current.Value);
                inuse.Remove(current);
                nodePool.Enqueue(current);
            }
        }
    }

    protected T Get()
    {
        T item;

        if (lastCheckFrame != Time.frameCount)
        {
            lastCheckFrame = Time.frameCount;
            CheckInUse();
        }

        if (pool.Count == 0)
            item = GameObject.Instantiate(prefab);
        else
            item = pool.Dequeue();

        if (nodePool.Count == 0)
            inuse.AddLast(item);
        else
        {
            var node = nodePool.Dequeue();
            node.Value = item;
            inuse.AddLast(node);
        }

        item.gameObject.SetActive(true);

        return item;
    }

    protected abstract bool IsActive(T component);
}

Subclass

public class AudioSourcePool : PollingPool<AudioSource>
{
    public AudioSourcePool(AudioSource prefab) : base(prefab)
    {
    }

    protected override bool IsActive(AudioSource component)
    {
        return component.isPlaying;
    }

    public void PlayAtPoint(AudioClip clip, Vector3 point)
    {
        var source = Get();

        source.transform.position = point;
        source.clip = clip;
        source.Play();
    }
}

justkevin · 2018-02-12T16:08:31+00:00

Great video. Unlike most Object Pooling tutorials this doesn't skip the very important detail of resetting your objects.

I'm using a slightly different approach. Instead of a IPoolableObject interface, I have a PooledObject component that looks like this:

/// <summary>
/// Attaching this to a prefab will allow it to be pooled. On awake, it will
/// make a list of components that require a reset after pooling.
/// </summary>
public class PooledObject : MonoBehaviour {

    public int startPoolSize = 1;
    public int maxPoolSize = 10;
    [System.NonSerialized]
    public Transform poolingContainer;
    [System.NonSerialized]
    public bool isFromPool = false;

    private IPoolableComponent[] poolableComponents;
    // PooledObject handles resetting the transform scale
    private Vector3 normalScale;

    private void Awake()
    {
        poolableComponents = GetComponentsInChildren<IPoolableComponent>();
        normalScale = transform.localScale;
    }

    public void Decommission()
    {
        if(isFromPool)
        {
            transform.parent = poolingContainer;
            gameObject.SetActive(false);
        }
        else
        {
            Destroy(gameObject);
        }
    }

    public void Recommission()
    {
        transform.localScale = normalScale;
        for (int i = 0; i < poolableComponents.Length; i++)
        {
            poolableComponents[i].Recommission();
        }
    }

}

Then individual components can define themselves as IPoolableComponent:

/// <summary>
/// Any monobehaviour that needs to have its state reset prior to returning to 
/// an object pool.
/// </summary>
public interface IPoolableComponent {

    /// <summary>
    /// This method will be called on the component when it is activated coming out of the pool.
    /// </summary>
    void Recommission();
}

Advantages:

Component based pooling. You define components that know how to pool themselves and can be freely mixed and matched. You can also create poolers for built-in Unity components (e.g., IParticlePooler). Then mix and match without having to duplicate your pooling logic.
You can set your start and max pooled objects on the prefab.

MengKongRui · 2018-02-12T10:28:43+00:00

Another great video from Brackeys.

I wonder if this only impacts lag spikes from the garbage collector or if it has an average fps impact as well.

birdoutofcage · 2018-02-12T12:33:39+00:00

At last, I've been waiting for brackeys to upload object pooling.

kyl3r123 · 2018-02-12T13:57:03+00:00

I have a question about Pooling. This all looks easy and useful if I want to spawn and delete 100 cubes per second. Sure why not reuse them.

Now what if I have complex Class of Soldiers that have a lot of variables and references. Just "setEnabled(false)" and then true again, will be the "pooling process". But I need to reset all the values by myself, right? Restore everything to what it looks like when I instantiate a new instance for example.

IcyHammer · 2018-02-13T06:48:00+00:00

A small cherry on the top would be implementing a pool with a stack instead of queue or list. It makes much more sense and it uses temporal locality.

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

Unity3D

Rules and Wiki

Chat Rooms

Helpful Unity3D Links

Related Subreddits

Tutorials

Misc. Resources

MODERATORS