// Use this for initialization
void InitializePool()
{
containerObject = new GameObject("ObjectPool");
containerObject.transform.parent = transform;
//Loop through the object prefabs and make a new list for each one.
//We do this because the pool can only support prefabs set to it in the editor,
//so we can assume the lists of pooled objects are in the same order as object prefabs in the array
pool = new List <GameObject> [entries.Length];
for (int i = 0; i < entries.Length; i++)
{
ObjectPoolEntry objectPrefab = entries[i];
//create the repository
pool[i] = new List <GameObject>();
//fill it
for (int n = 0; n < objectPrefab.count; n++)
{
if (objectPrefab.prefab)
{
GameObject newObj = Instantiate(objectPrefab.prefab) as GameObject;
newObj.name = objectPrefab.prefab.name;
PoolObject(newObj);
}
}
}
}
/// <summary>
/// Gets a new object for the name type provided. If no object type exists or if onlypooled is true and there is no objects of that type in the pool
/// then null will be returned.
/// </summary>
/// <returns>
/// The object for type.
/// </returns>
/// <param name='objectName'>
/// Object type.
/// </param>
/// <param name='onlyPooled'>
/// If true, it will only return an object if there is one currently pooled.
/// </param>
public GameObject GetObjectForType(string objectName, bool onlyPooled)
{
if (!entriesByName.ContainsKey(objectName))
{
Debug.Log("cant find " + objectName);
return(null);
}
ObjectPoolEntry objectPoolEntry = entriesByName[objectName];
if (objectPoolEntry.objectsInPool > 0)
{
GameObject pooledObject = objectPoolEntry.pool[--objectPoolEntry.objectsInPool];
pooledObject.transform.parent = null;
pooledObject.SetActive(true);
return(pooledObject);
}
else if (!onlyPooled)
{
GameObject obj = Instantiate(objectPoolEntry.Prefab);
obj.name = obj.name.Substring(0, obj.name.Length - CLONE_NAME_LENGTH);
objectPoolEntry.pool.Add(obj);
return(obj);
}
return(null);
}
// Use this for initialization
private void Start()
{
//Loop through the object prefabs and make a new list for each one.
//We do this because the pool can only support prefabs set to it in the editor,
//so we can assume the lists of pooled objects are in the same order as object prefabs in the array
for (int i = 0; i < Entries.Count; i++)
{
ObjectPoolEntry objectPoolEntry = Entries[i];
entriesByName.Add(objectPoolEntry.Prefab.name, objectPoolEntry);
//create the repository
objectPoolEntry.pool = new List <GameObject>(objectPoolEntry.Count);
//fill it
for (int n = 0; n < objectPoolEntry.Count; n++)
{
GameObject newObj = (GameObject)Instantiate(objectPoolEntry.Prefab, transform);
newObj.name = objectPoolEntry.Prefab.name;
newObj.SetActive(false);
}
}
if (PoolingInitialisationCompletedEvent != null)
{
PoolingInitialisationCompletedEvent();
}
}
/// <summary>
/// Creates new entry in objectpool and registers the given object type. Instances are automatically created (pCount).
/// </summary>
/// <param name="pPrefabToPool"> Prefab to pool.</param>
/// <param name="pObjectType"> The object type of the prefab.</param>
/// <param name="pCount"> Number of instances of the prefab, which are created automatically.</param>
public void CreateNewObjectPoolEntry(GameObject pPrefabToPool, int pObjectType, int pCount)
{
mListIndex++;
var newEntry = new ObjectPoolEntry();
newEntry.Initialize(pPrefabToPool, mListIndex, pCount);
mListOfGameobjectStacks.Add(newEntry);
mDictionaryOfObjectTypeIndex.Add(pObjectType, mListIndex);
}
public static GameObject PopObject(string poolName)
{
ObjectPoolEntry pool = GetPool(poolName);
if (pool == null)
{
throw new InvalidOperationException(string.Format("Object pool {0} does not exist", poolName));
}
return(pool.Pop());
}
public void RecycleObject(GameObject recycleMe, ObjectPoolEntry retrunToPool)
{
//I don't love needing to specify which pool it needs to be returned to. I'll fix this later.
if (retrunToPool == null)
{
//belongs to no pool, just disable it.
recycleMe.SetActive(false);
return;
}
retrunToPool.Recycle(recycleMe);
}
public int GetPoolID(string poolName)
{
for (int i = 0; i < objectPools.Length; i++)
{
ObjectPoolEntry o = objectPools[i];
if (o.Name == poolName)
{
return(i);
}
}
return(-1);
}
ObjectPoolEntry GetPoolFromName(string objName)
{
ObjectPoolEntry result = null;
foreach (ObjectPoolEntry o in objectPools)
{
if (o.Name == objName)
{
result = o;
}
}
return(result);
}
public static void PushObject(string poolName, GameObject go)
{
if (go == null)
{
throw new ArgumentNullException(string.Format("Trying to pool a null game object in pool {0}", poolName));
}
ObjectPoolEntry pool = GetPool(poolName);
if (pool == null)
{
throw new InvalidOperationException(string.Format("Object pool {0} does not exist", poolName));
}
pool.Push(go);
}
private void UpdateObjectPoolEntry()
{
Entries.Clear();
List <GameObject> _prefabs = Resources.LoadAll <GameObject>(OBJECT_POOL_ENTRIES_PATH).ToList();
foreach (GameObject _prefab in _prefabs)
{
ObjectPoolEntry objectPoolEntry = new ObjectPoolEntry
{
Prefab = _prefab,
};
Entries.Add(objectPoolEntry);
}
}
/// <summary>
/// Pools the object specified. Will not be pooled if there is no prefab of that type.
/// </summary>
/// <param name='obj'>
/// Object to be pooled.
/// </param>
public void PoolObject(GameObject obj, bool resetRigidbody = false)
{
if (!entriesByName.ContainsKey(obj.name))
{
Destroy(obj);
return;
}
ObjectPoolEntry objectPoolEntry = entriesByName[obj.name];
obj.SetActive(false);
obj.transform.parent = transform;
if (resetRigidbody)
{
obj.GetComponent <Rigidbody>().velocity = Vector3.zero;
}
objectPoolEntry.pool[objectPoolEntry.objectsInPool++] = obj;
}
void InitializePool()
{
containerObject_ = new GameObject("ObjectPool");
containerObject_.transform.parent = transform;
m_Pool = new List <GameObject> [m_Entries.Length];
for (int i = 0; i < m_Pool.Length; ++i)
{
ObjectPoolEntry prefab = m_Entries[i];
m_Pool[i] = new List <GameObject>();
for (int j = 0; j < prefab.mCount; ++j)
{
GameObject newObj = (GameObject)GameObject.Instantiate(prefab.mPrefab);
newObj.name = prefab.mPrefab.name;
PoolObject(newObj);
}
}
}
// Use this for initialization
void Start()
{
ContainerObject = new GameObject("ObjectPool");
//Loop through the object prefabs and make a new list for each one.
//We do this because the pool can only support prefabs set to it in the editor,
//so we can assume the lists of pooled objects are in the same order as object prefabs in the array
for (int i = 0; i < Entries.Length; i++)
{
ObjectPoolEntry objectPrefab = Entries [i];
//create the repository
objectPrefab.pool = new GameObject[objectPrefab.Count];
//fill it
for (int n = 0; n < objectPrefab.Count; n++)
{
GameObject newObj = (GameObject)Instantiate(objectPrefab.Prefab);
newObj.name = objectPrefab.Prefab.name;
PoolObject(newObj);
}
}
}
