private static void InvokeDespawnables(PooledGameObject instance)
{
for (int i = 0; i < instance.Spawnables.Count; i++)
{
instance.Spawnables[i].OnDespawn();
}
}
public void BackToPool(PooledGameObject go)
{
lock (m_availableObjects) {
m_availableObjects.Add(go);
go.gameObject.SetActive(false);
}
}
public PooledGameObject GetPooledInstance(Transform parent)
{
lock (m_availableObjects) {
int lastIndex = m_availableObjects.Count - 1;
if (lastIndex >= 0)
{
PooledGameObject go = m_availableObjects[lastIndex];
m_availableObjects.RemoveAt(lastIndex);
m_usingObjects.Add(go);
go.gameObject.SetActive(true);
if (go.transform.parent != parent)
{
go.transform.SetParent(parent);
}
return(go);
}
else
{
PooledGameObject go = GameObject.Instantiate <PooledGameObject> (m_prefab, parent);
go.pool = this;
m_usingObjects.Add(go);
return(go);
}
}
}
public static void GiveBackToPool(Transform content)
{
for (int i = 0; i < content.childCount; i++)
{
PooledGameObject pgo = content.GetChild(i).GetComponent <PooledGameObject>();
pgo.Push(false);
}
}
public GameObjectPool(PooledGameObject prefab, int initailSize)
{
m_prefab = prefab;
for (int i = 0; i < initailSize; i++)
{
PooledGameObject go = GameObject.Instantiate <PooledGameObject> (m_prefab);
go.pool = this;
m_availableObjects.Add(go);
go.gameObject.SetActive(false);
}
}
private void Update()
{
if (useObjectPool)
{
PooledGameObject go = pooledPrefab.GetPooledInstance(this.transform);
go.transform.position = this.transform.position;
}
else
{
PooledGameObject go = GameObject.Instantiate <PooledGameObject> (pooledPrefab);
}
}
// Use this for initialization
void Awake()
{
instance = this;
Bullets = new List <GameObject>(NumberBullets);
for (int i = 0; i < NumberBullets; i++)
{
GameObject prefab = Instantiate(bulletPrefab);
prefab.transform.SetParent(transform);
prefab.SetActive(false);
Bullets.Add(prefab);
}
}
private void Despawn(PooledGameObject pooledObject)
{
var isRemovalSuccess = _spawned.Remove(pooledObject);
if (isRemovalSuccess)
{
DespawnInstance(pooledObject);
_despawned.Push(pooledObject);
}
else
{
throw new ArgumentException(string.Format("GameObject '{0}' cannot be despawned in pool.", pooledObject.GameObject));
}
}
private void DespawnInstance(PooledGameObject pooledObject)
{
var gameObject = pooledObject.GameObject;
if (!gameObject.IsDestroyed())
{
InvokeDespawnables(pooledObject);
gameObject.SetActive(false);
if (!_despawnedContainer.IsDestroyed())
{
gameObject.transform.SetParent(null, worldPositionStays: false);
gameObject.transform.position = Vector3.zero;
gameObject.transform.rotation = Quaternion.identity;
gameObject.SetParent(_despawnedContainer);
}
}
}
public void Push(PooledGameObject gameObj, bool needChangeParent = true)
{
if (gameObjects.Contains(gameObj))
{
return;
}
if (gameObj == originalObj)
{
return;
}
if (needChangeParent)
{
gameObj.transform.SetParent(transform, false);
}
gameObj.gameObject.SetActive(false);
gameObjects.Add(gameObj);
}
private void SpawnInstance(PooledGameObject pooledObject, Vector3 position, Quaternion rotation)
{
var gameObject = pooledObject.GameObject;
if (gameObject == null)
{
throw new NullReferenceException(
string.Format("Pooled instance of type '{0}' is null. Did you Destroy() it by accident?",
gameObject.name));
}
gameObject.transform.SetParent(null, worldPositionStays: false);
gameObject.transform.position = position;
gameObject.transform.rotation = rotation;
gameObject.SetActive(true);
InvokeSpawnables(pooledObject);
}
public PooledGameObject Pop(bool needChangeParent = false)
{
if (gameObjects.Count == 0)
{
gameObjects.Add(GameObject.Instantiate(originalObj) as PooledGameObject);
}
PooledGameObject go = gameObjects[gameObjects.Count - 1];
go.gameObject.SetActive(true);
gameObjects.Remove(go);
if (needChangeParent)
{
go.transform.SetParent(null, false);
}
go.Init();
return(go);
}
public void Clear(bool includeUsingObject = true)
{
lock (m_availableObjects) {
for (int i = m_availableObjects.Count - 1; i >= 0; i--)
{
PooledGameObject go = m_availableObjects[i];
m_availableObjects.RemoveAt(i);
GameObject.Destroy(go.gameObject);
}
}
if (includeUsingObject)
{
lock (m_usingObjects) {
for (int i = m_usingObjects.Count - 1; i >= 0; i--)
{
PooledGameObject go = m_usingObjects[i];
m_usingObjects.RemoveAt(i);
GameObject.Destroy(go.gameObject);
}
}
}
}
private void OnEnable()
{
m_lifeTime = 1f;
m_pooledGameObject = this.GetComponent <PooledGameObject> ();
}
