Subdivide to sphere

This script will create an empty gameobject and use that to determine the new positions for the vertices. If anyone knows of a more efficient way I'd be glad to hear it.

 var buildmesh : boolean = false;
 
 private var verts : Vector3[];
 
 private var norms : Vector3[];
 
 private var uvs : Vector2[];
 
 private var trigs : int[];
 
 private var mesh : Mesh;
 
 private var originalMesh : Mesh;
 
 //var subdivision : boolean = false;
 
 //var useobjectsmaterial : boolean = false;
 
 //var forceaddmeshcollider : boolean = false;
 
 //var sides : boolean = false;
 
 //var middle : boolean = false;
 
 private var aimPoint : GameObject;
 
 var sphereSize : float = 1;
 
 
 
 function Update () {
 
     if(Input.GetKeyDown("1"))
 
         subdivide(false);
 
     if(Input.GetKeyDown("2"))
 
         subdivide(true);
 
     if(Input.GetKeyDown("x")){
 
         CopyMesh(originalMesh, mesh);
 
     }
 
 }
 
 
 
 function Awake() {
 
    
 
     ///////////////////////////////////////////////////////////
 
     //// initialize
 
     ///////////////////////////////////////////////////////////
 
     //var buildmesh=false;
 
     if(GetComponent(MeshFilter) == null){
 
         buildmesh=true;
 
         gameObject.AddComponent(MeshFilter);
 
     }
 
     if(GetComponent(MeshRenderer) == null)
 
         gameObject.AddComponent(MeshRenderer);
 
     //if(forceaddmeshcollider) {
 
     //  if(GetComponent(MeshCollider) == null)
 
     //    gameObject.AddComponent(MeshCollider);
 
     //}
 
        
 
     updatemesh();
 
    
 
     //if(!useobjectsmaterial)
 
     //  GetComponent(MeshRenderer).material = material;
 
        
 
     ///////////////////////////////////////////////////////////
 
     //// build mesh
 
     ///////////////////////////////////////////////////////////
 
    
 
     if(buildmesh) {
 
        
 
         //// vertices
 
        
 
         verts = [Vector3(0,-1,0),Vector3(1,1,0),Vector3(-1,1,0)
 
         ,Vector3(0,1,-1)];
 
        
 
         //// uvs
 
        
 
         uvs = [Vector2(0,0),Vector2(0,1),Vector2(1,0),Vector2(0,0)];
 
        
 
         //// triangles
 
        
 
         trigs = [0,1,2,1,3,2];
 
        
 
         applymesh();
 
         mesh.RecalculateNormals();
 
        
 
         Debug.Log(verts.length);
 
     }
 
    
 
     originalMesh=new Mesh();
 
     CopyMesh(mesh, originalMesh);
 
 }
 
 
 
 function subdivide(center : boolean) {
 
        aimPoint=new GameObject("AimPoint");
 
        aimPoint.transform.parent=transform;
 
     verts = mesh.vertices;
 
     trigs = mesh.triangles;
 
     uvs = mesh.uv;
 
     norms = mesh.normals;
 
    
 
     Debug.Log("enter subdividing: "+verts.length);
 
    
 
     var nv = new Array(verts);
 
     var nt = new Array(trigs);
 
     var nu = new Array(uvs);
 
     var nn = new Array(norms);
 
    
 
     if(!center) {
 
    
 
     for(var i : int = 2;i<trigs.length;i+=3) {
 
            
 
             var p0trigwho : int = trigs[i-2];
 
             var p1trigwho : int = trigs[i-1];
 
             var p2trigwho : int = trigs[i];
 
            
 
             var p0trigwhere : int = i-2;
 
             var p1trigwhere : int = i-1;
 
             var p2trigwhere : int = i;
 
            
 
             var p0 : Vector3 = verts[p0trigwho];
 
             var p1 : Vector3 = verts[p1trigwho];
 
             var p2 : Vector3 = verts[p2trigwho];
 
            
 
             var pn0 : Vector3 = norms[p0trigwho];
 
             var pn1 : Vector3 = norms[p1trigwho];
 
             var pn2 : Vector3 = norms[p2trigwho];
 
            
 
             var pu0 : Vector2 = uvs[p0trigwho];
 
             var pu1 : Vector2 = uvs[p1trigwho];
 
             var pu2 : Vector2 = uvs[p2trigwho];
 
            
 
             var p0mod : Vector3 = (p0+p1)/2;   
 
             var p1mod : Vector3 = (p1+p2)/2;
 
             var p2mod : Vector3 = (p0+p2)/2;
 
            
 
             var pn0mod : Vector3 = ((pn0+pn1)/2).normalized;   
 
             var pn1mod : Vector3 = ((pn1+pn2)/2).normalized;
 
             var pn2mod : Vector3 = ((pn0+pn2)/2).normalized;
 
            
 
             var pu0mod : Vector2 = (pu0+pu1)/2; 
 
             var pu1mod : Vector2 = (pu1+pu2)/2;
 
             var pu2mod : Vector2 = (pu0+pu2)/2;
 
                
 
             var p0modtrigwho = nv.length;
 
             var p1modtrigwho = nv.length+1;
 
             var p2modtrigwho = nv.length+2;
 
                
 
             nv.push(p0mod);
 
             nv.push(p1mod);
 
             nv.push(p2mod);
 
            
 
             nn.push(pn0mod);
 
             nn.push(pn1mod);
 
             nn.push(pn2mod);
 
            
 
             nu.push(pu0mod);
 
             nu.push(pu1mod);
 
             nu.push(pu2mod);
 
            
 
             nt[p0trigwhere] = p0trigwho;
 
             nt[p1trigwhere] = p0modtrigwho;
 
             nt[p2trigwhere] = p2modtrigwho;
 
            
 
             nt.push(p0modtrigwho);
 
             nt.push(p1modtrigwho);
 
             nt.push(p2modtrigwho);
 
            
 
             nt.push(p0modtrigwho);
 
             nt.push(p1trigwho);
 
             nt.push(p1modtrigwho);
 
            
 
             nt.push(p2modtrigwho);
 
             nt.push(p1modtrigwho);
 
             nt.push(p2trigwho);
 
         }
 
    
 
     }else{
 
        
 
         for(var ii : int = 2;ii<trigs.length;ii+=3) {
 
            
 
             var p0trigwhomi : int = trigs[ii-2];
 
             var p1trigwhomi : int = trigs[ii-1];
 
             var p2trigwhomi : int = trigs[ii];
 
            
 
             var p0trigwheremi : int = ii-2;
 
             var p1trigwheremi : int = ii-1;
 
             var p2trigwheremi : int = ii;
 
            
 
             var p0mi : Vector3 = verts[p0trigwhomi];
 
             var p1mi : Vector3 = verts[p1trigwhomi];
 
             var p2mi : Vector3 = verts[p2trigwhomi];
 
            
 
             var p0mn : Vector3 = norms[p0trigwhomi];
 
             var p1mn : Vector3 = norms[p1trigwhomi];
 
             var p2mn : Vector3 = norms[p2trigwhomi];
 
            
 
             var p0mu : Vector2 = uvs[p0trigwhomi];
 
             var p1mu : Vector2 = uvs[p1trigwhomi];
 
             var p2mu : Vector2 = uvs[p2trigwhomi];
 
            
 
             var p0modmi : Vector3 = (p0mi+p1mi+p2mi)/3;
 
             var p0modmn : Vector3 = ((p0mn+p1mn+p2mn)/3).normalized;
 
             var p0modmu : Vector2 = (p0mu+p1mu+p2mu)/3; 
 
                
 
             var p0modtrigwhomi = nv.length;
 
                
 
             nv.push(p0modmi);
 
             nn.push(p0modmn);
 
             nu.push(p0modmu);
 
            
 
             nt[p0trigwheremi] = p0trigwhomi;
 
             nt[p1trigwheremi] = p1trigwhomi;
 
             nt[p2trigwheremi] = p0modtrigwhomi;
 
            
 
             nt.push(p0modtrigwhomi);
 
             nt.push(p1trigwhomi);
 
             nt.push(p2trigwhomi);
 
            
 
             nt.push(p0trigwhomi);
 
             nt.push(p0modtrigwhomi);
 
             nt.push(p2trigwhomi);
 
            
 
         }
 
        
 
     }
 
     for(var iii : int = 2;iii<nv.length;iii++)
 
     {
 
            aimPoint.transform.position=Vector3.zero;
 
            aimPoint.transform.LookAt(nv[iii]);
 
            aimPoint.transform.Translate(Vector3.forward * sphereSize);
 
            nv[iii]=aimPoint.transform.position;
 
     }
 
     Destroy(aimPoint);
 
     verts = nv.ToBuiltin(Vector3);
 
     norms = nn.ToBuiltin(Vector3);
 
     uvs = nu.ToBuiltin(Vector2);
 
     trigs = nt.ToBuiltin(int);
 
    
 
     //applyuvs();
 
     applymesh();
 
     //mesh.RecalculateNormals();
 
    
 
     Debug.Log("exit subdividing: "+verts.length);
 
 }
 
 
 
 function applyuvs() {
 
     uvs = new Vector2[verts.length];
 
     for(var i : int = 0;i<verts.length;i++)
 
         uvs[i] = Vector2(verts[i].x,verts[i].y);
 
 }
 
 
 
 function updatemesh() {
 
     //mesh = new Mesh();
 
     mesh = GetComponent(MeshFilter).mesh;
 
 }
 
 
 
 function applymesh() {
 
     print(verts.length);
 
     if(verts.length > 65000){
 
         Debug.Log("Exiting... Too many vertices");
 
         return;
 
     }
 
     mesh.Clear();
 
     mesh.vertices = verts;
 
     mesh.uv = uvs;
 
     if(mesh.uv2 != null)
 
         mesh.uv2 = uvs;
 
     mesh.normals = norms;
 
     mesh.triangles = trigs;
 
     mesh.RecalculateBounds();
 
     if(GetComponent(MeshCollider) != null)
 
         GetComponent(MeshCollider).sharedMesh = mesh;
 
     updatemesh();
 
 }
 
 
 
 function CopyMesh(fromMesh : Mesh, toMesh : Mesh){
 
     toMesh.Clear();
 
     toMesh.vertices=fromMesh.vertices;
 
     toMesh.normals=fromMesh.normals;
 
     toMesh.uv=fromMesh.uv;
 
     toMesh.triangles=fromMesh.triangles;
 
 }