Documentation tweaks.

Author: ThirdPartyNinjas

CatmullRomSpline2D/README.md

@@ -29,21 +29,21 @@ Okay, we've created some splines, let's see how to use them.
 These splines are designed to be used as paths for game objects to move along. To find your position on the path, first you need to know what segment you are in by passing the distance along the path from the beginning. This will give you the current segment number and your position inside that segment.
 
 ```
-	int segment;
-	float s;
-	path.GetSegment(distanceAlongPath, out segment, out s);
+int segment;
+float s;
+path.GetSegment(distanceAlongPath, out segment, out s);
 ```
 
 Next, you'll need to pass that data to the GetPosition method to receive a Vector2 of your position in world space.
 
 ```
-	Vector2 position = path.GetPosition(segment, s);
+Vector2 position = path.GetPosition(segment, s);
 ```
 
 Finally, if you'd like to know the direction of the path at that position, you can pass the segment info to that GetDirection method.
 
 ```
-	var direction = path.GetDirection(segment, s);
+var direction = path.GetDirection(segment, s);
 ```	
 
 And that's it! There's a simple example solution in the demos folder showing a spaceship moving along first an S-shaped path and then a Z-shaped path. See [FollowPath.cs](../Demos/CatmullRomSpline2D/FollowPath.cs) for a code example.

PrefabPool/README.md

@@ -6,56 +6,56 @@ This application of an object pool specifically focuses on reusing spawned prefa
 
 ## Usage
 
-To use a prefab with PrefabPool, your game object must be PrefabMonoBehaviour instead of Unity's standard MonoBehaviour class. It's a very thin wrapper that adds a field so that we can tag it with the prefab the game object was spawned from. This is used to sort back into the correct pool collection when the object is returned.
+To use a prefab with PrefabPool, your game object must be derived from PrefabMonoBehaviour instead of Unity's standard MonoBehaviour class. It's a very thin wrapper that adds a field so that we can tag it with the prefab the game object was spawned from. This is used to sort back into the correct pool collection when the object is returned.
 
-While it's not required, I recommend adding a public Reset method to your class and handling your initialization there. You can't rely on Awake and Start for initialization, because the object is only spawned once. OnEnable and OnDisable will still work, though.
+While it's not required, it's recommended to add a public Reset method to your class and handle your initialization there. You can't rely on Awake and Start for initialization, because the object is only spawned once and recycled. OnEnable and OnDisable will still work normally, though.
 
 For example:
 
 ```
-	public class PoolDemoShip : PrefabMonoBehaviour
+public class PoolDemoShip : PrefabMonoBehaviour
+{
+	Vector3 speed = Vector3.zero;
+
+	public void Reset()
 	{
-		Vector3 speed = Vector3.zero;
-
-		public void Reset()
-		{
-			transform.position = Vector3.zero;
-			speed.x = Random.Range(-10.0f, 10.0f);
-			speed.y = Random.Range(-10.0f, 10.0f);
-			speed.z = 0.0f;
-		}
+		transform.position = Vector3.zero;
+		speed.x = Random.Range(-10.0f, 10.0f);
+		speed.y = Random.Range(-10.0f, 10.0f);
+		speed.z = 0.0f;
 	}
+}
 ```
 
 To take or return game objects from the pool, simply call the TakeObject or ReturnObject methods. TakeObject takes and optional Transform parameter if you want the retrieved object to be parented for you.
 
 Taking example:
 
 ```
-	GameObject shipPrefab;
+GameObject shipPrefab;
 
-	void Update()
+void Update()
+{
+	if(readyToTake)
 	{
-		if(readyToTake)
-		{
-			var ship = PrefabPool.Instance.TakeObject<PoolDemoShip>(shipPrefab);
-			ship.Reset();
-		}
+		var ship = PrefabPool.Instance.TakeObject<PoolDemoShip>(shipPrefab);
+		ship.Reset();
 	}
+}
 ```
 
 Returning example:
 
 ```
-	// in the PoolDemoShip class
+// in the PoolDemoShip class
 
-	void Update()
+void Update()
+{
+	if(readyToReturn)
 	{
-		if(readyToReturn)
-		{
-			PrefabPool.Instance.ReturnObject(this);
-		}
+		PrefabPool.Instance.ReturnObject(this);
 	}
+}
 ```
 
 ### Note

docs/README.md

@@ -26,26 +26,26 @@ An implementation of the [Singleton pattern](https://en.wikipedia.org/wiki/Singl
 Derive your class from MonoBehaviourSingleton. If you don't want the object to persist on Unity scene changes (when it would otherwise be destroyed) override the PersistOnSceneChange property.
 
 ```
-	public class SingletonExample : MonoBehaviourSingleton<SingletonExample>
-	{
-		public override bool PersistOnSceneChange { get { return false; } }
-	}
+public class SingletonExample : MonoBehaviourSingleton<SingletonExample>
+{
+	public override bool PersistOnSceneChange { get { return false; } }
+}
 ```
 
 When you want to get an instance of the object or create one if it doesn't exist, use the Instance property.
 
 ```
-	var instance = SingletonExample.Instance;
+var instance = SingletonExample.Instance;
 ```
 
 If you want to try to grab an instance of the object, but not create one, use ExistingInstance instead. (A good reason to use this is to prevent accidentally creating a new instance during application shutdown.) Make sure to check for a null return.
 
 ```
-	var instance = SingletonExample.ExistingInstance;
-	if(instance != null)
-	{
-		// do something with it
-	}
+var instance = SingletonExample.ExistingInstance;
+if(instance != null)
+{
+	// do something with it
+}
 ```
 
 For a more concrete example usage, see [PrefabPool](../PrefabPool/README.md).