Pool.cs

// With thanks to Jason Weimann  -- jason@unity3d.college

using System.Collections.Generic;
using UnityEngine;

namespace Askowl {
  /// <a href="http://bit.ly/2BQH2pA">MonoBehaviour to provide pooling functionality for child GameObjects. To be eligible they must be created with `Acquire` and disabled but not destroyed.</a> <inheritdoc />
  public sealed class Pool : MonoBehaviour {
    private bool isPoolContainer;

    private void Start() {
      Fiber.Start.Begin.WaitFor(hasReturns).Do(SetParentOnReturn).Again.Finish();
    }

    private void OnEnable() {
      if (gameObject.name.EndsWith("Pool") || GetComponents<Component>().Length <= 2) {
        isPoolContainer = true;
        // This is a list of predefined game objects to be pooled
        DontDestroyOnLoad(target: gameObject);
        Transform[] children = GetComponentsInChildren<Transform>();

        // skip first as it is the Pool itself
        for (var i = 1; i < children.Length; ++i) CreatePoolQueue(children[i].gameObject);
      }
      else if (!queues.ContainsKey(gameObject.name)) {
        Destroy(this);
        // we are inside a game object that wants to be pooled
        PoolFor(gameObject.GetComponent<PoolMonitor>()?.MasterName ?? gameObject.name);
      }
    }

    private PoolQueue CreatePoolQueue(GameObject master) {
      string poolName = $"{master.name} Pool";

      if (!queues.ContainsKey(poolName)) {
        PoolMonitor poolMonitor = master.AddComponent<PoolMonitor>();
        poolMonitor.MasterName = master.name;
        queues[poolName] = new PoolQueue {Master = master, Parent = master.transform.parent};
        GameObject poolRoot = new GameObject(poolName);
        poolRoot.transform.parent = transform;
        master.transform.SetParent(poolMonitor.PoolRoot = poolRoot.transform, worldPositionStays: false);
        master.SetActive(true);
        return queues[poolName];
      }

      return null;
    }

    /// <a href="http://bit.ly/2QdJ6kr">Use `Pool.Acquire&lt;T>()` to get a reference to a cloned gameObject instead of `Instantiate&lt;T>()`. All parameters bar name are optional.</a>
    public static T Acquire<T>(
      string name, Vector3 position = default, Quaternion rotation = default, Transform parent = default
      , bool enable = true, bool poolOnDisable = true) where T : Component {
      GameObject clone = Acquire(name, position, rotation, parent, enable, poolOnDisable);
      return clone == null ? null : clone.GetComponent<T>();
    }

    /// <a href="http://bit.ly/2BQvdQi">Use `Pool.Acquire()` to get a reference to a cloned gameObject instead of `Instantiate()`. All parameters bar name are optional.</a>
    public static GameObject Acquire(
      string name,
      Vector3 position = default,
      Quaternion rotation = default,
      Transform parent = null,
      bool enable = true,
      bool poolOnDisable = true) {
      PoolQueue pool = PoolFor(name);
      if (pool == null) return null;

      GameObject clone;
      PoolMonitor poolMonitor;

      do {
        clone = pool.Fetch();
        poolMonitor = clone.gameObject.GetComponent<PoolMonitor>();
      } while (!poolMonitor.OkToPool);

      if (parent != null) clone.transform.SetParent(parent);
      clone.transform.position = position;
      clone.transform.rotation = rotation;
      poolMonitor.PoolOnDisable = poolOnDisable;
      clone.gameObject.SetActive(enable);
      poolMonitor.InPool = false;
      poolMonitor.OkToPool = true;
      return clone;
    }

    /// <a href="http://bit.ly/2BScbco">Give an object created by `Acquire` in any pool, return it to the pool for reuse. Only needed if `poolOnDisable` is false</a>
    public static void Return(GameObject clone) {
      returns.Push(clone);
      if (returns.Count == 1) hasReturns.Fire();
    }

    private static readonly Fifo<GameObject> returns = Fifo<GameObject>.Instance;
    private static readonly Emitter hasReturns = Emitter.Instance;

    private void SetParentOnReturn(Fiber fiber) {
      while (!returns.Empty) {
        GameObject clone = returns.Pop();

        PoolMonitor poolMonitor = clone.GetComponent<PoolMonitor>();
        PoolQueue pool = PoolFor(poolMonitor.MasterName);

        if (pool != null) {
          poolMonitor.InPool = poolMonitor.OkToPool = true;
          pool.Push(clone);
          if (clone.transform.parent != poolMonitor.PoolRoot) clone.transform.SetParent(poolMonitor.PoolRoot, false);
        }
        else {
          Debug.LogErrorFormat("**** Error: {0} was not created in a pool", clone.name);
        }

        clone.SetActive(false);
      }
    }

    /// <a href="http://bit.ly/2QzQENF">Retrieve a reference to the pooling queue for the GameObject named</a>
    public static PoolQueue PoolFor(string name, Pool pool = null) {
      string poolName = $"{name} Pool";
      if (queues.ContainsKey(poolName)) return queues[poolName];

      GameObject gameObject = Objects.Find<GameObject>(name);

      if (gameObject == null) {
        gameObject = Resources.Load<GameObject>(name);

        if (gameObject == null) {
          Debug.LogErrorFormat("Cannot find Prefab or loaded GameObject named '{0}'", name);
          return null;
        }
      }

      // instantiate if it is a prefab
      if (gameObject.scene.name == null) {
        gameObject = Instantiate(gameObject);
        gameObject.name = name;
      }

      var monitor = gameObject.GetComponent<PoolMonitor>();
      if (monitor != null) return queues[poolName] = queues[monitor.MasterName];

      var queue = (pool ? pool : FindPool()).CreatePoolQueue(gameObject);
      if (!queues.ContainsKey(name)) queues[name] = queue; // name may be a path to the prefab
      return queue;
    }

    private static Pool FindPool() {
      Pool pool = null;
      var anyMonitor = FindObjectOfType<PoolMonitor>();

      if (anyMonitor != null) pool = anyMonitor.GetComponentInParent<Pool>();

      if (pool == null) {
        var pools = FindObjectsOfType<Pool>();

        for (var i = 0; i < pools.Length && pool == null; i++) {
          if (pools[i].isPoolContainer) pool = pools[i];
        }
      }

      if (pool == null) pool = Components.Create<Pool>("Pool");
      return pool;
    }

    private sealed class PoolDict : Dictionary<string, PoolQueue> { }

    private static readonly PoolDict queues = new PoolDict();

    /// <a href="">Each GameObject enabled for pooling resides in a `PoolQueue`.</a>  <inheritdoc />
    public sealed class PoolQueue : Fifo<GameObject> {
      /// <a href="">Master GameObject from which copies are cloned</a>
      public GameObject Master;

      /// <a href=""></a>
      public Transform Parent;

      private int count;

      /// <a href="">Fetch a cloned GameObject - either from a list of those returned or instantiating a new instance</a>
      public GameObject Fetch() {
        GameObject clone;

        if (Count > 0) {
          clone = Pop();
        }
        else {
          clone = Instantiate(Master);
          clone.name = $"{Master.name} (clone {++count})";
        }

        clone.transform.SetParent(Parent);

        return clone;
      }
    }
  }
}