Squid, dildos and bezier curves

Assets/BezierCurves/Editor.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: a7df1a42a1caa924e94005298a889190
+folderAsset: yes
+timeCreated: 1463688993
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/BezierCurves/Editor/BezierCurveEditor.cs

@@ -0,0 +1,263 @@
+using UnityEngine;
+using UnityEditor;
+using System.Collections;
+
+[CustomEditor(typeof(BezierCurve))]
+public class BezierCurveEditor : Editor 
+{	
+	BezierCurve curve;
+	SerializedProperty resolutionProp;
+	SerializedProperty closeProp;
+	SerializedProperty pointsProp;
+	SerializedProperty colorProp;
+	
+	private static bool showPoints = true;
+	
+	void OnEnable()
+	{
+		curve = (BezierCurve)target;
+		
+		resolutionProp = serializedObject.FindProperty("resolution");
+		closeProp = serializedObject.FindProperty("_close");
+		pointsProp = serializedObject.FindProperty("points");
+		colorProp = serializedObject.FindProperty("drawColor");
+	}
+	
+	public override void OnInspectorGUI()
+	{
+		serializedObject.Update();
+		
+		EditorGUILayout.PropertyField(resolutionProp);
+		EditorGUILayout.PropertyField(closeProp);
+		EditorGUILayout.PropertyField(colorProp);
+		
+		showPoints = EditorGUILayout.Foldout(showPoints, "Points");
+		
+		if(showPoints)
+		{
+			int pointCount = pointsProp.arraySize;
+			
+			for(int i = 0; i < pointCount; i++)
+			{
+				DrawPointInspector(curve[i], i);
+			}
+			
+			if(GUILayout.Button("Add Point"))
+			{
+				Undo.RegisterSceneUndo("Add Point");
+				
+				GameObject pointObject = new GameObject("Point "+pointsProp.arraySize);
+				pointObject.transform.parent = curve.transform;
+				pointObject.transform.localPosition = Vector3.zero;
+				BezierPoint newPoint = pointObject.AddComponent<BezierPoint>();
+				
+				newPoint.curve = curve;
+				newPoint.handle1 = Vector3.right*0.1f;
+				newPoint.handle2 = -Vector3.right*0.1f;
+				
+				pointsProp.InsertArrayElementAtIndex(pointsProp.arraySize);
+				pointsProp.GetArrayElementAtIndex(pointsProp.arraySize - 1).objectReferenceValue = newPoint;
+			}
+		}
+		
+		if(GUI.changed)
+		{
+			serializedObject.ApplyModifiedProperties();
+			EditorUtility.SetDirty(target);
+		}
+	}
+	
+	void OnSceneGUI()
+	{
+		for(int i = 0; i < curve.pointCount; i++)
+		{
+			DrawPointSceneGUI(curve[i]);
+		}
+	}
+	
+	void DrawPointInspector(BezierPoint point, int index)
+	{
+		SerializedObject serObj = new SerializedObject(point);
+		
+		SerializedProperty handleStyleProp = serObj.FindProperty("handleStyle");
+		SerializedProperty handle1Prop = serObj.FindProperty("_handle1");
+		SerializedProperty handle2Prop = serObj.FindProperty("_handle2");
+		
+		EditorGUILayout.BeginHorizontal();
+		
+		if(GUILayout.Button("X", GUILayout.Width(20)))
+		{
+			Undo.RegisterSceneUndo("Remove Point");
+			pointsProp.MoveArrayElement(curve.GetPointIndex(point), curve.pointCount - 1);
+			pointsProp.arraySize--;
+			DestroyImmediate(point.gameObject);
+			return;
+		}
+
+		EditorGUILayout.ObjectField(point.gameObject, typeof(GameObject), true);
+		
+		if(index != 0 && GUILayout.Button(@"/\", GUILayout.Width(25)))
+		{
+			UnityEngine.Object other = pointsProp.GetArrayElementAtIndex(index - 1).objectReferenceValue;
+			pointsProp.GetArrayElementAtIndex(index - 1).objectReferenceValue = point;
+			pointsProp.GetArrayElementAtIndex(index).objectReferenceValue = other;
+		}
+		
+		if(index != pointsProp.arraySize - 1 && GUILayout.Button(@"\/", GUILayout.Width(25)))
+		{
+			UnityEngine.Object other = pointsProp.GetArrayElementAtIndex(index + 1).objectReferenceValue;
+			pointsProp.GetArrayElementAtIndex(index + 1).objectReferenceValue = point;
+			pointsProp.GetArrayElementAtIndex(index).objectReferenceValue = other;
+		}
+		
+		EditorGUILayout.EndHorizontal();
+		
+		EditorGUI.indentLevel++;
+		EditorGUI.indentLevel++;
+		
+		int newType = (int)((object)EditorGUILayout.EnumPopup("Handle Type", (BezierPoint.HandleStyle)handleStyleProp.enumValueIndex));
+		
+		if(newType != handleStyleProp.enumValueIndex)
+		{
+			handleStyleProp.enumValueIndex = newType;
+			if(newType == 0)
+			{
+				if(handle1Prop.vector3Value != Vector3.zero) handle2Prop.vector3Value = -handle1Prop.vector3Value;
+				else if(handle2Prop.vector3Value != Vector3.zero) handle1Prop.vector3Value = -handle2Prop.vector3Value;
+				else
+				{
+					handle1Prop.vector3Value = new Vector3(0.1f, 0, 0);	
+					handle2Prop.vector3Value = new Vector3(-0.1f, 0, 0);	
+				}
+			}
+			
+			else if(newType == 1)
+			{
+				if(handle1Prop.vector3Value == Vector3.zero && handle2Prop.vector3Value == Vector3.zero)
+				{
+					handle1Prop.vector3Value = new Vector3(0.1f, 0, 0);	
+					handle2Prop.vector3Value = new Vector3(-0.1f, 0, 0);
+				}
+			}
+			
+			else if(newType == 2)
+			{
+				handle1Prop.vector3Value = Vector3.zero;	
+				handle2Prop.vector3Value = Vector3.zero;	
+			}
+		}
+		
+		Vector3 newPointPos = EditorGUILayout.Vector3Field("Position : ", point.transform.localPosition);
+		if(newPointPos != point.transform.localPosition)
+		{
+			Undo.RegisterUndo(point.transform, "Move Bezier Point");
+			point.transform.localPosition = newPointPos;
+		}
+		
+		if(handleStyleProp.enumValueIndex == 0)
+		{			
+			Vector3 newPosition;
+			
+			newPosition = EditorGUILayout.Vector3Field("Handle 1", handle1Prop.vector3Value);
+			if(newPosition != handle1Prop.vector3Value)
+			{
+				handle1Prop.vector3Value = newPosition;
+				handle2Prop.vector3Value = -newPosition;
+			}
+			
+			newPosition = EditorGUILayout.Vector3Field("Handle 2", handle2Prop.vector3Value);
+			if(newPosition != handle2Prop.vector3Value)
+			{
+				handle1Prop.vector3Value = -newPosition;
+				handle2Prop.vector3Value = newPosition;				
+			}
+		}
+		
+		else if(handleStyleProp.enumValueIndex == 1)
+		{
+			EditorGUILayout.PropertyField(handle1Prop);
+			EditorGUILayout.PropertyField(handle2Prop);			
+		}
+		
+		EditorGUI.indentLevel--;
+		EditorGUI.indentLevel--;	
+		
+		if(GUI.changed)
+		{
+			serObj.ApplyModifiedProperties();
+			EditorUtility.SetDirty(serObj.targetObject);
+		}
+	}
+	
+	static void DrawPointSceneGUI(BezierPoint point)
+	{	
+		Handles.Label(point.position + new Vector3(0, HandleUtility.GetHandleSize(point.position) * 0.4f, 0), point.gameObject.name);
+		
+		Handles.color = Color.green;
+		Vector3 newPosition = Handles.FreeMoveHandle(point.position, point.transform.rotation, HandleUtility.GetHandleSize(point.position)*0.1f, Vector3.zero, Handles.RectangleCap);
+		
+		if(newPosition != point.position)
+		{
+			Undo.RegisterUndo(point.transform, "Move Point");
+			point.transform.position = newPosition;
+		}
+		
+		if(point.handleStyle != BezierPoint.HandleStyle.None)
+		{
+			Handles.color = Color.cyan;
+			Vector3 newGlobal1 = Handles.FreeMoveHandle(point.globalHandle1, point.transform.rotation, HandleUtility.GetHandleSize(point.globalHandle1)*0.075f, Vector3.zero, Handles.CircleCap);
+			if(point.globalHandle1 != newGlobal1)
+			{
+				Undo.RegisterUndo(point, "Move Handle");
+				point.globalHandle1 = newGlobal1;
+				if(point.handleStyle == BezierPoint.HandleStyle.Connected) point.globalHandle2 = -(newGlobal1 - point.position) + point.position;
+			}
+			
+			Vector3 newGlobal2 = Handles.FreeMoveHandle(point.globalHandle2, point.transform.rotation, HandleUtility.GetHandleSize(point.globalHandle2)*0.075f, Vector3.zero, Handles.CircleCap);
+			if(point.globalHandle2 != newGlobal2)
+			{
+				Undo.RegisterUndo(point, "Move Handle");
+				point.globalHandle2 = newGlobal2;
+				if(point.handleStyle == BezierPoint.HandleStyle.Connected) point.globalHandle1 = -(newGlobal2 - point.position) + point.position;
+			}
+			
+			Handles.color = Color.yellow;
+			Handles.DrawLine(point.position, point.globalHandle1);
+			Handles.DrawLine(point.position, point.globalHandle2);
+		}
+	}
+	
+	public static void DrawOtherPoints(BezierCurve curve, BezierPoint caller)
+	{
+		foreach(BezierPoint p in curve.GetAnchorPoints())
+		{
+			if(p != caller) DrawPointSceneGUI(p);
+		}
+	}
+	
+	[MenuItem("GameObject/Create Other/Bezier Curve")]
+	public static void CreateCurve(MenuCommand command)
+	{
+		GameObject curveObject = new GameObject("BezierCurve");
+		Undo.RegisterUndo(curveObject, "Undo Create Curve");
+		BezierCurve curve = curveObject.AddComponent<BezierCurve>();
+		
+		BezierPoint p1 = curve.AddPointAt(Vector3.forward * 0.5f);
+		p1.handleStyle = BezierPoint.HandleStyle.Connected;
+		p1.handle1 = new Vector3(-0.28f, 0, 0);
+		
+		BezierPoint p2 = curve.AddPointAt(Vector3.right * 0.5f);
+		p2.handleStyle = BezierPoint.HandleStyle.Connected;
+		p2.handle1 = new Vector3(0, 0, 0.28f);
+		
+		BezierPoint p3 = curve.AddPointAt(-Vector3.forward * 0.5f);
+		p3.handleStyle = BezierPoint.HandleStyle.Connected;
+		p3.handle1 = new Vector3(0.28f, 0, 0);		
+		
+		BezierPoint p4 = curve.AddPointAt(-Vector3.right * 0.5f);
+		p4.handleStyle = BezierPoint.HandleStyle.Connected;
+		p4.handle1 = new Vector3(0, 0, -0.28f);
+		
+		curve.close = true;
+	}
+}

Assets/BezierCurves/Editor/BezierCurveEditor.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 076c82ebe1ea6b249b4e66e85cdf269a
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/BezierCurves/Editor/BezierPointEditor.cs

@@ -0,0 +1,152 @@
+using UnityEngine;
+using UnityEditor;
+using System.Collections;
+
+[CustomEditor(typeof(BezierPoint))]
+[CanEditMultipleObjects]
+public class BezierPointEditor : Editor {
+	
+	BezierPoint point;
+	
+	SerializedProperty handleTypeProp;
+	SerializedProperty handle1Prop;
+	SerializedProperty handle2Prop;
+	
+	private delegate void HandleFunction(BezierPoint p);
+	private HandleFunction[] handlers = new HandleFunction[] { HandleConnected, HandleBroken, HandleAbsent };
+	
+	void OnEnable(){
+		point = (BezierPoint)target;
+		
+		handleTypeProp = serializedObject.FindProperty("handleStyle");
+		handle1Prop = serializedObject.FindProperty("_handle1");
+		handle2Prop = serializedObject.FindProperty("_handle2");
+	}	
+	
+	public override void OnInspectorGUI (){
+		
+		serializedObject.Update();
+		
+		BezierPoint.HandleStyle newHandleType = (BezierPoint.HandleStyle)EditorGUILayout.EnumPopup("Handle Type", (BezierPoint.HandleStyle)handleTypeProp.intValue);
+		
+		if(newHandleType != (BezierPoint.HandleStyle)handleTypeProp.intValue)
+		{
+			handleTypeProp.intValue = (int)newHandleType;
+	
+			if((int)newHandleType == 0)
+			{
+				if(handle1Prop.vector3Value != Vector3.zero) handle2Prop.vector3Value = -handle1Prop.vector3Value;
+				else if(handle2Prop.vector3Value != Vector3.zero) handle1Prop.vector3Value = -handle2Prop.vector3Value;
+				else
+				{
+					handle1Prop.vector3Value = new Vector3(0.1f, 0, 0);	
+					handle2Prop.vector3Value = new Vector3(-0.1f, 0, 0);	
+				}
+			}
+			
+			else if((int)newHandleType == 1)
+			{
+				if(handle1Prop.vector3Value == Vector3.zero && handle2Prop.vector3Value == Vector3.zero)
+				{
+					handle1Prop.vector3Value = new Vector3(0.1f, 0, 0);	
+					handle2Prop.vector3Value = new Vector3(-0.1f, 0, 0);
+				}
+			}
+			
+			else if((int)newHandleType == 2)
+			{
+				handle1Prop.vector3Value = Vector3.zero;	
+				handle2Prop.vector3Value = Vector3.zero;	
+			}
+		}
+		
+		if(handleTypeProp.intValue != 2)
+		{
+			Vector3 newHandle1 = EditorGUILayout.Vector3Field("Handle 1", handle1Prop.vector3Value);
+			Vector3 newHandle2 = EditorGUILayout.Vector3Field("Handle 2", handle2Prop.vector3Value);
+			
+			if(handleTypeProp.intValue == 0){
+				if(newHandle1 != handle1Prop.vector3Value){
+					handle1Prop.vector3Value = newHandle1;
+					handle2Prop.vector3Value = -newHandle1;
+				}
+				
+				else if(newHandle2 != handle2Prop.vector3Value){
+					handle1Prop.vector3Value = -newHandle2;
+					handle2Prop.vector3Value = newHandle2;			
+				}
+			}
+			
+			else{
+				handle1Prop.vector3Value = newHandle1;
+				handle2Prop.vector3Value = newHandle2;
+			}
+		}
+		
+		if(GUI.changed){
+			serializedObject.ApplyModifiedProperties();
+			EditorUtility.SetDirty(target);
+		}
+	}
+	
+	void OnSceneGUI()
+	{
+		
+		Handles.color = Color.green;
+		Vector3 newPosition = Handles.FreeMoveHandle(point.position, point.transform.rotation, HandleUtility.GetHandleSize(point.position)*0.2f, Vector3.zero, Handles.CubeCap);
+		if(point.position != newPosition) point.position = newPosition;
+		
+		handlers[(int)point.handleStyle](point);
+		
+		Handles.color = Color.yellow;
+		Handles.DrawLine(point.position, point.globalHandle1);
+		Handles.DrawLine(point.position, point.globalHandle2);
+		
+		BezierCurveEditor.DrawOtherPoints(point.curve, point);
+	}
+	
+	private static void HandleConnected(BezierPoint p){
+		Handles.color = Color.cyan;
+		
+		Vector3 newGlobal1 = Handles.FreeMoveHandle(p.globalHandle1, p.transform.rotation, HandleUtility.GetHandleSize(p.globalHandle1)*0.15f, Vector3.zero, Handles.SphereCap);
+		
+		if(newGlobal1 != p.globalHandle1){
+			Undo.RegisterUndo(p, "Move Handle");
+			p.globalHandle1 = newGlobal1;
+			p.globalHandle2 = -(newGlobal1 - p.position) + p.position;
+		}
+		
+		Vector3 newGlobal2 = Handles.FreeMoveHandle(p.globalHandle2, p.transform.rotation, HandleUtility.GetHandleSize(p.globalHandle2)*0.15f, Vector3.zero, Handles.SphereCap);
+		
+		if(newGlobal2 != p.globalHandle2){
+			Undo.RegisterUndo(p, "Move Handle");
+			p.globalHandle1 = -(newGlobal2 - p.position) + p.position;
+			p.globalHandle2 = newGlobal2;
+		}
+	}
+	
+	private static void HandleBroken(BezierPoint p){
+		Handles.color = Color.cyan;
+
+		Vector3 newGlobal1 = Handles.FreeMoveHandle(p.globalHandle1, Quaternion.identity, HandleUtility.GetHandleSize(p.globalHandle1)*0.15f, Vector3.zero, Handles.SphereCap);
+		Vector3 newGlobal2 = Handles.FreeMoveHandle(p.globalHandle2, Quaternion.identity, HandleUtility.GetHandleSize(p.globalHandle2)*0.15f, Vector3.zero, Handles.SphereCap);
+		
+		if(newGlobal1 != p.globalHandle1)
+		{
+			Undo.RegisterUndo(p, "Move Handle");
+			p.globalHandle1 = newGlobal1;
+		}
+		
+		if(newGlobal2 != p.globalHandle2)
+		{
+			Undo.RegisterUndo(p, "Move Handle");
+			p.globalHandle2 = newGlobal2;
+		}
+	}
+	
+	private static void HandleAbsent(BezierPoint p)
+	{
+		p.handle1 = Vector3.zero;
+		p.handle2 = Vector3.zero;
+	}
+}

Assets/BezierCurves/Editor/BezierPointEditor.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 2f40a14ecad007949831de4081a5a58e
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/BezierCurves/Example.unity.meta

@@ -0,0 +1,6 @@
+fileFormatVersion: 2
+guid: 3b3fe768c68c21647b45cad53f1d7c06
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/BezierCurves/Scripts.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 7d7e57956b99d2b4e81efd36ef46eea1
+folderAsset: yes
+timeCreated: 1463688993
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/BezierCurves/Scripts/BezierCurve.cs

@@ -0,0 +1,555 @@
+#region UsingStatements
+
+using UnityEngine;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+#endregion
+
+/// <summary>
+/// 	- Class for describing and drawing Bezier Curves
+/// 	- Efficiently handles approximate length calculation through 'dirty' system
+/// 	- Has static functions for getting points on curves constructed by Vector3 parameters (GetPoint, GetCubicPoint, GetQuadraticPoint, and GetLinearPoint)
+/// </summary>
+[ExecuteInEditMode]
+[Serializable]
+public class BezierCurve : MonoBehaviour {
+	
+	#region PublicVariables
+	
+	/// <summary>
+	///  	- the number of mid-points calculated for each pair of bezier points
+	///  	- used for drawing the curve in the editor
+	///  	- used for calculating the "length" variable
+	/// </summary>
+	public int resolution = 30;
+	
+	/// <summary>
+	/// Gets or sets a value indicating whether this <see cref="BezierCurve"/> is dirty.
+	/// </summary>
+	/// <value>
+	/// <c>true</c> if dirty; otherwise, <c>false</c>.
+	/// </value>
+	public bool dirty { get; private set; }
+	
+	/// <summary>
+	/// 	- color this curve will be drawn with in the editor
+	///		- set in the editor
+	/// </summary>
+	public Color drawColor = Color.white;
+	
+	#endregion
+	
+	#region PublicProperties
+	
+	/// <summary>
+	///		- set in the editor
+	/// 	- used to determine if the curve should be drawn as "closed" in the editor
+	/// 	- used to determine if the curve's length should include the curve between the first and the last points in "points" array
+	/// 	- setting this value will cause the curve to become dirty
+	/// </summary>
+	[SerializeField] private bool _close;
+	public bool close
+	{
+		get { return _close; }
+		set
+		{
+			if(_close == value) return;
+			_close = value;
+			dirty = true;
+		}
+	}
+	
+	/// <summary>
+	///		- set internally
+	///		- gets point corresponding to "index" in "points" array
+	///		- does not allow direct set
+	/// </summary>
+	/// <param name='index'>
+	/// 	- the index
+	/// </param>
+	public BezierPoint this[int index]
+	{
+		get { return points[index]; }
+	}
+	
+	/// <summary>
+	/// 	- number of points stored in 'points' variable
+	///		- set internally
+	///		- does not include "handles"
+	/// </summary>
+	/// <value>
+	/// 	- The point count
+	/// </value>
+	public int pointCount
+	{
+		get { return points.Length; }
+	}
+	
+	/// <summary>
+	/// 	- The approximate length of the curve
+	/// 	- recalculates if the curve is "dirty"
+	/// </summary>
+	private float _length;
+	public float length
+	{
+		get
+		{
+			if(dirty)
+			{
+				_length = 0;
+				for(int i = 0; i < points.Length - 1; i++){
+					_length += ApproximateLength(points[i], points[i + 1], resolution);
+				}
+				
+				//if(close) _length += ApproximateLength(points[points.Length - 1], points[0], resolution);
+				
+				dirty = false;
+			}
+			
+			return _length;
+		}
+	}
+	
+	#endregion
+	
+	#region PrivateVariables
+	
+	/// <summary> 
+	/// 	- Array of point objects that make up this curve
+	///		- Populated through editor
+	/// </summary>
+	[SerializeField] private BezierPoint[] points = new BezierPoint[0];
+	
+	#endregion
+	
+	#region UnityFunctions
+	
+	void OnDrawGizmos () {
+		Gizmos.color = drawColor;
+		
+		if(points.Length > 1){
+			for(int i = 0; i < points.Length - 1; i++){
+				DrawCurve(points[i], points[i+1], resolution);
+			}
+			
+			if (close) DrawCurve(points[points.Length - 1], points[0], resolution);
+		}
+	}
+	
+	void Awake(){
+		dirty = true;
+	}
+
+	#endregion
+	
+	#region PublicFunctions
+
+	/// <summary>
+	/// 	- Adds the given point to the end of the curve ("points" array)
+	/// </summary>
+	/// <param name='point'>
+	/// 	- The point to add.
+	/// </param>
+	public void AddPoint(BezierPoint point)
+	{
+		List<BezierPoint> tempArray = new List<BezierPoint>(points);
+		tempArray.Add(point);
+		points = tempArray.ToArray();
+		dirty = true;
+	}
+	
+	/// <summary>
+	/// 	- Adds a point at position
+	/// </summary>
+	/// <returns>
+	/// 	- The point object
+	/// </returns>
+	/// <param name='position'>
+	/// 	- Where to add the point
+	/// </param>
+	public BezierPoint AddPointAt(Vector3 position)
+	{
+		GameObject pointObject = new GameObject("Point "+pointCount);
+
+		pointObject.transform.parent = transform;
+		pointObject.transform.position = position;
+		
+		BezierPoint newPoint = pointObject.AddComponent<BezierPoint>();
+		newPoint.curve = this;
+		
+		return newPoint;
+	}
+	
+	/// <summary>
+	/// 	- Removes the given point from the curve ("points" array)
+	/// </summary>
+	/// <param name='point'>
+	/// 	- The point to remove
+	/// </param>
+	public void RemovePoint(BezierPoint point)
+	{
+		List<BezierPoint> tempArray = new List<BezierPoint>(points);
+		tempArray.Remove(point);
+		points = tempArray.ToArray();
+		dirty = false;
+	}
+	
+	/// <summary>
+	/// 	- Gets a copy of the bezier point array used to define this curve
+	/// </summary>
+	/// <returns>
+	/// 	- The cloned array of points
+	/// </returns>
+	public BezierPoint[] GetAnchorPoints()
+	{
+		return (BezierPoint[])points.Clone();
+	}
+	
+	/// <summary>
+	/// 	- Gets the point at 't' percent along this curve
+	/// </summary>
+	/// <returns>
+	/// 	- Returns the point at 't' percent
+	/// </returns>
+	/// <param name='t'>
+	/// 	- Value between 0 and 1 representing the percent along the curve (0 = 0%, 1 = 100%)
+	/// </param>
+	public Vector3 GetPointAt(float t)
+	{
+		if(t <= 0) return points[0].position;
+		else if (t >= 1) return points[points.Length - 1].position;
+		
+		float totalPercent = 0;
+		float curvePercent = 0;
+		
+		BezierPoint p1 = null;
+		BezierPoint p2 = null;
+		
+		for(int i = 0; i < points.Length - 1; i++)
+		{
+			curvePercent = ApproximateLength(points[i], points[i + 1], 10) / length;
+			if(totalPercent + curvePercent > t)
+			{
+				p1 = points[i];
+				p2 = points[i + 1];
+				break;
+			}
+			
+			else totalPercent += curvePercent;
+		}
+		
+		if(close && p1 == null)
+		{
+			p1 = points[points.Length - 1];
+			p2 = points[0];
+		}
+		
+		t -= totalPercent;
+		
+		return GetPoint(p1, p2, t / curvePercent);
+	}
+	
+	/// <summary>
+	/// 	- Get the index of the given point in this curve
+	/// </summary>
+	/// <returns>
+	/// 	- The index, or -1 if the point is not found
+	/// </returns>
+	/// <param name='point'>
+	/// 	- Point to search for
+	/// </param>
+	public int GetPointIndex(BezierPoint point)
+	{
+		int result = -1;
+		for(int i = 0; i < points.Length; i++)
+		{
+			if(points[i] == point)
+			{
+				result = i;
+				break;
+			}
+		}
+		
+		return result;
+	}
+	
+	/// <summary>
+	/// 	- Sets this curve to 'dirty'
+	/// 	- Forces the curve to recalculate its length
+	/// </summary>
+	public void SetDirty()
+	{
+		dirty = true;
+	}
+	
+	#endregion
+	
+	#region PublicStaticFunctions
+	
+	/// <summary>
+	/// 	- Draws the curve in the Editor
+	/// </summary>
+	/// <param name='p1'>
+	/// 	- The bezier point at the beginning of the curve
+	/// </param>
+	/// <param name='p2'>
+	/// 	- The bezier point at the end of the curve
+	/// </param>
+	/// <param name='resolution'>
+	/// 	- The number of segments along the curve to draw
+	/// </param>
+	public static void DrawCurve(BezierPoint p1, BezierPoint p2, int resolution)
+	{
+		int limit = resolution+1;
+		float _res = resolution;
+		Vector3 lastPoint = p1.position;
+		Vector3 currentPoint = Vector3.zero;
+		
+		for(int i = 1; i < limit; i++){
+			currentPoint = GetPoint(p1, p2, i/_res);
+			Gizmos.DrawLine(lastPoint, currentPoint);
+			lastPoint = currentPoint;
+		}		
+	}	
+
+	/// <summary>
+	/// 	- Gets the point 't' percent along a curve
+	/// 	- Automatically calculates for the number of relevant points
+	/// </summary>
+	/// <returns>
+	/// 	- The point 't' percent along the curve
+	/// </returns>
+	/// <param name='p1'>
+	/// 	- The bezier point at the beginning of the curve
+	/// </param>
+	/// <param name='p2'>
+	/// 	- The bezier point at the end of the curve
+	/// </param>
+	/// <param name='t'>
+	/// 	- Value between 0 and 1 representing the percent along the curve (0 = 0%, 1 = 100%)
+	/// </param>
+	public static Vector3 GetPoint(BezierPoint p1, BezierPoint p2, float t)
+	{
+		if(p1.handle2 != Vector3.zero)
+		{
+			if(p2.handle1 != Vector3.zero) return GetCubicCurvePoint(p1.position, p1.globalHandle2, p2.globalHandle1, p2.position, t);
+			else return GetQuadraticCurvePoint(p1.position, p1.globalHandle2, p2.position, t);
+		}
+		
+		else
+		{
+			if(p2.handle1 != Vector3.zero) return GetQuadraticCurvePoint(p1.position, p2.globalHandle1, p2.position, t);
+			else return GetLinearPoint(p1.position, p2.position, t);
+		}	
+	}
+
+	/// <summary>
+	/// 	- Gets the point 't' percent along a third-order curve
+	/// </summary>
+	/// <returns>
+	/// 	- The point 't' percent along the curve
+	/// </returns>
+	/// <param name='p1'>
+	/// 	- The point at the beginning of the curve
+	/// </param>
+	/// <param name='p2'>
+	/// 	- The second point along the curve
+	/// </param>
+	/// <param name='p3'>
+	/// 	- The third point along the curve
+	/// </param>
+	/// <param name='p4'>
+	/// 	- The point at the end of the curve
+	/// </param>
+	/// <param name='t'>
+	/// 	- Value between 0 and 1 representing the percent along the curve (0 = 0%, 1 = 100%)
+	/// </param>
+    public static Vector3 GetCubicCurvePoint(Vector3 p1, Vector3 p2, Vector3 p3, Vector3 p4, float t)
+    {
+        t = Mathf.Clamp01(t);
+
+        Vector3 part1 = Mathf.Pow(1 - t, 3) * p1;
+        Vector3 part2 = 3 * Mathf.Pow(1 - t, 2) * t * p2;
+        Vector3 part3 = 3 * (1 - t) * Mathf.Pow(t, 2) * p3;
+        Vector3 part4 = Mathf.Pow(t, 3) * p4;
+
+        return part1 + part2 + part3 + part4;
+    }
+	
+	/// <summary>
+	/// 	- Gets the point 't' percent along a second-order curve
+	/// </summary>
+	/// <returns>
+	/// 	- The point 't' percent along the curve
+	/// </returns>
+	/// <param name='p1'>
+	/// 	- The point at the beginning of the curve
+	/// </param>
+	/// <param name='p2'>
+	/// 	- The second point along the curve
+	/// </param>
+	/// <param name='p3'>
+	/// 	- The point at the end of the curve
+	/// </param>
+	/// <param name='t'>
+	/// 	- Value between 0 and 1 representing the percent along the curve (0 = 0%, 1 = 100%)
+	/// </param>
+    public static Vector3 GetQuadraticCurvePoint(Vector3 p1, Vector3 p2, Vector3 p3, float t)
+    {
+        t = Mathf.Clamp01(t);
+
+        Vector3 part1 = Mathf.Pow(1 - t, 2) * p1;
+        Vector3 part2 = 2 * (1 - t) * t * p2;
+        Vector3 part3 = Mathf.Pow(t, 2) * p3;
+
+        return part1 + part2 + part3;
+    }
+	
+	/// <summary>
+	/// 	- Gets point 't' percent along a linear "curve" (line)
+	/// 	- This is exactly equivalent to Vector3.Lerp
+	/// </summary>
+	/// <returns>
+	///		- The point 't' percent along the curve
+	/// </returns>
+	/// <param name='p1'>
+	/// 	- The point at the beginning of the line
+	/// </param>
+	/// <param name='p2'>
+	/// 	- The point at the end of the line
+	/// </param>
+	/// <param name='t'>
+	/// 	- Value between 0 and 1 representing the percent along the line (0 = 0%, 1 = 100%)
+	/// </param>
+    public static Vector3 GetLinearPoint(Vector3 p1, Vector3 p2, float t)
+    {
+        return p1 + ((p2 - p1) * t);
+    }
+	
+	/// <summary>
+	/// 	- Gets point 't' percent along n-order curve
+	/// </summary>
+	/// <returns>
+	/// 	- The point 't' percent along the curve
+	/// </returns>
+	/// <param name='t'>
+	/// 	- Value between 0 and 1 representing the percent along the curve (0 = 0%, 1 = 100%)
+	/// </param>
+	/// <param name='points'>
+	/// 	- The points used to define the curve
+	/// </param>
+	public static Vector3 GetPoint(float t, params Vector3[] points){
+		t = Mathf.Clamp01(t);
+		
+		int order = points.Length-1;
+		Vector3 point = Vector3.zero;
+		Vector3 vectorToAdd;
+		
+		for(int i = 0; i < points.Length; i++){
+			vectorToAdd = points[points.Length-i-1] * (BinomialCoefficient(i, order) * Mathf.Pow(t, order-i) * Mathf.Pow((1-t), i));
+			point += vectorToAdd;
+		}
+		
+		return point;
+	}
+	
+	/// <summary>
+	/// 	- Approximates the length
+	/// </summary>
+	/// <returns>
+	/// 	- The approximate length
+	/// </returns>
+	/// <param name='p1'>
+	/// 	- The bezier point at the start of the curve
+	/// </param>
+	/// <param name='p2'>
+	/// 	- The bezier point at the end of the curve
+	/// </param>
+	/// <param name='resolution'>
+	/// 	- The number of points along the curve used to create measurable segments
+	/// </param>
+	public static float ApproximateLength(BezierPoint p1, BezierPoint p2, int resolution = 10)
+	{
+		float _res = resolution;
+		float total = 0;
+		Vector3 lastPosition = p1.position;
+		Vector3 currentPosition;
+		
+		for(int i = 0; i < resolution + 1; i++)
+		{
+			currentPosition = GetPoint(p1, p2, i / _res);
+			total += (currentPosition - lastPosition).magnitude;
+			lastPosition = currentPosition;
+		}
+		
+		return total;
+	}
+	
+	#endregion
+	
+	#region UtilityFunctions
+	
+	private static int BinomialCoefficient(int i, int n){
+		return 	Factoral(n)/(Factoral(i)*Factoral(n-i));
+	}
+	
+	private static int Factoral(int i){
+		if(i == 0) return 1;
+		
+		int total = 1;
+		
+		while(i-1 >= 0){
+			total *= i;
+			i--;
+		}
+		
+		return total;
+	}
+	
+	#endregion
+	
+	public Vector3 GetPointAtDistance(float distance)
+	{
+		if(close)
+		{
+			if(distance < 0) while(distance < 0) { distance += length; }
+			else if(distance > length) while(distance > length) { distance -= length; }
+		}
+		
+		else
+		{
+			if(distance <= 0) return points[0].position;
+			else if(distance >= length) return points[points.Length - 1].position;
+		}
+		
+		float totalLength = 0;
+		float curveLength = 0;
+		
+		BezierPoint firstPoint = null;
+		BezierPoint secondPoint = null;
+		
+		for(int i = 0; i < points.Length - 1; i++)
+		{
+			curveLength = ApproximateLength(points[i], points[i + 1], resolution);
+			if(totalLength + curveLength >= distance)
+			{
+				firstPoint = points[i];
+				secondPoint = points[i+1];
+				break;
+			}
+			else totalLength += curveLength;
+		}
+		
+		if(firstPoint == null)
+		{
+			firstPoint = points[points.Length - 1];
+			secondPoint = points[0];
+			curveLength = ApproximateLength(firstPoint, secondPoint, resolution);
+		}
+		
+		distance -= totalLength;
+		return GetPoint(firstPoint, secondPoint, distance / curveLength);
+	}
+}

Assets/BezierCurves/Scripts/BezierCurve.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 4234cd2c43978e041bbe9323c195c4bd
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/BezierCurves/Scripts/BezierPoint.cs

@@ -0,0 +1,170 @@
+#region UsingStatements
+
+using UnityEngine;
+using System;
+using System.Collections;
+
+#endregion
+
+/// <summary>
+/// 	- Helper class for storing and manipulating Bezier Point data
+/// 	- Ensures that handles are in correct relation to one another
+/// 	- Handles adding/removing self from curve point lists
+/// 	- Calls SetDirty() on curve when edited 
+/// </summary>
+[Serializable]
+public class BezierPoint : MonoBehaviour{
+	
+	#region PublicEnumerations
+	
+	/// <summary>
+	/// 	- Enumeration describing the relationship between a point's handles
+	/// 	- Connected : The point's handles are mirrored across the point
+	/// 	- Broken : Each handle moves independently of the other
+	/// 	- None : This point has no handles (both handles are located ON the point)
+	/// </summary>
+	public enum HandleStyle
+	{
+		Connected,
+		Broken,
+		None,
+	}
+	
+	#endregion
+	
+	#region PublicProperties
+	
+	/// <summary>
+	///		- Curve this point belongs to
+	/// 	- Changing this value will automatically remove this point from the current curve and add it to the new one
+	/// </summary>
+	[SerializeField]
+	private BezierCurve _curve;
+	public BezierCurve curve
+	{
+		get{return _curve;}
+		set
+		{
+			if(_curve) _curve.RemovePoint(this);
+			_curve = value;
+			_curve.AddPoint(this);
+		}
+	}
+
+	/// <summary>
+	/// 	- Value describing the relationship between this point's handles
+	/// </summary>
+	public HandleStyle handleStyle;
+	
+	/// <summary>
+	/// 	- Shortcut to transform.position
+	/// </summary>
+	/// <value>
+	/// 	- The point's world position
+	/// </value>
+	public Vector3 position
+	{
+		get { return transform.position; }
+		set { transform.position = value; }
+	}
+	
+	/// <summary>
+	/// 	- Shortcut to transform.localPosition
+	/// </summary>
+	/// <value>
+	/// 	- The point's local position.
+	/// </value>
+	public Vector3 localPosition
+	{
+		get { return transform.localPosition; }
+		set { transform.localPosition = value; }
+	}
+	
+	/// <summary>
+	/// 	- Local position of the first handle
+	/// 	- Setting this value will cause the curve to become dirty
+	/// 	- This handle effects the curve generated from this point and the point proceeding it in curve.points
+	/// </summary>
+	[SerializeField] 
+	private Vector3 _handle1;
+	public Vector3 handle1
+	{
+		get { return _handle1; }
+		set 
+		{ 
+			if(_handle1 == value) return;
+			_handle1 = value;
+			if(handleStyle == HandleStyle.None) handleStyle = HandleStyle.Broken;
+			else if(handleStyle == HandleStyle.Connected) _handle2 = -value;
+			_curve.SetDirty();
+		}
+	}
+
+	/// <summary>
+	///		- Global position of the first handle
+	///		- Ultimately stored in the 'handle1' variable
+	/// 	- Setting this value will cause the curve to become dirty
+	/// 	- This handle effects the curve generated from this point and the point proceeding it in curve.points
+	/// </summary>
+	public Vector3 globalHandle1
+	{
+		get{return 	transform.TransformPoint(handle1);}
+		set{handle1 = transform.InverseTransformPoint(value);}
+	}
+	
+	/// <summary>
+	/// 	- Local position of the second handle
+	///  	- Setting this value will cause the curve to become dirty
+	///		- This handle effects the curve generated from this point and the point coming after it in curve.points
+	/// </summary>
+	[SerializeField] 
+	private Vector3 _handle2;
+	public Vector3 handle2
+	{
+		get { return _handle2; }
+		set 
+		{ 
+			if(_handle2 == value) return;
+			_handle2 = value;
+			if(handleStyle == HandleStyle.None) handleStyle = HandleStyle.Broken;
+			else if(handleStyle == HandleStyle.Connected) _handle1 = -value;
+			_curve.SetDirty();
+		}		
+	}
+	
+	/// <summary>
+	///		- Global position of the second handle
+	///		- Ultimately stored in the 'handle2' variable
+	///		- Setting this value will cause the curve to become dirty
+	///		- This handle effects the curve generated from this point and the point coming after it in curve.points 
+	/// </summary>
+	public Vector3 globalHandle2
+	{
+		get{return 	transform.TransformPoint(handle2);}
+		set{handle2 = transform.InverseTransformPoint(value);}
+	}
+	
+	#endregion
+	
+	#region PrivateVariables
+	
+	/// <summary>
+	/// 	- Used to determine if this point has moved since the last frame
+	/// </summary>
+	private Vector3 lastPosition;
+	
+	#endregion
+	
+	#region MonoBehaviourFunctions
+	
+	void Update()
+	{
+		if(!_curve.dirty && transform.position != lastPosition)
+		{
+			_curve.SetDirty();
+			lastPosition = transform.position;
+		}
+	}
+	
+	#endregion
+}

Assets/BezierCurves/Scripts/BezierPoint.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 1dff893e341592e438963ea8cbceb377
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/BezierCurves/readme.txt

@@ -0,0 +1,17 @@
+Product : Bezier Curve Editor Package
+Studio : Arkham Interactive
+Date : September 9th, 2013
+Version : 1.0
+Email : support@arkhaminteractive.com
+
+How to use:
+	1) Add BezierCurve package to your Unity project
+	2a) Add BezierCurve.cs script from Assets/BezierCurves/Scripts to any object
+	2b) Alternatively, select GameObject/Create Other/Bezier Curve
+	3) Use "Add Point" button to add bezier points to the curve
+	4) Use "X" button to remove bezier points from the curve
+	5) Use "/\" or "\/" to move points up or down in the curve order
+
+ - The BezierCurve class also contains static functions used for getting points on first, second, and third order bezier curves. 
+ - These functions take the positions of the anchor points as arguments.
+ - Instances of the BezierCurve object use these same functions to calculate positions.

Assets/BezierCurves/readme.txt.meta

@@ -0,0 +1,6 @@
+fileFormatVersion: 2
+guid: 1c019e87c4c680d4ba6e2fb138a2e1ee
+TextScriptImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: