The actual pool used by the pooling system, multiple instances of these will be created per unique Prefab or GameObject. More...

Public Member Functions
	ObjectPoolCollection (int preload, bool spawnMore, bool slowMessage, bool handleParticles, bool trackSpawned, bool cullExtras, float cullInterval)

void	AddToPool ()

void	Initialize (GameObject prefab, Transform parent, int poolID)

void	CullUpdate ()

void	Despawn (GameObject gameObject)

void	Despawn (GameObject gameObject, bool onSpawn)

void	DespawnImmediate (GameObject gameObject)

bool	RemoveFromPool (GameObject gameObject, bool destroyObject)

GameObject	Spawn ()
	Spawn an object from the pool at origin. More...

GameObject	Spawn (Vector3 location, Quaternion rotation)
	Spawn an object from the pool at the specified world location and rotation. More...

Public Attributes
bool	CullExtras
	Should extra objects be culled when not in use? More...

float	CullInterval
	How often should we look at culling extra objects. More...

bool	DespawnPoolLocation = true
	Should despawned object be returned to it's pool's origin position? More...

bool	ManageParticles = true
	Should particle systems be appropriately handled when despawning? More...

GameObject	Prefab
	Reference to the Prefab or GameObject used by this Object Pool. More...

int	PreloadAmount
	The number of objects to preload in an Object Pool. More...

bool	SendMessage
	Should Unity's SendMessage be used. (OnSpawned, WaitToDespawn, OnDespawned) More...

bool	SpawnMore
	Should additional objects be spawned as needed? More...

bool	TrackObjects
	Should objects be tracked when they are spawned? More...

Properties
bool	HasObjectPoolItem `[get]`

bool	HasRigidbody `[get]`

bool	HasParticleSystem `[get]`

bool	HasLegacyParticleAnimator `[get]`

bool	HasLegacyParticleEmitter `[get]`

GameObject[]	SpawnedObjects `[get]`

bool	Initialized `[get]`

Detailed Description

The actual pool used by the pooling system, multiple instances of these will be created per unique Prefab or GameObject.

Definition at line 37 of file ObjectPoolCollection.cs.

Constructor & Destructor Documentation

Hydrogen.Core.ObjectPoolCollection.ObjectPoolCollection	(	int	preload,
		bool	spawnMore,
		bool	slowMessage,
		bool	handleParticles,
		bool	trackSpawned,
		bool	cullExtras,
		float	cullInterval
	)

Definition at line 161 of file ObjectPoolCollection.cs.

                 {
                         ManageParticles = handleParticles;
                         PreloadAmount = preload;
                         SpawnMore = spawnMore;
                         SendMessage = slowMessage;
                         TrackObjects = trackSpawned;
                         CullExtras = cullExtras;
                         CullInterval = cullInterval;
                         _cullTimer = cullInterval;
                 }

Member Function Documentation

void Hydrogen.Core.ObjectPoolCollection.AddToPool ( )

Definition at line 173 of file ObjectPoolCollection.cs.

                 {
                         var newObject = Object.Instantiate (Prefab) as GameObject;
                         newObject.name = Prefab.name;
 
 
                         // Check if there is our helper item on the gameObject
                         if (newObject.GetComponent<ObjectPoolItemBase> ()) {
                                 newObject.GetComponent<ObjectPoolItemBase> ().ParentPool = this;
                                 newObject.GetComponent<ObjectPoolItemBase> ().PoolID = _poolID;
                         }
 
                         Array.Add<GameObject> (ref _pooledObjects, newObject, false);
 
                         Despawn (newObject, true);
                 }

void Hydrogen.Core.ObjectPoolCollection.CullUpdate ( )

Definition at line 216 of file ObjectPoolCollection.cs.

                 {
                         if (!TrackObjects || !_hasObjectPoolItem)
                                 return;
 
                         _cullTimer -= Time.deltaTime;
 
                         if (_cullTimer <= 0) {
                                 for (int x = 0; x < SpawnedObjects.Length; x++) {
                                         if (SpawnedObjects [x].GetComponent<ObjectPoolItemBase> ().IsInactive ()) {
                                                 Despawn (SpawnedObjects [x]);
                                         }
                                 }
                                 // Establish Timer Again
                                 _cullTimer = CullInterval;
                         }
                 }

void Hydrogen.Core.ObjectPoolCollection.Despawn ( GameObject gameObject )

Definition at line 234 of file ObjectPoolCollection.cs.

                 {
                         Despawn (gameObject, false);
                 }

void Hydrogen.Core.ObjectPoolCollection.Despawn	(	GameObject	gameObject,
		bool	onSpawn
	)

Definition at line 239 of file ObjectPoolCollection.cs.

                 {
                         if (!ManageParticles)
                                 gameObject.transform.parent = _parentTransform;
 
                         // Has our handler
                         if (_hasObjectPoolItem) {
                                 if (ManageParticles) {
                                         gameObject.GetComponent<ObjectPoolItemBase> ().DespawnSafely ();    
                                         return;
                                 }
                                 gameObject.GetComponent<ObjectPoolItemBase> ().OnDespawned ();  
 
                         }
                         // Use slow method
                         else if (SendMessage) {
                                 if (ManageParticles) {
                                         gameObject.SendMessage ("WaitToDespawn", SendMessageOptions.DontRequireReceiver);
                                         return;
                                 }
                                 gameObject.SendMessage ("OnDespawned", SendMessageOptions.DontRequireReceiver);
                         }
                         // Fail safe
                         else {
                                 // This stops things from keeping their velocity from previous
                                 if (_hasRigidbody) {
                                         gameObject.rigidbody.velocity = Vector3.zero;
                                         gameObject.rigidbody.angularVelocity = Vector3.zero;
                                 }
 
                                 gameObject.SetActive (false);
 
                         }
 
                         if (DespawnPoolLocation && _parentTransform != null) {
                                 gameObject.transform.position = _parentTransform.position;
                         }
 
                         if (!onSpawn) {
                                 if (TrackObjects)
                                         Array.Remove<GameObject> (ref _spawnedObjects, gameObject);
                                 Array.Add<GameObject> (ref _pooledObjects, gameObject, false);
                         }
                 }

void Hydrogen.Core.ObjectPoolCollection.DespawnImmediate ( GameObject gameObject )

Definition at line 284 of file ObjectPoolCollection.cs.

                 {
                         gameObject.transform.parent = _parentTransform;
                         if (TrackObjects)
                                 Array.Remove<GameObject> (ref _spawnedObjects, gameObject);
                         Array.Add<GameObject> (ref _pooledObjects, gameObject, false);  
                 }

void Hydrogen.Core.ObjectPoolCollection.Initialize	(	GameObject	prefab,
		Transform	parent,
		int	poolID
	)

Definition at line 190 of file ObjectPoolCollection.cs.

                 {
                         Prefab = prefab;
 
                         _parentTransform = parent;
                         _poolID = poolID;
                         _pooledObjects = new GameObject[0];
 
                         _hasObjectPoolItem |= Prefab.GetComponent<ObjectPoolItemBase> ();
 
                         _hasRigidbody |= prefab.GetComponent<Rigidbody> ();
 
                         if (ManageParticles) {
                                 _hasLegacyParticleEmitter |= prefab.GetComponent<ParticleEmitter> ();
                                 _hasLegacyParticleAnimator |= prefab.GetComponent<ParticleAnimator> ();
                                 _hasParticleSystem |= prefab.GetComponent<ParticleSystem> ();
                         }
 
                         ManageParticles &= _hasLegacyParticleAnimator || _hasLegacyParticleEmitter || _hasParticleSystem;
 
                         for (int x = 0; x < PreloadAmount; x++) {
                                 AddToPool ();
                         }
                         _initialized = true;
                 }

bool Hydrogen.Core.ObjectPoolCollection.RemoveFromPool	(	GameObject	gameObject,
		bool	destroyObject
	)

Definition at line 292 of file ObjectPoolCollection.cs.

                 {
                         if (destroyObject) {
 
                                 Object.DestroyImmediate (gameObject);
                                 return Array.Remove<GameObject> (ref _pooledObjects, gameObject);
                         }
                         return Array.Remove<GameObject> (ref _pooledObjects, gameObject);
 
                 }

GameObject Hydrogen.Core.ObjectPoolCollection.Spawn ( )

Spawn an object from the pool at origin.

Definition at line 306 of file ObjectPoolCollection.cs.

                 {
                         return Spawn (Vector3.zero, Quaternion.identity);
                 }

GameObject Hydrogen.Core.ObjectPoolCollection.Spawn	(	Vector3	location,
		Quaternion	rotation
	)

Spawn an object from the pool at the specified world location and rotation.

Parameters

location	Spawn Location
rotation	Spawn Rotation

Definition at line 316 of file ObjectPoolCollection.cs.

                 {
                         if (_pooledObjects != null && _pooledObjects.Length > 0) {
                                 GameObject spawnedObject = _pooledObjects [0];
 
                                 if (spawnedObject == null) {
                                         UnityEngine.Debug.LogError (
                                                 "[h] A GameObject (" + Prefab.name + ") has been destroyed," +
                                                 "but is still referenced by the Object Pool. If you must destroy a GameObject manually," +
                                                 "please make sure to remove it from the pool as well:" +
                                                 "hObjectPool.Instance.Remove(GameObject);");
 
                                         return null;
                                 }
 
                                 Array.RemoveAt<GameObject> (ref _pooledObjects, 0);
 
                                 // Move and rotate before we call on spawned
                                 spawnedObject.transform.position = location;
                                 spawnedObject.transform.rotation = rotation;
 
                                 if (ManageParticles) {
                                         spawnedObject.GetComponent<ParticleAnimator> ().autodestruct &= !_hasLegacyParticleAnimator;
                                         spawnedObject.GetComponent<ParticleEmitter> ().emit |= _hasLegacyParticleEmitter;
                                 }
 
                                 if (_hasObjectPoolItem) {
                                         spawnedObject.GetComponent<ObjectPoolItemBase> ().OnSpawned ();
                                 } else if (SendMessage) {
                                         spawnedObject.SendMessage ("OnSpawned", SendMessageOptions.DontRequireReceiver);
                                 } else {
                                         spawnedObject.SetActive (true);
                                 }
 
                                 if (TrackObjects) {
                                         // No already spawned objects
                                         if (_spawnedObjects == null)
                                                 _spawnedObjects = new GameObject[0];
 
                                         Array.Add<GameObject> (ref _spawnedObjects, spawnedObject, false);
                                 }
 
                                 return spawnedObject;
                         }
                         if (SpawnMore) {
                                 AddToPool ();
                                 return Spawn (location, rotation);
                         }
                         return null;
                 }

Member Data Documentation

bool Hydrogen.Core.ObjectPoolCollection.CullExtras

Should extra objects be culled when not in use?

Definition at line 42 of file ObjectPoolCollection.cs.

float Hydrogen.Core.ObjectPoolCollection.CullInterval

How often should we look at culling extra objects.

Definition at line 46 of file ObjectPoolCollection.cs.

bool Hydrogen.Core.ObjectPoolCollection.DespawnPoolLocation = true

Should despawned object be returned to it's pool's origin position?

Definition at line 50 of file ObjectPoolCollection.cs.

bool Hydrogen.Core.ObjectPoolCollection.ManageParticles = true

Should particle systems be appropriately handled when despawning?

Definition at line 54 of file ObjectPoolCollection.cs.

GameObject Hydrogen.Core.ObjectPoolCollection.Prefab

Reference to the Prefab or GameObject used by this Object Pool.

Definition at line 58 of file ObjectPoolCollection.cs.

int Hydrogen.Core.ObjectPoolCollection.PreloadAmount

The number of objects to preload in an Object Pool.

Definition at line 62 of file ObjectPoolCollection.cs.

bool Hydrogen.Core.ObjectPoolCollection.SendMessage

Should Unity's SendMessage be used. (OnSpawned, WaitToDespawn, OnDespawned)

Definition at line 66 of file ObjectPoolCollection.cs.

bool Hydrogen.Core.ObjectPoolCollection.SpawnMore

Should additional objects be spawned as needed?

Definition at line 70 of file ObjectPoolCollection.cs.

bool Hydrogen.Core.ObjectPoolCollection.TrackObjects

Should objects be tracked when they are spawned?

Useful for when you need to keep track of what objects are in use.

Definition at line 77 of file ObjectPoolCollection.cs.

Property Documentation

bool Hydrogen.Core.ObjectPoolCollection.HasLegacyParticleAnimator

get

Definition at line 141 of file ObjectPoolCollection.cs.

bool Hydrogen.Core.ObjectPoolCollection.HasLegacyParticleEmitter

get

Definition at line 147 of file ObjectPoolCollection.cs.

bool Hydrogen.Core.ObjectPoolCollection.HasObjectPoolItem

get

Definition at line 123 of file ObjectPoolCollection.cs.

bool Hydrogen.Core.ObjectPoolCollection.HasParticleSystem

get

Definition at line 135 of file ObjectPoolCollection.cs.

bool Hydrogen.Core.ObjectPoolCollection.HasRigidbody

get

Definition at line 129 of file ObjectPoolCollection.cs.

bool Hydrogen.Core.ObjectPoolCollection.Initialized

get

Definition at line 155 of file ObjectPoolCollection.cs.

GameObject [] Hydrogen.Core.ObjectPoolCollection.SpawnedObjects

get

Definition at line 153 of file ObjectPoolCollection.cs.

Public Member Functions

Public Attributes

Properties

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

Property Documentation