World Struct

using UnityEngine;
using System.Collections;
using System;

[RequireComponent(typeof(MeshFilter))]
[RequireComponent(typeof(MeshRenderer))]
[RequireComponent(typeof(MeshCollider))]
public class WorldStructure : MonoBehaviour {
    Voxel[,,] voxels;
    MeshFilter filter;
    MeshCollider coll;

    public int chunkSize = 16;
    public bool update;
    public bool rendered;
    public bool showGen;

    void Start()
    {
        filter = gameObject.GetComponent<MeshFilter>();
        coll = gameObject.GetComponent<MeshCollider>();
        voxels = new Voxel[chunkSize, chunkSize, chunkSize];
        try
        {
            for (int x = 0; x < chunkSize; x++)
            {
                for (int y = 0; y < chunkSize; y++)
                {
                    for (int z = 0; z < chunkSize; z++)
                    {
                        createVoxel(x, y, z, "air");
                    }
                }
            }
            try
            {
                if(showGen)
                    StartCoroutine(constructVoxels());
                else
                {
                    for (int x = 1; x < chunkSize - 1; x++)
                    {
                        for (int y = 2; y < chunkSize - 2; y++)
                        {
                            for (int z = 1; z < chunkSize - 1; z++)
                            {
                                createVoxel(x, 1, z);
                                createVoxel(x, 2, z, "dirt");
                                createVoxel(x, 3, z, "grass");
                            }
                        }
                    }
                }
            }
            catch (Exception e) { Debug.Log(e); }
        }
        catch (Exception e) { Debug.Log(e); }
        UpdateChunk();
    }

    IEnumerator constructVoxels()
    {
        for (int x = 1; x < chunkSize - 1; x++)
        {
                for (int z = 1; z < chunkSize - 1; z++)
                {
                    createVoxel(x, 1, z);
                    createVoxel(x, 2, z, "dirt");
                    createVoxel(x, 3, z, "grass");
                    UpdateChunk();
                    yield return new WaitForSeconds(0f);
                }
        }
    }

    void Update()
    {
        if(update)
        {
            update = false;
            UpdateChunk();
        }
    }

    void UpdateChunk()
    {
        rendered = true;
        MeshData meshData = new MeshData();
        try
        {
            for (int x = 0; x < chunkSize; x++)
            {
                for (int y = 0; y < chunkSize; y++)
                {
                    for (int z = 0; z < chunkSize; z++)
                    {
                        meshData = voxels[x, y, z].VoxelData(this, x, y, z, meshData);
                    }
                }
            }
        }
        catch (Exception e) { Debug.Log(e); }
        RenderMesh(meshData);
    }

    void createVoxel(int x, int y, int z)
    {
        voxels[x, y, z] = new Voxel();
    }

    void createVoxel(int x, int y, int z, string voxelType)
    {
        if (voxelType.ToLower() == "air")
            voxels[x, y, z] = new Voxel_Air();
        if (voxelType.ToLower() == "grass")
            voxels[x, y, z] = new Voxel_Grass();
        if (voxelType.ToLower() == "dirt")
            voxels[x, y, z] = new Voxel_Dirt();
    }

    void RenderMesh(MeshData meshData)
    {
        filter.mesh.Clear();
        filter.mesh.vertices = meshData.verts.ToArray();
        filter.mesh.triangles = meshData.tris.ToArray();
        filter.mesh.uv = meshData.uvs.ToArray();
        filter.mesh.RecalculateNormals();

        coll.sharedMesh = null;
        Mesh mesh = new Mesh();
        mesh.vertices = meshData.colVerts.ToArray();
        mesh.triangles = meshData.colTris.ToArray();
        mesh.RecalculateNormals();

        coll.sharedMesh = mesh;
    }

    public Voxel getVoxel(int x, int y, int z)
    {
        return voxels[x, y, z];
    }
}