Add Explicit Prewarm to Pool

Added Prewarm to IPool
Implemented Prewarm in PoolSO
Removed private InitializePool in ComponentPoolSO
Added Lazy-Loaded PoolRootObject to ComponentPoolSO
Removed InitialPoolSize property from ComponentPoolSO
Modified Examples to use new workflow
Modified Audio scripts to use new workflow

UOP1_Project/Assets/Scripts/Audio/AudioManager.cs

 		_pool = ScriptableObject.CreateInstance<SoundEmitterPoolSO>();
 		_pool.name = "SoundEmitter Pool";
 		_pool.Factory = _factory;
-		_pool.InitialPoolSize = _initialPoolSize;
+		_pool.Prewarm(_initialPoolSize);
 	}
 
 	public static bool SetGroupVolume(AudioMixerGroup group, float volume)

UOP1_Project/Assets/Scripts/Audio/SoundEmitters/SoundEmitterPoolSO.cs

 {
 	[SerializeField]
 	private SoundEmitterFactorySO _factory;
-	[SerializeField]
-	private int _initialPoolSize;
 
 	public override IFactory<SoundEmitter> Factory
 	{
 		set
 		{
 			_factory = value as SoundEmitterFactorySO;
-		}
-	}
-
-	public override int InitialPoolSize
-	{
-		get
-		{
-			return _initialPoolSize;
-		}
-		set
-		{
-			_initialPoolSize = value;
 		}
 	}
 }

UOP1_Project/Assets/Scripts/Pool/ComponentPoolSO.cs

 	/// <typeparam name="T">Specifies the component to pool.</typeparam>
 	public abstract class ComponentPoolSO<T> : PoolSO<T> where T : Component
 	{
-		public abstract int InitialPoolSize { get; set; }
-
-		private void InitializePool()
-		{
-			_poolRootObject = new GameObject(name);
-			DontDestroyOnLoad(_poolRootObject);
-			for (int i = 0; i < InitialPoolSize; i++)
+		private GameObject PoolRootObject {
+			get
-				_available.Push(Create());
+				if (!Application.isPlaying)
+				{
+					return null;
+				}
+				if (_poolRootObject == null)
+				{
+					_poolRootObject = new GameObject(name);
+					DontDestroyOnLoad(_poolRootObject);
+				}
+				return _poolRootObject;
-			if (_poolRootObject == null)
-			{
-				InitializePool();
-			}
 			T member = base.Request();
 			member.gameObject.SetActive(true);
 			return member;
 		{
-			if (_poolRootObject == null)
-			{
-				InitializePool();
-			}
-			member.transform.SetParent(_poolRootObject.transform);
+			member.transform.SetParent(PoolRootObject.transform);
 			member.gameObject.SetActive(false);
 			base.Return(member);
 		}
 			T newMember = base.Create();
-			newMember.transform.SetParent(_poolRootObject.transform);
+			newMember.transform.SetParent(PoolRootObject.transform);
 			newMember.gameObject.SetActive(false);
 			return newMember;
 		}
 			base.OnDisable();
 #if UNITY_EDITOR
-			DestroyImmediate(_poolRootObject);
+			DestroyImmediate(PoolRootObject);
-			Destroy(_poolRootObject);
+			Destroy(PoolRootObject);
 #endif
 		}
 	}

UOP1_Project/Assets/Scripts/Pool/Example/LocalPoolTester.cs

 		_pool = ScriptableObject.CreateInstance<ParticlePoolSO>();
 		_pool.name = gameObject.name;
 		_pool.Factory = _factory;
-		_pool.InitialPoolSize = _initialPoolSize;
-		List<ParticleSystem> particles = _pool.Request(10) as List<ParticleSystem>;
+		_pool.Prewarm(_initialPoolSize);
+		List<ParticleSystem> particles = _pool.Request(2) as List<ParticleSystem>;
 		foreach (ParticleSystem particle in particles)
 		{
 			StartCoroutine(DoParticleBehaviour(particle));

UOP1_Project/Assets/Scripts/Pool/Example/ParticlePoolSO.cs

 {
 	[SerializeField]
 	private ParticleFactorySO _factory;
-	[SerializeField]
-	private int _initialPoolSize;
 
 	public override IFactory<ParticleSystem> Factory
 	{
 		set
 		{
 			_factory = value as ParticleFactorySO;
-		}
-	}
-
-	public override int InitialPoolSize
-	{
-		get
-		{
-			return _initialPoolSize;
-		}
-		set
-		{
-			_initialPoolSize = value;
 		}
 	}
 }

UOP1_Project/Assets/Scripts/Pool/IPool.cs

 	/// <typeparam name="T">Specifies the type of elements in the pool.</typeparam>
 	public interface IPool<T>
 	{
+		void Prewarm(int num);
 		T Request();
 		void Return(T member);
 	}

UOP1_Project/Assets/Scripts/Pool/PoolSO.cs

 	{
 		protected readonly Stack<T> _available = new Stack<T>();
 		public abstract IFactory<T> Factory { get; set; }
+		protected bool HasBeenPrewarmed { get; set; }
+		}
+
+		public virtual void Prewarm(int num)
+		{
+			if (HasBeenPrewarmed)
+			{
+				Debug.LogWarning($"Pool {name} has already been prewarmed.");
+				return;
+			}
+			for (int i = 0; i < num; i++)
+			{
+				_available.Push(Create());
+			}
+			HasBeenPrewarmed = true;
 		}
 
 		public virtual T Request()