         midBC = vec3.scale( vec3.add(vB, vC, vec3.create()), 1/2 )
         midCA = vec3.scale( vec3.add(vC, vA, vec3.create()), 1/2 )
 
-        recursiveInit vA, midAB, midCA, detail
-        recursiveInit midAB, vB, midBC, detail
-        recursiveInit midCA, midBC, vC, detail
-        recursiveInit midAB, midBC, midCA, detail
+        recursiveInit vA, midAB, midCA, detail # top
+        recursiveInit midAB, vB, midBC, detail # left
+        recursiveInit midCA, midBC, vC, detail # right
+        recursiveInit midAB, midBC, midCA, detail # center
       true
 
     # Vertices & vertices' normals

        @complexity
      )

    # precision problems
#    vertL = ( Math.sqrt( ( 5 + Math.sqrt(5) ) / 2 ) ) # length of the icosahedron.vertices
#    scale = @size / vertL # normalize vertices on mesh size
#    theta = 0.5535743588970451 # Math.acos(g/vertL)
#    complexity = @complexity
#    size = @size
#    recursiveInit = (vAx, vAy, vAz, vBx, vBy, vBz, vCx, vCy, vCz, detail) ->
#      if detail < 1
#        vertices.push vAx*scale, vAy*scale, vAz*scale, vBx*scale, vBy*scale, vBz*scale, vCx*scale, vCy*scale, vCz*scale
#        normals.push  vAx/vertL, vAy/vertL, vAz/vertL, vBx/vertL, vBy/vertL, vBz/vertL, vCx/vertL, vCy/vertL, vCz/vertL
#      else
#        s = 1 / ( 2 * Math.cos( theta / Math.pow(2, complexity - detail) ) )
#        detail--
#        # top
#        recursiveInit(
#          vAx, vAy, vAz,
#          (vAx + vBx) * s, (vAy + vBy) * s, (vAz + vBz) * s,
#          (vAx + vCx) * s, (vAy + vCy) * s, (vAz + vCz) * s,
#          detail
#        )
#        # left
#        recursiveInit(
#          (vAx + vBx) * s, (vAy + vBy) * s, (vAz + vBz) * s,
#          vBx, vBy, vBz,
#          (vBx + vCx) * s, (vBy + vCy) * s, (vBz + vCz) * s,
#          detail
#        )
#        # right
#        recursiveInit(
#          (vAx + vCx) * s, (vAy + vCy) * s, (vAz + vCz) * s,
#          (vBx + vCx) * s, (vBy + vCy) * s, (vBz + vCz) * s,
#          vCx, vCy, vCz,
#          detail
#        )
#        # center
#        recursiveInit(
#          (vAx + vBx) * s, (vAy + vBy) * s, (vAz + vBz) * s,
#          (vBx + vCx) * s, (vBy + vCy) * s, (vBz + vCz) * s,
#          (vAx + vCx) * s, (vAy + vCy) * s, (vAz + vCz) * s,
#          detail
#        )
#      true

#    for face in icosahedron.faces
#      recursiveInit(
#        icosahedron.vertices[face[0]][0], icosahedron.vertices[face[0]][1], icosahedron.vertices[face[0]][2],
#        icosahedron.vertices[face[1]][0], icosahedron.vertices[face[1]][1], icosahedron.vertices[face[1]][2],
#        icosahedron.vertices[face[2]][0], icosahedron.vertices[face[2]][1], icosahedron.vertices[face[2]][2],
#        @complexity
#      )



    # UVs fixme
    for faceUVs in icosahedron.facesUVs
      for uv in faceUVs
        textureCoords.push uv[0] * u
        textureCoords.push uv[1] * v

    # Tangents todo
    # Bitangents todo


    size = @size

    _vA = vec3.create() ; _vB = vec3.create() ; _vC = vec3.create()
    recursiveInit = (vA, vB, vC, detail) ->
      if detail < 1
        vec3.normalize(vA, _vA)
