public PoolItem GetPoolItem(PoolType poolType)
{
if (!m_poolItems.ContainsKey(poolType.ToString()))
{
Debug.LogError("No pool item configured for type: " + poolType);
return(null);
}
PoolItem poolItem = null;
for (int i = 0; i < m_poolItems[poolType.ToString()].Count; i++)
{
if (!m_poolItems[poolType.ToString()][i].Allocated)
{
poolItem = m_poolItems[poolType.ToString()][i];
break;
}
}
if (poolItem == null)
{
poolItem = SpawnPoolItem(poolType);
}
poolItem.OnAllocate();
return(poolItem);
}
/// <summary>
/// 初始化
/// </summary>
/// <param name="poolType">对象池类型</param>
/// <param name="gameObject">Obj</param>
/// <param name="cont">初始化大小</param>
public void InitPool(PoolType poolType, GameObject prefab, int count = 20)
{
//创建个MgrPool节点 把所有池子都归到这个节点下 方便管理
if (_poolTotal == null)
{
_poolTotal = new GameObject("TamToastPool").transform;
}
if (!_poolDic.ContainsKey(poolType))
{
if (_unifiedMgr)
{
//如果是新池子 创建一个节点
Transform parent = new GameObject("Pool_" + poolType.ToString()).transform;
parent.SetParent(_poolTotal);
_pathDic.Add(poolType, parent);
}
_poolDic.Add(poolType, new Queue <GameObject>());
CreatorItem(poolType, prefab, count);
}
else
{
//throw new Exception(string.Format("该池子：'{0}'已存在，请勿重复初始化！", poolType));
}
}
// 从池中获取一个能用的对象
public GameObject getObjFromPool(PoolType type)
{
if (!hashTable.ContainsKey(type))
{
throw new Exception("Have not create " + type.ToString() + " Pool");
}
PoolObj poolObj = hashTable[type] as PoolObj;
GameObject t;
for (int i = 0; i < poolObj.objList.Count; i++)
{
t = poolObj.objList[(poolObj.index + i) % poolObj.objList.Count];
// Active 为False 即为可以拿出来使用的对象，否则寻找下一个
if (!t.activeSelf)
{
poolObj.index = (poolObj.index + i) % poolObj.objList.Count;
t.SetActive(true);
return(t);
}
}
// 所有的都正在使用……只能添加新的了
t = addToPool(poolObj);
t.SetActive(true);
return(t);
}
public GameObject GetPooledObject(PoolType poolType, Vector3 pos, Quaternion rot)
{
if (poolDictionary.ContainsKey(poolType))
{
// Dequeue object and activates it
if (poolDictionary[poolType].pooledGameObjects.Count != 0)
{
GameObject pooledObject = poolDictionary[poolType].pooledGameObjects.Dequeue();
pooledObject.transform.position = pos;
pooledObject.transform.rotation = rot;
pooledObject.SetActive(true);
return(pooledObject);
}
// Creates a new object and instantly returns it
else
{
GenerateNewObject(poolType);
GameObject pooledObject = poolDictionary[poolType].pooledGameObjects.Dequeue();
pooledObject.transform.position = pos;
pooledObject.transform.rotation = rot;
pooledObject.SetActive(true);
return(pooledObject);
}
}
else
{
Debug.LogWarning($"Requested Object from a non existing pool! {poolType.ToString()}");
return(null);
}
}
public PutPoolPartitionSpectraS3Request(string name, PoolType type)
{
this.Name = name;
this.Type = type;
this.QueryParams.Add("name", name);
this.QueryParams.Add("type", type.ToString());
}
EmitterManager CreateEmitterManager(PoolType pType, Transform parent, Vector3 pos)
{
var go = ResourceManager.Load <GameObject>(PathManager.GetEmitterPath(pType.ToString()));
var emitterGo = PoolManager.InstantiateGameObject(go, pType);
var emitter = emitterGo.GetComponent <EmitterManager>();
emitter.transform.SetParent(parent, false);
emitter.transform.position = pos;
return(emitter);
}
private void GenerateNewObject(PoolType poolType)
{
if (poolDictionary.ContainsKey(poolType))
{
// Instantiate Object inside the respective Pool Container
GameObject newObject = Instantiate(poolDictionary[poolType].prefabToInstantiate, poolDictionary[poolType].poolContainer.transform);
// Add tracker to the Object
newObject.AddComponent <ObjectPoolTracker>().SetObjectType(poolType);
// Queues the object to its respective pool (Tracker calls ReturnPooledObject())
newObject.SetActive(false);
}
else
{
Debug.LogWarning($"Requested Object from a non existing pool! {poolType.ToString()}");
}
}
public Pool(PoolType type, GameObject prefab, int count)
{
PoolTransform = (new GameObject(type.ToString())).transform;
_inActiveObjects = new Dictionary <int, Poolee>();
_activeObjects = new Dictionary <int, Poolee>();
_prefab = prefab;
_type = type;
Poolee temp;
for (int i = 0; i < count; i++)
{
temp = Create(_type, _prefab);
temp.gameObject.SetActive(false);
temp.transform.SetParent(PoolTransform);
_inActiveObjects.Add(temp.GetInstanceID(), temp);
}
}
PoolItem SpawnPoolItem(PoolType poolType)
{
for (int i = 0; i < m_poolConfig.PoolItems.Length; i++)
{
if (m_poolConfig.PoolItems[i].Type == poolType)
{
GameObject newPoolObject = Instantiate(m_poolConfig.PoolItems[i].Item.Object);
PoolItem newPoolItem = newPoolObject.GetComponent <PoolItem>();
newPoolObject.transform.SetParent(m_poolParents[m_poolConfig.PoolItems[i].Type.ToString()]);
newPoolObject.SetActive(false);
m_poolItems[poolType.ToString()].Add(newPoolItem);
return(newPoolItem);
}
}
return(null);
}
// 创建一个新的对象池
public T CreateObjectPool <T>(PoolType poolName, Transform parent = null) where T : ObjectPool, new()
{
if (m_PoolDic.ContainsKey(poolName))
{
return(m_PoolDic[poolName] as T);
}
GameObject obj = new GameObject(poolName.ToString());
if (parent != null)
{
obj.transform.SetParent(parent);
}
else
{
obj.transform.SetParent(m_RootPoolTrans);
}
T pool = new T();
pool.Init(poolName, obj.transform);
m_PoolDic.Add(poolName, pool);
return(pool);
}
public GetBucketCapacitySummarySpectraS3Request WithPoolType(PoolType? poolType)
{
this._poolType = poolType;
if (poolType != null)
{
this.QueryParams.Add("pool_type", poolType.ToString());
}
else
{
this.QueryParams.Remove("pool_type");
}
return this;
}
public IEnumerable <Permission> GetPermissions(PoolType level)
{
var permissions = new List <Permission>();
foreach (var provider in _permissionProviders)
{
if (provider.Level == level)
{
permissions.AddRange(provider.PermissionGroups());
}
}
if (permissions.Count == 0)
{
throw new NotImplementedException($"No permissions registered for level {level.ToString()}");
}
return(permissions);
}
public GetPoolPartitionsSpectraS3Request WithType(PoolType? type)
{
this._type = type;
if (type != null)
{
this.QueryParams.Add("type", type.ToString());
}
else
{
this.QueryParams.Remove("type");
}
return this;
}