Squid, dildos and bezier curves

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: