Line Drawing in Unity3D!

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;
    void LateUpdate()
    {
        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;
        lineRenderer.castShadows = false;
        lineRenderer.receiveShadows = false;
        lineRenderer.SetColors(color, color);
        lineRenderer.SetWidth(widthStart, widthFinish);
        go.transform.parent = transform;
        return go;
    }
    public GameObject AddLine_(Vector3 a, Vector3 b, bool persistent)
    {
        int numPoints = 2;
        GameObject lineg = GetLineGameObject();
        LineRenderer lineRenderer = lineg.GetComponent<LineRenderer>();
        lineRenderer.SetVertexCount(numPoints);
        lineRenderer.SetPosition(0, a);
        lineRenderer.SetPosition(1, b);
        if(!persistent)
            temp.Add(lineg);
        return lineg;
    }
    public GameObject AddCircle_(Vector3 p, float r, Vector3 normal, float angle, float startAngle, int pointsPerCircle, bool persistent)
    {
        float numPointsF = (angle * pointsPerCircle / 360);
        int numPoints = (int)(numPointsF);
        float remainder = numPointsF - numPoints;
        GameObject lineg = GetLineGameObject();
        LineRenderer lineRenderer = lineg.GetComponent<LineRenderer>();
        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)
        {
            q = Quaternion.AngleAxis(i*360.0f/pointsPerCircle + startAngle, normal);
            lineRenderer.SetPosition(i, p + q * right * r);
        }
        if(remainder > 0)
        {
            q = Quaternion.AngleAxis(angle + startAngle, normal);
            lineRenderer.SetPosition(numPoints+1, p + q * right * r);
        }
        if(!persistent)
            temp.Add(lineg);
        // TEST CODE
//      Color c = GetColor_();
//          SetColor_(Color.red);   AddLine_(p, GetRightVector(q) + p,persistent);
//          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;
        float angle;
        quaternion.ToAngleAxis(out angle, out axis);
        float s = widthStart, f = widthFinish;
        SetWidth_(s+f, 0);
        Vector3 r2 = axis*r*2;
        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));
    }
}