이번에는 게임 오브젝트의 "풀링"이라는 개념에 대해서 알아볼 것이다,
요즘은 하드웨어 성능이 좋아져서 1인게임이나 규모가 작은 게임을 만들때 굳이 풀링을 할필요는 없지만
FPS게임의 총알같은 경우, 아니면 조금이나마의 성능 향상을 위해서 풀링을 하는것이다.
먼저 풀링의 개념은 우리가 GameObject를 불러올때, Resource 에서 Load 한다음 Instantiate으로 GameObject에 Load한것을 복사하는 방식으로 Instantiate를 해주었는데,
계속사용해야하는 GameObject나(ex 총알) 같은경우에 계속 Load하는 식으로 GameObject를 불러오면 부화나 속도가 느려질 수 있기때문에
필요없거나 필요한 GameObject(배우)들을 집으로 돌려보내는 것이 아니라 대기실에 대기를 하는상태로 두었다가 필요시에 바로 대기실에서 빠르게 꺼내오는 방법을 "Pooling"**이라고한다.**
우리는 필요한 GameObject들을 프리팹에 모아서 이것을 Load를 통해 가져왔는데
prefab에 있는 GameObject들 중에 풀링이 필요한 녀석인지 아닌지 구별부터 해야한다.
그래서 전체적인 순서는
1. 풀링이 필요한 GameObject인지 아닌지 구별
2. 풀링이 필요한 녀석들을 어떻게 넣을 것인지
3. 풀링이 필요한 녀석들을 어떻게 꺼내올 것인지
이다.
그래서 먼저 풀링이 필요한지 아닌지 구별하기위해서 프리팹에있는 GameObject들에 비어있는 컴포넌트를 붙여준 상태로 프리팹에 저장을 먼저 하도록하자
먼저 Poolable이라는 스크립트(컴포넌트)를 만들어준다
이 컴포넌트는 단순히 풀링할것인지 아닌지 구별하기 위한 것이므로 안에 내용은 비워둔다(허전하니까 bool 하나 넣어주도록하자)
이후 풀링할 게임오브젝트에 넣어준다.
현재 풀링할 UnityChan이라는 게임오브젝트에 넣어주었다.
지금은 한개로 실습을 하지만,
풀링할 게임 오브젝트가 많다면 풀링할 것들 안에 해당 게임오브젝트들이 들어갈것인데
그냥 막 다 때려 넣어버리면 구별하기가 힘들것이니
풀링할 것들 안에 풀링할 게임오브젝트별로 구별을 해주어야한다.
예를들면
> 풀링할것들(최상위부모, Pool_Root)
-> 풀링할 게임오브젝트1(UnityChan_Root)
--> 대기하고있는 풀링된 게임오브젝트1(UnityChan)
--> 대기하고있는 풀링된 게임오브젝트1(UnityCahn)
-> 풀링할 게임오브젝트2(Tank Root)
--> 대기하고있는 풀링된 게임오브젝트2(Tank)
--> 대기하고있는 풀링된 게임오브젝트2(Tank)
이런식으로 구별을 해줘야한다.
그리고 저렇게 대기실에 있는 경우 필요시에 바로 Load를 통해서 가져올 필요 없이 풀링한곳에서 바로 꺼내 오는 것이다.
그럼이제 어떻게 풀링할것들을 넣고 꺼내오고 생성을 할지 살펴보자.
먼저 실행을 한다면 바로
public void init()
{
if(_root == null)
{@
_root = new GameObject { name = "@Pool_Root" }.transform;
Object.DontDestroyOnLoad(_root);
}
} 로 삭제가 되지 않도록 만들어주고
public void Push()
{
{
public void Pop()
{
}이런식으로 Pool_Root산하에 풀링할 게임오브젝트를 넣어줄 수 있도록 함수를 만들어 주자.
현재
Resource Manager는
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System;
public class ResourceManager
{
public T Load<T>(string path) where T : UnityEngine.Object
{
if(typeof(T) == typeof(GameObject)) // 이렇다면 프리팹일 확률이 굉장히 높다는 것이다.
{
string name = path;
int index = name.LastIndexOf('/');
if (index >= 0)
name = name.Substring(index + 1);
GameObject go = Managers.Pool.GetOriginal(name);
if (go != null)
return go as T;
}
return Resources.Load<T>(path);
}
public GameObject Instantiate(string path, Transform parent = null)
{
// 1. original 이미 들고있으면 바로 사용 => 구현함 Load부분에서
GameObject original = Load<GameObject>($"Prefabs/{path}");
if (original == null)
{
Debug.Log($"Fail to load prefab : {path}");
return null;
}
// 2. 혹시 풀링된 애가 있을까?
if (original.GetComponent<Poolable>() != null) // 없다면 무시하고 원래대로 돌아가면 될것이다.
return Managers.Pool.Pop(original, parent).gameObject;
GameObject go = UnityEngine.Object.Instantiate(original, parent);
//int index = go.name.IndexOf("(Clone)");
//if (index > 0)
// go.name = go.name.Substring(0, index);
// 위에 3줄이랑 go.name = original.name;이랑 같은것이다.
//GameObject go = Object.Instantiate(original, parent); 이렇게하는거랑 UnityEngine.Object.Instantiate(original, parent); 이거랑 같다
go.name = original.name;
return go;
}
public void Destroy(GameObject go)
{
if (go == null)
return;
// 3. 필요없다고 바로 없애는것이 아니라(풀링이 필요한 아이라면) -> 풀링매니저한테 위탁을 해준다.
Poolable poolable = go.GetComponent<Poolable>();
if(poolable != null)
{
Managers.Pool.Push(poolable);
return;
}
UnityEngine.Object.Destroy(go);
//Object.Destrot(go);
}
}
이렇고
PoolManager의 코드는
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class PoolManager
{
#region Pool
class Pool
{
public GameObject Original { get; private set; }
public Transform Root { get; set; }
Stack<Poolable> _poolStack = new Stack<Poolable>();
public void init(GameObject original, int count = 5)
{
Original = original;
Root = new GameObject().transform; // 위에서 Root를 Transform으로 설정해놔서
Root.name = $"{original.name}_Root";
for(int i =0; i < 5; i++)
{
Push(Create());
}
}
Poolable Create()
{
GameObject go = Object.Instantiate<GameObject>(Original);
go.name = Original.name;
return go.GetOrAddComponent<Poolable>();
}
public void Push(Poolable poolable)
{
if(poolable == null)
{
return;
// 없다면 바로 끝낸다.
}
poolable.transform.parent = Root;
// 영상 꺼놓는 부분
poolable.gameObject.SetActive(false);
poolable.isUsing = false;
// 이렇게까지해서 설정이 완료되었으니 stack에 넣어주면된다.
_poolStack.Push(poolable);
}
public Poolable Pop(Transform parent)
{
Poolable poolable;
if (_poolStack.Count > 0)
poolable = _poolStack.Pop();
else
poolable = Create();
poolable.gameObject.SetActive(true);
// DontDestroyOnLoad 해제 용도
// 한번이라도 DontDestroyOnLoad 위로 이동을 했다면 정상적으로 잘 작동을 할것이다.
if (parent == null)
poolable.transform.parent = Managers.Scene.CurrenScene.transform;
poolable.transform.parent = parent;
poolable.isUsing = true;
return poolable;
}
}
#endregion
Dictionary<string, Pool> _pool = new Dictionary<string, Pool>();
Transform _root;
public void init()
{
if(_root == null)
{
_root = new GameObject { name = "@Pool_Root" }.transform;
Object.DontDestroyOnLoad(_root);
}
}
public void CreatePool(GameObject original, int count = 5)
{
Pool pool = new Pool(); // 새로운 class생성
pool.init(original, count);
pool.Root.parent = _root;
// 현재 _root가 Transform 이니까 pool.Root.parent = _root.trnasform이랑 같은 말이다.
_pool.Add(original.name, pool);
}
public void Push(Poolable poolable)
{
string name = poolable.gameObject.name;
if(_pool.ContainsKey(name) == false)
{
GameObject.Destroy(poolable.gameObject);
return;
}
_pool[name].Push(poolable);
}
public Poolable Pop(GameObject original, Transform parent = null)
{
if (_pool.ContainsKey(original.name) == false)
{
CreatePool(original);
}
return _pool[original.name].Pop(parent);
}
public GameObject GetOriginal(string name)
{
if (_pool.ContainsKey(name) == false)
{
return null;
}
return _pool[name].Original;
}
public void Clear()
{
foreach (Transform child in _root)
GameObject.Destroy(child.gameObject);
_pool.Clear();
}
}
이렇다.
그래서 우리는 게임 오브젝틀 불러올때 ResourceManager의 Instantiate를 통해서 불러올 것인데,
Instantiate를 할때 Load함수를 통해서 T(type)을 꺼내오고 return Resources.Load(path);
를 해준다. 해당 path를 받아서 Poolable컴포넌트를 가지고있다면 이것을 Instantiate안에 original에게 할당을 해주는것이다.
그리고 해당 GameObject가 Poolable 컴포넌트를 가지고있는지 안가지고있는지
구분을 한다음에
해당 컴포넌트를 가지고있다면 PoolManager의 Pop함수를통해서 바로 꺼내오고
아니라면 원래대로 Resource.Instantiate를 통해 생성을 해줘야한다.
근데 여기서 풀링하는 녀석은 맞는데 처음 Pop을 하게되는 경우에는
모든 Pool을관리하는 우리 _pool에 처음 풀링하는 녀석은 Pop을 할게 없는 상태이기때문에 에러가 나거나 아무것도 Pop을 하지 못할 것이기때문에
PoolManager 에서 처음 Pop을 하는 경우를 생각을해서 해당 Pool을 만들어 줘야한다.
이부분이
PoolManager안의 Pool Class안의
public Poolable Pop(Transform parent)
{
Poolable poolable;
if (_poolStack.Count > 0)
poolable = _poolStack.Pop();
else
poolable = Create();
poolable.gameObject.SetActive(true);
if (parent == null)
poolable.transform.parent = Managers.Scene.CurrenScene.transform;
poolable.transform.parent = parent;
poolable.isUsing = true;
return poolable;
}Pop함수가 될것이다.
PoolManager의 코드를 하나씩 설명을하자면
먼저 Pool Class 가 있다.
위에서 말했던 UnityChan_Root안에 들어갈 녀석들을 관리할 Pool이고
Class Pool밑에 _pool 딕셔너리가 게임오브젝트들의 Root를 관리할 딕셔너리가 될것이다.
여기에서 Push, Pop, Create를 통해 Pool을 만들어내고
Class Pool에서 풀링할 GameObject들을 Push, Pop, Create를 다시 해주는것이다.
풀링할 코드는 자기마음대로 호율적이라 생각되는 부분으로 짜는것이 좋지만
저는
풀링할 것들을 나누고
풀링할 게임오브젝트들을 구별하기위한 Root오브젝트를 만들어서
제일큰 Root밑에 작은 Root를 나둬서 게임오브젝트들을 해당 작은Root산하에 집어 넣는 방식으로 풀링을 하였다.
이상 게임오브젝트의 풀링에 대한 설명이였습니다.
