protected override void Awake() { base.Awake(); // references poolObject = (PoolObject)GetComponent(typeof(PoolObject)); }
// инициализация пула public void Initialize(int count, PoolObject sample, Transform objects_parent) { objects = new List<PoolObject>(); // инициализация листа objectsParent = objects_parent; // забираем папаньку for (int i = 0; i < count; i++) { AddObject(sample, objects_parent); } }
public ObjectInstance(GameObject objectInstance) { gameObject = objectInstance; transform = gameObject.transform; gameObject.SetActive(false); if (gameObject.GetComponent<PoolObject>()) { hasPoolObjectComponent = true; poolObjectScript = gameObject.GetComponent<PoolObject>(); } }
// добавление нового объекта в пул void AddObject(PoolObject sample, Transform objects_parent) { GameObject temp = GameObject.Instantiate(sample.gameObject); temp.name = sample.name; temp.transform.SetParent(objects_parent); objects.Add(temp.GetComponent<PoolObject>()); if (temp.GetComponent<Animator>()) { temp.GetComponent<Animator>().StartPlayback(); } temp.SetActive(false); }
void AddPoolObject(PoolObject po, int count) { if (po == null) Debug.Log("po null"); else if (po.poolPrefab == null) Debug.Log("po.poolPrefab null, " + po.name); Transform t = ((GameObject)Instantiate(po.poolPrefab)).transform; t.SetParent(inactiveListTransform); t.name = po.name + count; po.inactiveList.Add(t); DeactivateObject(t); }
public override void OnInspectorGUI() { if(m_reference == null) { m_reference = (PoolObject)target; } EditorGUILayout.LabelField("Pool name: ", m_reference.PoolName); EditorGUILayout.ObjectField("Game object: ", m_reference.PoolableObject, typeof(GameObject), false); EditorGUILayout.IntField("Initial count: ", m_reference.InitialCount); EditorGUILayout.Toggle("Incremental: ", m_reference.IncrementalPool); }
// Use this for initialization void Start() { curHP = HP; myTag = tag; Player = GameObject.FindGameObjectWithTag("Player"); myPoolObject = GetComponent<PoolObject>(); myTransform = transform; StartCoroutine(EnemyCoroutine()); PlayerTag = "Player"; if (tag.Equals("Enemy_Unbreakable") == false) { Health = myTransform.Find("Canvas").Find("Health").GetComponent<Image>(); Health.fillAmount = (curHP * 1.0f) / HP; } }
// initial configuration void Configure() { targetAspect = targetAspectRatio.x / targetAspectRatio.y; poolObjects = new PoolObject[poolSize]; for (int i = 0; i < poolObjects.Length; i++) { GameObject go = Instantiate(Prefab) as GameObject; // instantiate a prefab Transform t = go.transform; // get transform of newly instantiated prefab t.SetParent(transform); // set new inst. prefab's parent to its spawner obj t.position = Vector3.one * 1000; // move (way) off screen to start poolObjects[i] = new PoolObject(t); // new poolobject with this object's transform } if (spawnImmediate) { SpawnImmediate(); } }
void Configure() { targetAspect = targetAspectRatio.x / targetAspectRatio.y; poolObjects = new PoolObject[poolSize]; for (int i = 0; i < poolObjects.Length; i++) { GameObject go = Instantiate(Prefab) as GameObject; Transform t = go.transform; t.SetParent(transform); t.position = Vector3.one * 1000; poolObjects[i] = new PoolObject(t); } if (spawnImmediate) { SpawnImmediate(); } }
/// <summary> /// Constructor, se encargar de guardar las referencias que vamos a necesitar para crear el objecto que queremos poolear, /// vamos a pedir un stock inicial,Como vamos a crear cada objeto y sus funciones de como inicializarlos y finalizarlos,ademas de preguntar si lo queremos dinamico al pool /// </summary> /// <param name="initialStock"></param> /// <param name="factoryMethod"></param> /// <param name="initialize"></param> /// <param name="finalize"></param> /// <param name="isDinamic"></param> public Pool(int initialStock, CallbackFactory factoryMethod, PoolObject <T> .PoolCallback initialize, PoolObject <T> .PoolCallback finalize, bool isDinamic) { //Creamos una lista de objetos Pooleables _poolList = new List <PoolObject <T> >(); //Guardamos las referencias para cuando los necesitemos. _factoryMethod = factoryMethod; _isDinamic = isDinamic; _count = initialStock; _init = initialize; _finalize = finalize; //Generamos el stock inicial. for (int i = 0; i < _count; i++) { _poolList.Add(new PoolObject <T>(_factoryMethod(), _init, _finalize)); } }
/// <summary> /// Despawn the specified GameObject, returning it to its pool. /// If the GameObject has no pool, it is destroyed instead. /// </summary> public static void Despawn(GameObject go) { if (go == null) { return; } PoolObject po = go.GetComponent <PoolObject>(); if (po == null || !PoolExists(po.PrefabName)) { Destroy(go); } else { Pools[po.PrefabName].Despawn(go); } }
public void CreatePool(GameObject obj, int size) { int poolkey = obj.GetInstanceID(); if (!pool.ContainsKey(poolkey)) { pool.Add(poolkey, new Queue <PoolObject>()); GameObject o = new GameObject(obj.name); o.transform.parent = transform; for (int i = 0; i < size; i++) { PoolObject newBoulder = new PoolObject(Instantiate(obj) as GameObject); pool[poolkey].Enqueue(newBoulder); newBoulder.setParent(o.transform);; } } }
public static PoolObject Spawn <T>(Transform parent = null) where T : PoolObject { //spawn object and pull it out of dictionary stack Type type = typeof(T); if (poolObjects[type].Count > 0) { PoolObject obj = poolObjects[type].Pop(); //Pop it out of the stack obj.OnSpawn(); //PoolObject version of Start() obj.transform.SetParent(parent); obj.gameObject.SetActive(true); //Activate it return(obj); } else { return(null); } }
public void ObjectPoolTest_AllocateAndRecycle_ObjectNull() { //option PoolObject po = SafeObjectPool <PoolObject> .Instance.Allocate(); //Assert Assert.IsNotNull(po); Assert.AreEqual(10, po.id); //option bool isRecycle = SafeObjectPool <PoolObject> .Instance.Recycle(po); //Assert Assert.IsTrue(isRecycle); Assert.AreEqual(0, po.id); SafeObjectPool <PoolObject> .Instance.Dispose(); }
public T Get() { for (int i = 0; i < _pool.Count; i++) { if (!_pool[i].IsActive) { _enableMethod(_pool[i].Content); _pool[i].IsActive = true; return(_pool[i].Content); } } PoolObject <T> newObj = new PoolObject <T>(_factoryMethod); _enableMethod(newObj.Content); newObj.IsActive = true; _pool.Add(newObj); return(newObj.Content); }
public void AddObject(PoolObject sample, Transform objectsParent) { GameObject temp; if (sample.gameObject.scene.name == null) { temp = GameObject.Instantiate(sample.gameObject); temp.name = sample.name; temp.transform.SetParent(objectsParent); } else { temp = sample.gameObject; } objects.Add(temp.GetComponent <PoolObject>()); temp.SetActive(false); }
public bool TryInstantiate(Vector3 position, Quaternion rotation, Transform camRef) { PoolObject objectToReuse = poolQueue.Peek(); if (!objectToReuse.gameObject.activeSelf) { poolQueue.Dequeue(); poolQueue.Enqueue(objectToReuse); objectToReuse.transform.position = position; objectToReuse.transform.rotation = rotation; objectToReuse.OnObjectReuse(); objectToReuse.SetCam(camRef); // this clearly belongs here lolol return(true); } return(false); }
private void Shot() { if (!IsShotReady()) { return; } Vector3 mousePos = Camera.main.ScreenToWorldPoint(Input.mousePosition); Vector2 direction = mousePos - transform.position; float angle = Mathf.Atan2(direction.x, direction.y) * Mathf.Rad2Deg; PoolObject bullet = PoolManager.Get(1); bullet.transform.position = transform.position; bullet.transform.rotation = Quaternion.Euler(0, 0, -angle); Bullet comp = bullet.GetComponent <Bullet>(); comp.Init(_stats.shotSpeed, _stats.bulletDestroyDelay); _lastShotTime = Time.time; }
public void addToPool(PoolObject poolObject) { GameObject parent = new GameObject("Parentof" + objectsInPool.Count); objectsInPool.Add(poolObject); List <GameObject> tempPool = new List <GameObject>(); for (int i = 0; i < poolObject.numberToPool; i++) { GameObject go = MonoBehaviour.Instantiate(poolObject.objectPrefab); go.transform.parent = parent.transform; poolItems pi = (poolItems)pool.Count; go.transform.name = pi.ToString(); go.SetActive(false); tempPool.Add(go); } pool.Add(tempPool); }
/// <summary> /// 将一个对象放入对象池 /// </summary> /// <param name="go"></param> /// <param name="isSetInactive">是否将放入的物体设为不激活状态(obj.SetActive(false))</param> public static void DestroyGameObjectByPool(GameObject go, bool isSetInactive = true) { string key = go.name.Replace("(Clone)", ""); if (s_objectPool.ContainsKey(key) == false) { s_objectPool.Add(key, new List <GameObject>()); } if (s_objectPool[key].Contains(go)) { throw new Exception("DestroyGameObjectByPool:-> Repeat Destroy GameObject !" + go); } s_objectPool[key].Add(go); if (isSetInactive) { go.SetActive(false); } else { go.transform.position = s_OutOfRange; } go.name = key; go.transform.SetParent(PoolParent); PoolObject po = go.GetComponent <PoolObject>(); if (po) { po.OnRecycle(); } if (createPools.ContainsKey(key) && createPools[key].Contains(go)) { createPools[key].Remove(go); //Debug.LogWarning(go.name + " ==>>" + createPools[key].Count); if (createPools[key].Count == 0) { createPools.Remove(key); AssetsPoolManager.DestroyByPool(key); } } }
public void OnEnemySurvival() { _estadoEnemigo = EstadoEnemigo.vivo; poolObjectEnemy = GetComponent <PoolObject>(); float opcion = Random.Range(MinRangeRandom, TypeRandom); if (gm == null) { gm = GameManager.instanceGameManager; } Debug.Log("Enemigos Abatidos:" + gm.countEnemysDead); if ((gm.countEnemysDead % gm.RondasPorJefe) != 0 || gm.countEnemysDead == 0) { switch ((int)opcion) { case 0: //Debug.Log("ENTRE BALANCEADO"); //Cambiar el sprite del enemigo Balanceado. typeEnemy = TiposDeEnemigo.Balanceado; break; case 1: //Debug.Log("ENTRE AGRESIVO"); //Cambiar el sprite del enemigo Agresivo. typeEnemy = TiposDeEnemigo.Agresivo; break; case 2: //Debug.Log("ENTRE DEFENSIVO"); //Cambiar el sprite del enemigo Defensivo. typeEnemy = TiposDeEnemigo.Defensivo; break; } } else if ((gm.countEnemysDead % gm.RondasPorJefe) == 0 && gm.countEnemysDead > 1) { //Cambiar el sprite del jefe correspondiente Debug.Log("Soy tremendo jefe"); typeEnemy = TiposDeEnemigo.Jefe; typeBoss = TiposDeJefe.ProfeAnatomia; } CheckInitialSprite(); SetPorcentageMovements(); }
private IEnumerator CoSpawnEnemys() { yield return(new WaitForSeconds(startWait)); float generateInterval = interval.max; while (!_gameover) { Vector3 spawnPosition = new Vector3(spawnX, Random.Range(spawnY.min, spawnY.max), 0f); Pool enemyPool = enemyPools[Random.Range(0, enemyPools.Length)]; PoolObject poolObj = enemyPool.Pop(); poolObj.transform.position = spawnPosition; poolObj.transform.rotation = Quaternion.identity; yield return(new WaitForSeconds(generateInterval)); generateInterval = Mathf.Clamp(generateInterval - intervalAccel, interval.min, interval.max); } }
public PoolObject UsePoolObject(PoolObject poolobject, Vector3 transform, Quaternion rotation) { int poolid = poolobject.GetInstanceID(); if (!poolDictionary.ContainsKey(poolid)) { CreatePool(poolobject); } if (poolDictionary[poolid].Count == 0) { poolDictionary[poolid].Enqueue(CreatePoolObject(poolobject, poolid)); } PoolObject pooledObject = poolDictionary[poolid].Dequeue(); pooledObject.transform.position = transform; pooledObject.transform.rotation = rotation; pooledObject.gameObject.SetActive(true); return(pooledObject); }
/// <summary> /// 清空对象池 /// </summary> public static void CleanPool(bool isClearAssetsAndBundle) { Debug.LogWarning("清空对象池"); foreach (string name in s_objectPool.Keys) { if (s_objectPool.ContainsKey(name)) { List <GameObject> l_objList = s_objectPool[name]; for (int i = 0; i < l_objList.Count; i++) { GameObject go = l_objList[i]; PoolObject po = go.GetComponent <PoolObject>(); if (po) { po.OnObjectDestroy(); } if (isClearAssetsAndBundle) { GameObject.DestroyImmediate(go, true); } else { Destroy(go); } } //if (isClearAssetsAndBundle && !createPools.ContainsKey(name)) //{ // //if (ResourcesConfigManager.GetIsExitRes(name)) // //{ // // Debug.LogWarning("卸载资源:" + name); // // ResourceManager.UnLoad(name); // //} // AssetsPoolManager.DestroyByPool(name); //} l_objList.Clear(); } } s_objectPool.Clear(); }
private void configure() { targetApsect = TargetApsectRatio.x / TargetApsectRatio.y; poolObjectArray = new PoolObject[PoolSize]; for (var i = 0; i < poolObjectArray.Length; i++) { var newGameObject = Instantiate(Prefab); var newTransform = newGameObject.transform; newTransform.SetParent(transform); newTransform.position = Vector3.one * 1000; poolObjectArray[i] = new PoolObject(newTransform); } if (SpawnImediate) { spawnObjectImediate(); } }
public PoolObject Get() { PoolObject obj = null; if (queue.Count > 0) { obj = queue.Dequeue(); obj.gameObject.SetActive(true); } else if (instanceCount < maxInstances) { instanceCount++; obj = Instantiate <PoolObject>(prefab); obj.transform.parent = transform; obj.gameObject.SetActive(true); } return(obj); }
private PoolObject InstantiateNewPoolObject(PoolObject poolObjectToSpawn, List <PoolObject> poolListToAdd) { //New poolObject PoolObject newPoolObject = (PoolObject)Instantiate(poolObjectToSpawn, Vector3.zero, Quaternion.identity); // start disabled newPoolObject.DisablePoolObject(); //use this as the transform to keep pool objects organised. newPoolObject.transform.SetParent(transform); //make sure there is a pool object script on the new object newPoolObject.gameObject.AddComponent <PoolObject>(); //Add to the pool list poolListToAdd.Add(newPoolObject); return(newPoolObject); }
void Configure() //called in awake { //spawning pool objects targetAspect = targetAspectRatio.x / targetAspectRatio.y; poolObjects = new PoolObject[poolSize]; for (int i = 0; i < poolObjects.Length; i++) { GameObject go = Instantiate(Prefab) as GameObject; // go short for gameobject,creating object spawning into game, only happen once (spawning prefab and casting it as gameobject) Transform t = go.transform; //need to store transforms t.SetParent(transform); //paralaxer on all parent objects, so t will set the parent (whatever script is attached to t.position = Vector3.one * 1000; //initialize it off screen poolObjects[i] = new PoolObject(t); //value passed a parameter within the instructor poolObject we need } if (spawnImmediate) // if its true { SpawnImmediate(); } }
void Awake() { PrefabManager.Instance.LoadPrefabs_Editor(); foreach (KeyValuePair <PrefabNames, int> kv in PoolConfigs) { string prefabName = kv.Key.ToString(); GameObject go_Prefab = PrefabManager.Instance.GetPrefab(prefabName); if (go_Prefab) { GameObject go = new GameObject("Pool_" + prefabName); GameObjectPool pool = go.AddComponent <GameObjectPool>(); pool.transform.SetParent(transform); PoolDict.Add(kv.Key, pool); PoolObject po = go_Prefab.GetComponent <PoolObject>(); pool.Initiate(po, kv.Value); } } }
public PoolObject GetFromPool(string i_FXName, float px , float py , float scaleX , float scaleY) { if (pool.ContainsKey (i_FXName)) { if (pool [i_FXName].Count > 0) { PoolObject p = pool [i_FXName] [0]; pool [i_FXName].RemoveAt (0); p.gameObject.SetActive (true); p.myTransform.position = new Vector2 (px, py); p.myTransform.localScale = new Vector2 (scaleX, scaleY); p.isActive = true; p.OutOfPool (); return p; } else { return CreateSinglePoolObject (i_FXName); } } return null; }
public IEnumerator InstantiateSphere(int poolNum, int insPerFrame, Action stepAction = null) { Objects = new PoolObject[poolNum]; var count = 0; for (int i = 0; i < poolNum; i++) { Objects[i] = new PoolObject(); Objects[i].Obj = CreateSphere(new Vector2(0, 0), 1); Objects[i].Obj.name = i.ToString(); count++; if (count >= insPerFrame) { stepAction?.Invoke(); count = 0; yield return(null); } } }
void Start() { if (_linkedPool == null) { _linkedPool = OneMeshPool.GetPool(_poolIdName); } if (_linkedPool != null) { _linkedObject = _linkedPool.Next(true, true); if (_linkedObject != null) { _linkedObject.transform.parent = this.transform; _linkedObject.transform.localPosition = Vector3.zero; _linkedObject.transform.localScale = this.transform.localScale; return; } } Destroy(this.gameObject); }
public IEnumerator InstantiateAction(Func <GameObject> create, int poolNum, int insPerFrame, Action stepAction = null) { Objects = new PoolObject[poolNum]; var count = 0; for (int i = 0; i < poolNum; i++) { Objects[i] = new PoolObject(); Objects[i].Obj = create(); Objects[i].Obj.name = i.ToString(); count++; if (count >= insPerFrame) { stepAction?.Invoke(); count = 0; yield return(null); } } }
void Configure_Label() { labelObjects = new PoolObject[poolSize]; int counter = 0; for (int i = 0; i < poolObjects.Length; i++) { randomizer : int rnd = Random.Range(0, Label_Prefabs.Length); if (!Label_Prefabs[rnd].beenChosen) { counter++; if (counter == Label_Prefabs.Length) { counter = 0; int savedInt = rnd; for (int j = 0; j < Label_Prefabs.Length; j++) { Label_Prefabs[j].beenChosen = false; if (j == savedInt) { Label_Prefabs[j].beenChosen = true; } } } } else { goto randomizer; } GameObject go = Instantiate(Label_Prefabs[rnd].prefab) as GameObject; Label_Prefabs[rnd].beenChosen = true; Transform t = go.transform; t.SetParent(transform); t.position = Vector3.one * 1000; labelObjects[i] = new PoolObject(t); } }
/// <summary> /// 将对象返回到池。 /// </summary> public void ReturnObjectToPool(PoolObject poolObject) { poolObject.transform.SetParent(parent, false); switch (poolBehaviour) { case PoolBehaviour.GameObject: poolObject.gameObject.SetActive(false); break; case PoolBehaviour.CanvasGroup: poolObject.canvasGroup.alpha = 0f; poolObject.canvasGroup.interactable = false; poolObject.canvasGroup.blocksRaycasts = false; break; } poolObject.isInPool = true; }
private void SpawnSlash(SkillUser user) { PoolObject slash = user.userPool.SpawnTargetObject(meleeHitPrefab, 2); slash.transform.position = user.transform.position; DamageSource dmg = slash.GetComponent <DamageSource>(); dmg.damageValue = (int)user.userStats.strength.Value; dmg.hostileTo = user.userStats.enemyEntitySets; dmg.knockbackForce = baseKnockbackForce; dmg.skillType = SkillType.Melee; dmg.damageType = DamageType.Physical; //slash.transform.rotation = user.userAim.optionalRotatingPointer.rotation; //temporario, não ideal, precisamos de um método pra calcular rotação user.userAim.RotateObjectToAim(slash.transform); dmg.owner = user.userStats; dmg.manaReplenishAmount = 2; }
public List <PoolObject> GetAllActiveObjects(int id) { List <PoolObject> list = new List <PoolObject>(); if (id > PoolItems.Count || id < 0) { Debug.Log("Requesting illegal object with id " + id); return(null); } for (int count = 0; count < _pool[id].Count; ++count) { PoolObject obj = _pool[id][count]; if (obj.IsActive) { list.Add(obj); } } return(list); }
/// <summary> /// Adiciona objeto ao Pool /// </summary> /// <param name="object_">Object.</param> public void AddObjectToPool(PoolObject templateObject_, int times_) { if (_currentIndex > _pool.Length) return; //Nao ha mais espacos para inserir for (int i = 0; i < times_; i++){ _pool[_currentIndex] = GameObject.Instantiate(templateObject_) as PoolObject; _pool[_currentIndex].gameObject.SetActive(false); _pool[_currentIndex].ObjectAddedToPool(); _pool[_currentIndex].Pool = templateObject_.Pool; // Recupera a referencia de um unico PoolManager por Template _currentIndex++; // Soma mais um para o proximo objeto ser adicionado corretamente } // Estrutura os filhos dentro do template for (int i = 0; i < _pool.Length; i++) { if (_pool[i] != null) { _pool[i].transform.parent = DefaultParent; } } }
/// <summary> /// /// </summary> /// <param name="prefab"></param> /// <param name="poolParent"></param> /// <returns></returns> public Pool CreatePool(PoolObject prefab, Transform poolParent = null) { Pool pool = new Pool(this, prefab); poolList.Add(pool); pools.Add(prefab, pool); if (poolParent == null) { poolParent = new GameObject(prefab.name).transform; poolParent.parent = parent; } pool.Initialize(poolParent); return pool; }
/// <summary> /// Create pool and cache prefab. /// </summary> /// <param name="poolManager"></param> /// <param name="prefab"></param> /// <param name="parent"></param> public Pool(PoolManager poolManager, PoolObject prefab, Transform parent = null) { this.poolManager = poolManager; if (prefab != null) { this.prefab = prefab; } }
void CreatePoolTable(PoolObject[] poolTable, int initialPoolAmmout) { for (int i = 0; i < poolTable.Length; i++) { poolTable[i] = Instantiate(poolTable[i], Vector3.zero, Quaternion.identity) as PoolObject; /*SkillBase _skillBase = poolTable[i] as SkillBase; if (_skillBase != null) _skillBase.SetupSkill();*/ poolTable[i].name += " Table"; poolTable[i].gameObject.SetActive(false); poolTable[i].Pool = new PoolManager(); poolTable[i].Pool.Initialize(initialPoolAmmout, poolTable[i].transform); poolTable[i].Pool.AddObjectToPool(poolTable[i], initialPoolAmmout); /*if (_skillBase != null) { for (int j = 0; j < _skillBase.Pool.Length; j++) { ((SkillBase)_skillBase.Pool[j]).SetupSkill(); } }*/ poolTable[i].transform.parent = this.transform; } }
protected virtual void Awake() { myTransform = transform; myPoolObject = GetComponent<PoolObject>(); }
/// <summary> /// Push gameObject back into the pool. /// </summary> /// <param name="poolObject">GameObject to return to the pool.</param> public void Push(PoolObject poolObject) { pool.Push(poolObject.gameObject); ActiveCount--; }
/// <summary> /// Hides and returns assigned poolobject to this pool /// </summary> /// <param name="obj"></param> public virtual void Return(PoolObject obj) { obj.gameObject.SetActive(false); m_Instances.Enqueue(obj.gameObject); }
/// <summary> /// /// </summary> /// <param name="prefab"></param> /// <returns></returns> public Pool GetPool(PoolObject prefab) { return poolList.FirstOrDefault(p => p.prefab == prefab); }
public PoolList(GameObject Prefab) { m_Prefab = Prefab; m_ActivePool = null; m_FreePool = null; m_NumAllocated = 0; m_NumReused = 0; m_Container = new GameObject(); m_Container.name = Prefab.name; m_Container.transform.parent = sInstance.gameObject.transform; }
internal GameObject AllocatedFromPool(Vector3 spawnPosition, Quaternion spawnRotation) { PoolObject NewPoolObject; if(m_FreePool == null) { m_NumAllocated++; NewPoolObject = PoolObject.Create (m_Prefab, this, spawnPosition, spawnRotation); NewPoolObject.m_Next = m_ActivePool; m_ActivePool = NewPoolObject; } else { m_NumReused++; NewPoolObject = m_FreePool; NewPoolObject.Reuse(this, spawnPosition, spawnRotation); // next free pool entry is now the head m_FreePool = m_FreePool.m_Next; // link node into active pool NewPoolObject.m_Next = m_ActivePool; m_ActivePool = NewPoolObject; } NewPoolObject.m_GameObject.SetActive(true); NewPoolObject.m_GameObject.name = m_Prefab.name + m_NumAllocated.ToString(); return (NewPoolObject.m_GameObject); }
/// <summary> /// Retrieve the next available gameObject from the corresponding pool. Creates a new pool if necessary. /// </summary> /// <param name="prefab">Type of gameObject to return.</param> /// <param name="life">Time in seconds till gameObject gets disabled.</param> /// <returns>Enabled gameObject.</returns> public GameObject Pop(PoolObject prefab, float life) { while (true) { Pool pool; if (pools.TryGetValue(prefab, out pool)) { return pool.Pop(life); } CreatePool(prefab); } }
internal bool Release(GameObject ThisGameObject) { PoolObject LastObject = null; PoolObject CheckObject = m_ActivePool; while(CheckObject != null) { if(CheckObject.m_GameObject == ThisGameObject) { // unlink from active pool if(LastObject == null) m_ActivePool = CheckObject.m_Next; else LastObject.m_Next = CheckObject.m_Next; // add to free pool CheckObject.m_Next = m_FreePool; m_FreePool = CheckObject; ThisGameObject.SetActive(false); return (true); } LastObject = CheckObject; CheckObject = CheckObject.m_Next; } return (false); }
internal static PoolObject Create(GameObject Prefab, PoolList Creator, Vector3 spawnPosition, Quaternion spawnRotation) { PoolObject NewPoolObject = new PoolObject(); NewPoolObject.m_Next = null; NewPoolObject.m_GameObject = GameObject.Instantiate(Prefab) as GameObject; NewPoolObject.m_GameObject.transform.parent = Creator.m_Container.transform; NewPoolObject.m_GameObject.transform.position = spawnPosition; NewPoolObject.m_GameObject.transform.rotation = spawnRotation; return(NewPoolObject); }
//o(1) public void ReturnObjectToPool(PoolObject po) { if (poolName.Equals(po.poolName)) { objectsInUse--; /* we could have used availableObjStack.Contains(po) to check if this object is in pool. * While that would have been more robust, it would have made this method O(n) */ if (po.isPooled) { #if UNITY_EDITOR Debug.LogWarning(po.gameObject.name + " is already in pool. Why are you trying to return it again? Check usage."); #endif } else { AddObjectToPool(po); } } else { Debug.LogError(string.Format("Trying to add object to incorrect pool {0} {1}", po.poolName, poolName)); } }
/// <summary> /// Retrieve the next available gameObject from the corresponding pool. Creates a new pool if necessary. /// </summary> /// <param name="prefab">Type of gameObject to return.</param> /// <param name="position"></param> /// <param name="rotation"></param> /// <param name="life">Time in seconds till gameObject gets disabled.</param> /// <returns>Enabled gameObject.</returns> public GameObject Pop(PoolObject prefab, Vector3 position, Quaternion rotation, float life) { while (true) { Pool pool; if (pools.TryGetValue(prefab, out pool)) { Transform popped = pool.Pop(life).transform; popped.position = position; popped.rotation = rotation; return popped.gameObject; } CreatePool(prefab); } }
//o(1) private void AddObjectToPool(PoolObject po) { //add to pool po.gameObject.SetActive(false); po.gameObject.name = poolName; availableObjStack.Push(po); po.isPooled = true; //add to a root obj po.gameObject.transform.SetParent(rootObj.transform, false); }
// Use this for initialization void Start() { BulletTransform = transform; BulletPoolObject = GetComponent<PoolObject>(); StartCoroutine(BulletCoroutine()); }