Update README.md

Author: 2401lucas

README.md

@@ -1,47 +1,33 @@
-# Unity-Object-Pool
-A very simple singleton object pooler for optimization. It can handle all of the object pooling during the game loading and is persistant throughout scenes
+# Unity Generic Object Pool
+An Updated Object pooler to increase performance when pooling many objects.
 
-Currently to get the objects from the pool you need to know the index in the pool, will be changed to use the name.
-# What is pooling? 
-It is computationally expensive to instantiate and destroy objects like bullets that get re-used a lot.
-Its a lot more effective to instantiate them all in the beginning and to keep re-using them by setting them active/false
+# Why use Object Pooling? 
+It is computationally expensive to instantiate and destroy objects, such as bullets, that get re-used a lot.
+Its a lot more performant to instantiate them all and to keep reference and to recycle them.
 
-This script can act as a pooling control hub, it will create all pooled objects you need at the start and objects can be called as and when needed by other scripts.
+To use this object pool you will need to create a script for every pool you will need, and only one object is allowed per pool.
 
-## How to setup
-1) Create a new empty GameObject
-2) Create a new script called ObjectPooler and attach it to the GameObject
-3) Replace the contents of ObjectPooler with contents of the ObjectPooler script that can be found in this repo.
-4) In the inspector, in the script component, enter the number of gameObjects you want pooled and then add their prefabs to the list.
-5) Increase Amount to Pool to at least 1. You can also check the 'Load More If None Left' box if you are unsure on how many you will need
-6) Access the Pooled Objects by using
+# Why use Queue instead of List?
+Queue is benificial to use because it acts similar to a LinkedList in C++. With a Queue, when we Dequeue an object it Pops the first element from the Queue. When we Enqueue an object, it is added to the end of the queue, creating a first in, first out system. We will not need to access objects at specific indecies, therefor a Queue is perfect for what we need. [Read More about when to use Lists or Queues here!](https://stackoverflow.com/questions/10380692/queuet-vs-listt)
 
+## The Setup
+1) Create a new script, call it what you want your pool to be named, IE a enemy pool could be called EnemyPool.cs and attach it to a GameObject
+2) In the script, we will follow the example below. The script will inherite from GenericObjectPool.cs, we will then give it a component type, such as ObjectTobePooled.cs, this could be any script or component that is attachable to a GameObject. 
+```
+public class GenericPool : GenericObjectPool<ObjectTobePooled>
+{
+    public override void AddPoolReference(ObjectTobePooled objectToAddReference) => objectToAddReference.GetComponent<IObjectPool>().pool = this;
+}
 ```
-GameObject GO = ObjectPooler.Instance.GetGameObject(/*Index of the Pooled Object*/);
- //Make changes to your gameObject here
- ```
- 
-# In the Editor
-![image](https://user-images.githubusercontent.com/32739337/102151045-4fa96100-3e48-11eb-9bed-7c8a8cb7eb8f.png)
-
-Here we have the option to enable debugging and to assign new objects to the pool
-
-## Assigning new Objects to the pool
-![image](https://user-images.githubusercontent.com/32739337/102151204-b890d900-3e48-11eb-9eb3-d1654fcea0c7.png)
-
-### Assignables
-Set the name you want to use for retrieving the GameObject from the pool
-
-Set the initial amount you want to be created.
-
-Set the GameOject to be pooled
-
-### Settings
 
-If you enable Load More If None Left, then if the pool runs out of the object you want, it will create a new one and add it to the pool
+3) We then need to override the virtual function AddPoolReference(), on every object that will be pooled, we want to this snipped of code. This creates an Interface that we access to give the pooled object the reference to the pool that it belongs to. This is done so that all we need to do is call pool.Recycle() when the object is no longer needed and it will know the proper pool to Recycle the object into.   
 
-## Debugging
-When Debug is enabled it gives more information on what the pool is doing
+```
+internal interface IObjectPool
+{
+        public GenericPool pool { get; set; }
+}
+```
 
-![image](https://user-images.githubusercontent.com/32739337/102151501-6ef4be00-3e49-11eb-8320-d3e5529cddf4.png)
-![image](https://user-images.githubusercontent.com/32739337/102151883-3b666380-3e4a-11eb-85bf-440009247c92.png)
+## How to use the Pool?
+To access the pool, we want to call our new PoolScript and use the Get() method to return the object we have pooled.