-
Notifications
You must be signed in to change notification settings - Fork 0
/
SimplePool.cs
260 lines (228 loc) · 8.84 KB
/
SimplePool.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
using UnityEngine;
using System.Collections.Generic;
public static class SimplePool
{
// You can avoid resizing of the Stack's internal data by
// setting this to a number equal to or greater to what you
// expect most of your pool sizes to be.
// Note, you can also use Preload() to set the initial size
// of a pool -- this can be handy if only some of your pools
// are going to be exceptionally large (for example, your bullets.)
private const int DEFAULT_POOL_SIZE = 3;
/// <summary>
/// The Pool class represents the pool for a particular prefab.
/// </summary>
public class Pool
{
// We append an id to the name of anything we instantiate.
// This is purely cosmetic.
private int _nextId = 1;
// The structure containing our inactive objects.
// Why a Stack and not a List? Because we'll never need to
// pluck an object from the start or middle of the array.
// We'll always just grab the last one, which eliminates
// any need to shuffle the objects around in memory.
private readonly Queue<GameObject> _inactive;
//A Hashset which contains all GetInstanceIDs from the instantiated GameObjects
//so we know which GameObject is a member of this pool.
public readonly HashSet<int> MemberIDs;
// The prefab that we are pooling
private readonly GameObject _prefab;
public int StackCount
{
get { return _inactive.Count; }
}
// Constructor
public Pool(GameObject prefab, int initialQty)
{
_prefab = prefab;
// If Stack uses a linked list internally, then this
// whole initialQty thing is a placebo that we could
// strip out for more minimal code. But it can't *hurt*.
_inactive = new Queue<GameObject>(initialQty);
MemberIDs = new HashSet<int>();
}
public void Preload(int initialQty, Transform parent = null)
{
for (int i = 0; i < initialQty; i++)
{
// instantiate a whole new object.
var obj = GameObject.Instantiate(_prefab, parent);
obj.name = string.Format("{0} ({1})", _prefab.name, _nextId++);
// Add the unique GameObject ID to our MemberHashset so we know this GO belongs to us.
MemberIDs.Add(obj.GetInstanceID());
obj.SetActive(false);
_inactive.Enqueue(obj);
}
}
// Spawn an object from our pool
public GameObject Spawn(Vector3 pos, Quaternion rot)
{
while (true)
{
GameObject obj;
if (_inactive.Count == 0)
{
// We don't have an object in our pool, so we
// instantiate a whole new object.
obj = GameObject.Instantiate(_prefab, pos, rot);
obj.name = string.Format("{0} ({1})", _prefab.name, _nextId++);
// Add the unique GameObject ID to our MemberHashset so we know this GO belongs to us.
MemberIDs.Add(obj.GetInstanceID());
}
else
{
// Grab the last object in the inactive array
obj = _inactive.Dequeue();
if (obj == null)
{
// The inactive object we expected to find no longer exists.
// The most likely causes are:
// - Someone calling Destroy() on our object
// - A scene change (which will destroy all our objects).
// NOTE: This could be prevented with a DontDestroyOnLoad
// if you really don't want this.
// No worries -- we'll just try the next one in our sequence.
continue;
}
}
obj.transform.position = pos;
obj.transform.rotation = rot;
obj.SetActive(true);
return obj;
}
}
public T Spawn<T>(Vector3 pos, Quaternion rot)
{
return Spawn(pos, rot).GetComponent<T>();
}
//public void ManuelPush(GameObject obj)
//{
// inactive.Push(obj);
//}
// Return an object to the inactive pool.
public void Despawn(GameObject obj)
{
if (!obj.activeSelf)
return;
obj.SetActive(false);
// Since Stack doesn't have a Capacity member, we can't control
// the growth factor if it does have to expand an internal array.
// On the other hand, it might simply be using a linked list
// internally. But then, why does it allow us to specify a size
// in the constructor? Maybe it's a placebo? Stack is weird.
_inactive.Enqueue(obj);
}
}
// All of our pools
public static Dictionary<int, Pool> _pools;
/// <summary>
/// Initialize our dictionary.
/// </summary>
private static void Init(GameObject prefab = null, int qty = DEFAULT_POOL_SIZE)
{
if (_pools == null)
_pools = new Dictionary<int, Pool>();
if (prefab != null)
{
//changed from (prefab, Pool) to (int, Pool) which should be faster if we have
//many different prefabs.
var prefabID = prefab.GetInstanceID();
if (!_pools.ContainsKey(prefabID))
_pools[prefabID] = new Pool(prefab, qty);
}
}
public static void PoolPreLoad(GameObject prefab, int qty, Transform newParent = null)
{
Init(prefab, 1);
_pools[prefab.GetInstanceID()].Preload(qty, newParent);
}
/// <summary>
/// If you want to preload a few copies of an object at the start
/// of a scene, you can use this. Really not needed unless you're
/// going to go from zero instances to 100+ very quickly.
/// Could technically be optimized more, but in practice the
/// Spawn/Despawn sequence is going to be pretty darn quick and
/// this avoids code duplication.
/// </summary>
public static GameObject[] Preload(GameObject prefab, int qty = 1, Transform newParent = null)
{
Init(prefab, qty);
// Make an array to grab the objects we're about to pre-spawn.
var obs = new GameObject[qty];
for (int i = 0; i < qty; i++)
{
obs[i] = Spawn(prefab, Vector3.zero, Quaternion.identity);
if (newParent != null)
obs[i].transform.SetParent(newParent);
}
// Now despawn them all.
for (int i = 0; i < qty; i++)
Despawn(obs[i]);
return obs;
}
/// <summary>
/// Spawns a copy of the specified prefab (instantiating one if required).
/// NOTE: Remember that Awake() or Start() will only run on the very first
/// spawn and that member variables won't get reset. OnEnable will run
/// after spawning -- but remember that toggling IsActive will also
/// call that function.
/// </summary>
///
public static GameObject Spawn(GameObject prefab, Vector3 pos, Quaternion rot)
{
Init(prefab);
return _pools[prefab.GetInstanceID()].Spawn(pos, rot);
}
public static GameObject Spawn(GameObject prefab)
{
return Spawn(prefab, Vector3.zero, Quaternion.identity);
}
public static T Spawn<T>(T prefab) where T : Component
{
return Spawn(prefab, Vector3.zero, Quaternion.identity);
}
public static T Spawn<T>(T prefab, Vector3 pos, Quaternion rot) where T : Component
{
Init(prefab.gameObject);
return _pools[prefab.gameObject.GetInstanceID()].Spawn<T>(pos, rot);
}
/// <summary>
/// Despawn the specified gameobject back into its pool.
/// </summary>
public static void Despawn(GameObject obj)
{
Pool p = null;
foreach (var pool in _pools.Values)
{
if (pool.MemberIDs.Contains(obj.GetInstanceID()))
{
p = pool;
break;
}
}
if (p == null)
{
Debug.LogFormat("Object '{0}' wasn't spawned from a pool. Destroying it instead.", obj.name);
Object.Destroy(obj);
}
else
{
p.Despawn(obj);
}
}
public static int GetStackCount(GameObject prefab)
{
if (_pools == null)
_pools = new Dictionary<int, Pool>();
if (prefab == null) return 0;
return _pools.ContainsKey(prefab.GetInstanceID()) ? _pools[prefab.GetInstanceID()].StackCount : 0;
}
public static void ClearPool()
{
if (_pools != null)
{
_pools.Clear();
}
}
}