Pool.cs

using UnityEngine;
using System.Collections.Generic;

/// <summary>
/// Fast implementation of Pool object using array as a stack
/// </summary>
public class Pool
{
    #region variables

    private int size = 2; // initial size of the pool
    private GameObject m_poolObject; // Prefab that will be instatitated
    private Transform m_objectsHolder; // Prefab that will be instatitated
    private GameObject[] m_poolStack;

    private int m_activeCount; // number of objects currently on scene
    private int m_inactiveCount; // number of objects in the pool ready for spawning

    #endregion

    #region getters/setters

    /// <summary>
    /// Number of active spawned GameObjects
    /// </summary>
    public int ActiveCount
    {
        get { return m_activeCount; }
    }

    /// <summary>
    /// Number of inactive GameObjects in pool stack
    /// </summary>
    public int InactiveCount
    {
        get { return m_inactiveCount; }
    }

    #endregion

    #region methods

    /// <summary>
    /// Creates a new Pool for holding game objects.
    /// </summary>
    /// <param name="pooledObject">GameObject prefab to spawn</param>
    /// <param name="parentTransform">Transform parent for spawned objects. If the value is left as null, 
    /// the spawned objects will be attached to scene root.</param>
    public Pool(GameObject pooledObject, Transform parentTransform = null)
    {
        m_poolStack = new GameObject[size];
        m_objectsHolder = parentTransform;
        m_poolObject = pooledObject;
    }


    /// <summary>
    /// Spawns the object. Note that the Awake() and Start() will be called only once. OnDisable() and OnEnable() will be called insted,
    /// since the method calls SetActive(true) on spawned Object;
    /// </summary>
    /// <returns>Instance from prefab</returns>
    public T Spawn<T>() where T : Component
    {
        return Spawn<T>(Vector3.zero);
    }

    /// <summary>
    /// Spawns the object with desired position. Note that the Awake() and Start() will be called only once. OnDisable() and OnEnable() will be called insted,
    /// since the method calls SetActive(true) on spawned Object;
    /// </summary>
    /// <param name="position">Position where the object shoul be spawned</param>
    /// <returns>Instance from prefab</returns>

    public T Spawn<T>(Vector3 position) where T : Component
    {
        return Spawn<T>(position, Quaternion.identity);
    }

    /// <summary>
    /// Spawns the object with desired position and rotation. Note that the Awake() and Start() will be called only once. OnDisable() and OnEnable() will be called insted,
    /// since the method calls SetActive(true) on spawned Object;
    /// </summary>
    /// <param name="position">Position where the object shoul be spawned</param>
    /// <param name="rotation">Rotation of the spawned object</param>
    /// <returns></returns>
    public T Spawn<T>(Vector3 position, Quaternion rotation) where T : Component
    {
        GameObject go; // object to return

        if (m_inactiveCount == 0)
        {
            if (m_objectsHolder == null)
            {
                go = GameObject.Instantiate(m_poolObject, position, rotation);
            }
            else
            {
                go = GameObject.Instantiate(m_poolObject, position, rotation, m_objectsHolder);
            }

            PoolObject po = go.GetComponent<PoolObject>();
            if(po == null) po = go.AddComponent<PoolObject>();

            po.Init(this);
        }
        else
        {
            go = m_poolStack[--m_inactiveCount];
        }

        // set position and rotation
        go.transform.position = position; 
        go.transform.rotation = rotation;
        go.gameObject.SetActive(true);

        // increment active count
        m_activeCount++;
        return go.GetComponent<T>();
    }

    /// <summary>
    /// Returns the GameObject back to pool 
    /// </summary>
    /// <param name="go"></param>
    public void ReturnToPool(GameObject go)
    {
        if (m_inactiveCount == m_poolStack.Length)
        {
            // Double the pools size if it's full.
            EnlargeStack(size * 2);
        }

        go.SetActive(false);

        m_activeCount--; // decrement active count
        m_poolStack[m_inactiveCount++] = go;
    }

    /// <summary>
    /// Enlarges the pool stack by provided size
    /// </summary>
    /// <param name="newSize"></param>
    private void EnlargeStack(int newSize)
    {
        if (newSize <= size) return; // if new size is same or less size

        GameObject[] tmp = new GameObject[newSize];
        for (int i = 0; i < size; i++)
        {
            tmp[i] = m_poolStack[i];
        }
        m_poolStack = tmp;
        size = newSize;
    }

    #endregion
}