procedural heightmap mesh w/ lods attempt

func make_heightmap(x,y):
    print_debug(str(multiplayer.get_unique_id())+" Generate terrain "+str(x)+","+str(y))
    noise.fractal_octaves = 4
    var meshdata = []
    var expectedNormals = []
    var biomevals = []
    for yy in range(0,(map_size.y/mesh_density)+1):
        for xx in range(0,(map_size.x/mesh_density)+1):
            meshdata.append(getHeight((xx*mesh_density)+x,(mesh_density*yy)+y))
            expectedNormals.append(make_normal(Vector3((xx*mesh_density)+x,getHeight((xx*mesh_density)+x,(yy*mesh_density)+y),(yy*mesh_density)+y)))
            biomevals.append(biome_data((xx*mesh_density)+x,(mesh_density*yy)+y))
    var scaled_data = []
    for yy in range(0,(map_size.y/collision_density)+1):
        for xx in range(0,(map_size.x/collision_density)+1):
            scaled_data.append(getHeight((xx*collision_density)+x,(yy*collision_density)+y))

    var staticbody = Tile.new()
    staticbody.x = x
    staticbody.y = y
    staticbody.set_collision_layer_value(1,true)
    staticbody.set_collision_mask_value(2,true)
    staticbody.set_collision_mask_value(3,true)
    staticbody.collision_priority = 25


    var newMesh = MeshInstance3D.new()
    newMesh.mesh = PlaneMesh.new()
    newMesh.mesh.size.x = map_size.x
    newMesh.mesh.size.y = map_size.y
    newMesh.mesh.subdivide_width = (map_size.x/mesh_density) -1
    newMesh.mesh.subdivide_depth = (map_size.y/mesh_density) -1
    var mesh = ArrayMesh.new()

#

    mesh.add_surface_from_arrays(Mesh.PRIMITIVE_TRIANGLES, newMesh.mesh.get_mesh_arrays() )
    var mdt = MeshDataTool.new()
    mdt.create_from_surface(mesh, 0)
    for i in range(mdt.get_vertex_count()):
        var vertex = mdt.get_vertex(i)
        vertex.y = meshdata[i]
        mdt.set_vertex(i, vertex)
        var a = 1
        var old = mdt.get_vertex_normal(i)
        mdt.set_vertex_normal(i,expectedNormals[i])

#   # Run through vertices one last time to normalize normals and
#   # set color to biome values.
    for i in range(mdt.get_vertex_count()):
        var v = mdt.get_vertex_normal(i).normalized().rotated(Vector3.UP,PI)
        mdt.set_vertex_normal(i, v)
        mdt.set_vertex_color(i, Color(biomevals[i].x,biomevals[i].y,biomevals[i].z,1.0))

    mesh.clear_surfaces()
    mdt.commit_to_surface(mesh)
    newMesh.mesh = mesh

    var xsize:int = map_size.x/mesh_density
    var ysize:int = map_size.y/mesh_density
    var generated_lods = {}
    for key in lods.keys():
        var decimate:int = lods[key]
        var lod_indexes:Array[int] = []
        for vx in range(xsize/decimate):
            for vy in range(ysize/decimate):
                lod_indexes.append((vy*(xsize+1)*decimate)+(vx*decimate))
                lod_indexes.append((vy*(xsize+1)*decimate)+((vx+1)*decimate))
                lod_indexes.append(((vy+1)*(xsize+1)*decimate)+(vx*decimate))

                lod_indexes.append((vy*(xsize+1)*decimate)+((vx+1)*decimate))
                lod_indexes.append(((vy+1)*(xsize+1)*decimate)+((vx+1)*decimate))
                lod_indexes.append(((vy+1)*(xsize+1)*decimate)+(vx*decimate))

        generated_lods[key]=PackedInt32Array(lod_indexes)


    var arrays = mesh.surface_get_arrays(0)
    mesh.clear_surfaces()
    mesh.add_surface_from_arrays(Mesh.PRIMITIVE_TRIANGLES,arrays,[],generated_lods)
    mesh.surface_set_material(0,surface_material)
    mesh.regen_normal_maps()
    newMesh.rotate_y(PI)


    newMesh.create_trimesh_collision()
    var temp_collision = newMesh.find_children("*","CollisionShape3D",true,false)[0]
    temp_collision.get_parent().remove_child(temp_collision)
    staticbody.add_child(temp_collision)
    temp_collision.rotate_y(PI)


    newMesh.cast_shadow = GeometryInstance3D.SHADOW_CASTING_SETTING_DOUBLE_SIDED
    staticbody.add_child(newMesh)
    newMesh.set_owner(get_tree().edited_scene_root)
    staticbody.global_position = Vector3(x,0,y)

    spare_tiles.append(staticbody)
    staticbody.tree_entered.connect(add_objects.bind(staticbody))
    return staticbody