View difference between Paste ID: kNEN4Bz3 and DTuk18ni

 using UnityEngine;
 using System.Collections;
 using System.Collections.Generic;
 
 public class LineDraw : MonoBehaviour
 {
 	static LineDraw instance = null;
 	float widthStart = 0.1f;
 	float widthFinish = 0.1f;
 	ShaderOptionEnum shader = ShaderOptionEnum.SelfIlluminDiffuse;
 	Color color = Color.red;
 
 	string[] shaders = {"Self-Illumin/Diffuse", "Particles/Additive"};//, "VertexLit", "Diffuse"};
 	public enum ShaderOptionEnum {SelfIlluminDiffuse = 0, ParticlesAdditive};
 	//public class LineData{Vector3 a, b; float s, f; ShaderOptionEnum shader; Color c1, c2;}
 
 	public void SetWidth_(float widthStart, float widthFinish)
 	{
 		this.widthStart = widthStart;
 		this.widthFinish = widthFinish;
 	}
 	public float GetWidthStart_(){return widthStart;}
 	public float GetWidthFinish_(){return widthFinish;}
 
 	public void SetShaderOption_(ShaderOptionEnum shader)
 	{
 		this.shader = shader;
 	}
 
 	public void SetColor_(Color color){this.color = color;}
 	public Color GetColor_(){return this.color;}
 
 	public static void SetShaderOption(ShaderOptionEnum shader){instance.SetShaderOption_(shader);}
 	public static Color GetColor(){return instance.GetColor_();}
 	public static void SetColor(Color color){instance.SetColor_(color);}
 	public static void SetWidth(float widthStart, float widthFinish){instance.SetWidth_(widthStart, widthFinish);}
 	public static void SetWidth(float width){instance.SetWidth_(width, width);}
 	public static float GetWidthStart(){return instance.GetWidthStart_();}
 	public static float GetWidthFinish(){return instance.GetWidthFinish_();}
 
 	public static GameObject AddPersistent(Vector3 a, Vector3 b){return instance.AddLine_(a, b, true);}
 	public static GameObject AddPersistentCircle(Vector3 center, float radius, Vector3 normal){return instance.AddCircle_(center, radius, normal, 360, 0, 24, true);}
 	public static GameObject AddPersistentSpiralPlane(Vector3 center, int size, Vector3 normal){return instance.AddSpiralPlane_(center, size, normal, 24, true);}
 	public static GameObject AddPersistentQuaternion(Vector3 p, float radius, Quaternion q){return instance.AddQuaternion_(p, radius, q, 24, true);}
 	public static void AddTemporary(Vector3 a, Vector3 b){instance.AddLine_(a, b, false);}
 	public static void AddTemporaryCircle(Vector3 center, float radius, Vector3 normal){instance.AddCircle_(center, radius, normal, 360, 0, 24, false);}
 
 	List<GameObject> temp = new List<GameObject>();
 	List<GameObject> unusedTemp = new List<GameObject>();
 
 // MonoBehavior upkeep stuff, including test code -----------------------------
 
 	// TEST CODE
 //	float t = 0;
-//		LineDraw.AddTemporaryCircle(new Vector3(2,-2,-1), .6f, new Vector3(-1,1,1).normalized);
+
 	{
 		for(int i = 0; i < temp.Count; ++i)
 		{
 			temp[i].active = false;
 			unusedTemp.Add(temp[i]);
 		}
 		temp.Clear();
 		// TEST CODE
 //		t += Time.deltaTime;
 //		if(t >= 360) t-=360;
 //		Quaternion q = Quaternion.AngleAxis(t * 360, Vector3.forward);
 //		Vector3 v = q * new Vector3(1,0,0);
 //		LineDraw.AddTemporary(Vector3.zero, v);
 	}
 	void Start()
 	{
 		if(instance == null)
 			instance = this;
 		// TEST CODE
 //		GameObject g = LineDraw.AddPersistent(new Vector3(-1,-1,-2), new Vector3(5,1,-2));
 //		Destroy(g, 3);
 //		Vector3 v = new Vector3(1,1,1);
 //		v.Normalize();
 //		LineDraw.AddPersistentSpiralPlane(new Vector3(-2,2,-1), 2, v);
 //		Vector3 p = new Vector3(2,-2,-1), n = new Vector3(-1,1,1).normalized;
 //		for(int i = 0; i < 5; ++i)
 //		{
 //			AddCircle_(p, 1.0f+(0.4f*i), n, 360-(i*15), 0+(i*30), 24, true);
 //		}
 //		LineDraw.SetColor(Color.white);
 //		Quaternion q = transform.rotation;
 //		AddPersistentQuaternion(new Vector3(0, -5, 0), .5f, q);
 //		LineDraw.SetColor(Color.blue);
 	}
 
 // THE MEATY CODE -------------------------------------------------------------
 	GameObject GetLineGameObject()
 	{
 		GameObject go;
 		LineRenderer lineRenderer;
 		if(unusedTemp.Count > 0)
 		{
 			int lastIndex = unusedTemp.Count-1;
 			go = unusedTemp[lastIndex];
 			unusedTemp.RemoveAt(lastIndex);
 			go.active = true;
 			lineRenderer = go.GetComponent<LineRenderer>();
 		}else{
 			go = new GameObject("line");
 			lineRenderer = go.AddComponent<LineRenderer>();
 		}
 		string shaderName = shaders[(int)shader];
 		if(lineRenderer.material.shader.name != shaderName)
 		{
 			UnityEngine.Shader shaderObject = Shader.Find(shaderName);
 			lineRenderer.material = new Material(shaderObject);
 		}
 		lineRenderer.material.color = color;
-	float tempRotation = 0;
+
-	public GameObject AddCircle_(Vector3 p, float r, Vector3 normal, bool persistent)
+
 		lineRenderer.SetColors(color, color);
-		float startRotation = 0;//tempRotation * 360;
+
-		int numPoints = 24;
+
 		return go;
 	}
-		lineRenderer.SetVertexCount(numPoints+1);
+
-		tempRotation += Time.deltaTime;
+
-		if(tempRotation > 1) tempRotation -= 1;
+
-		Quaternion q1 = Quaternion.LookRotation(normal);
+
 		LineRenderer lineRenderer = lineg.GetComponent<LineRenderer>();
 		lineRenderer.SetVertexCount(numPoints);
 		lineRenderer.SetPosition(0, a);
-//			SetColor_(Color.red);	AddLine_(p, GetRightVector(q1) + p,persistent);
+
-//			SetColor_(Color.green);	AddLine_(p, GetUpVector(q1) + p,persistent);
+
-//			SetColor_(Color.blue);	AddLine_(p, GetForwardVector(q1) + p,persistent);
+
 		return lineg;
 	}
-		Quaternion q;
+	public GameObject AddCircle_(Vector3 p, float r, Vector3 normal, float angle, float startAngle, int pointsPerCircle, bool persistent)
 	{
 		float numPointsF = (angle * pointsPerCircle / 360);
-			q = Quaternion.AngleAxis(i*360.0f/24 + startRotation, normal);
+		int numPoints = (int)(numPointsF);
 		float remainder = numPointsF - numPoints;
 		GameObject lineg = GetLineGameObject();
-		q = Quaternion.AngleAxis(startRotation, normal);
+
-		lineRenderer.SetPosition(numPoints, p + q * right * r);
+		Quaternion q = Quaternion.LookRotation(normal);
 		Vector3 right = GetRightVector(q);
 		lineRenderer.SetVertexCount(numPoints+1 + ((remainder>0?1:0)));
 		lineRenderer.SetPosition(0, p + right * r);
 		for(int i = 0; i < numPoints+1; ++i)
-	public GameObject AddSpiralPlane_(Vector3 p, int size, Vector3 normal, bool persistent)
+
 			q = Quaternion.AngleAxis(i*360.0f/pointsPerCircle + startAngle, normal);
-		int perCircle = 24;
+
-		int numPoints = size*perCircle;
+
 		if(remainder > 0)
 		{
 			q = Quaternion.AngleAxis(angle + startAngle, normal);
 			lineRenderer.SetPosition(numPoints+1, p + q * right * r);
 		}
 		if(!persistent)
 			temp.Add(lineg);
-			Quaternion q = Quaternion.AngleAxis(i*360.0f/perCircle, normal);
+
 //		Color c = GetColor_();
 //			SetColor_(Color.red);	AddLine_(p, GetRightVector(q) + p,persistent);
-			rad += 2f/perCircle;
+//			SetColor_(Color.green);	AddLine_(p, GetUpVector(q) + p,persistent);
 //			SetColor_(Color.blue);	AddLine_(p, GetForwardVector(q) + p,persistent);
 //		SetColor_(c);
 		return lineg;
 	}
 	public GameObject AddQuaternion_(Vector3 p, float r, Quaternion quaternion, int pointsPerCircle, bool persistent)
 	{
 		Vector3 axis;
-	public static GameObject AddPersistentCircle(Vector3 center, float radius, Vector3 normal)
+		float angle;
-	{return instance.AddCircle_(center, radius, normal, true);}
+		quaternion.ToAngleAxis(out angle, out axis);
-	public static void AddTemporaryCircle(Vector3 center, float radius, Vector3 normal)
+		float s = widthStart, f = widthFinish;
-	{instance.AddCircle_(center, radius, normal, false);}
+		SetWidth_(s+f, 0);
-	public static GameObject AddPersistentSpiralPlane(Vector3 center, int size, Vector3 normal)
+		Vector3 r2 = axis*r*2;
-	{return instance.AddSpiralPlane_(center, size, normal, true);}
+		GameObject lineg = AddLine_(p-r2, p+r2, persistent);//GetLineGameObject();
 		GameObject curve = AddCircle_(p, r, axis, angle, 0, pointsPerCircle, persistent);
 		curve.transform.parent = lineg.transform;
 		SetWidth_(s, f);
 		if(!persistent)
 		{
 			temp.Add(lineg);
 			temp.Add(curve);
 		}
 		return lineg;
 	}
 	public GameObject AddSpiralPlane_(Vector3 p, int size, Vector3 normal, int pointsPerCircle, bool persistent)
 	{
 		int numPoints = size*pointsPerCircle;
 		GameObject lineg = GetLineGameObject();
 		LineRenderer lineRenderer = lineg.GetComponent<LineRenderer>();
 		Vector3 right = GetRightVector(Quaternion.LookRotation(normal));
 		lineRenderer.SetVertexCount(numPoints);
 		float rad = 0;
 		for(int i = 0; i < numPoints; ++i)
 		{
 			Quaternion q = Quaternion.AngleAxis(i*360.0f/pointsPerCircle, normal);
 			Vector3 delta = q * right * rad;
 			lineRenderer.SetPosition(i, p + (delta * 1));
 			rad += 2f/pointsPerCircle;
 		}
 		if(!persistent)
 			temp.Add(lineg);
 		return lineg;
 	}
 	Vector3 GetForwardVector(Quaternion q)
 	{
 		return new Vector3( 2 * (q.x * q.z + q.w * q.y),
 						2 * (q.y * q.z - q.w * q.x),
 						1 - 2 * (q.x * q.x + q.y * q.y));
 	}
 	public static Vector3 GetUpVector(Quaternion q)
 	{
 	    return new Vector3( 2 * (q.x * q.y - q.w * q.z),
 	                    1 - 2 * (q.x * q.x + q.z * q.z),
 	                    2 * (q.y * q.z + q.w * q.x));
 	}
 	public static Vector3  GetRightVector(Quaternion q)
 	{
 	    return new Vector3( 1 - 2 * (q.y * q.y + q.z * q.z),
 	                    2 * (q.x * q.y + q.w * q.z),
 	                    2 * (q.x * q.z - q.w * q.y));
 	}
 }