public void Initialize(int resolution, float size)
    {
        this.m_resolution = resolution;
        m_gridSize = size;
        m_voxelSize = size / resolution;
        m_voxels = new Voxel[resolution * resolution];
        m_voxelMaterials = new Material[m_voxels.Length];

        for (int i = 0, y = 0; y < resolution; y++)
        {
            for (int x = 0; x < resolution; x++, i++)
            {
                CreateVoxel(i, x, y);
            }
        }

        m_dummyX = new Voxel();
        m_dummyY = new Voxel();
        m_dummyT = new Voxel();

        //offset the grid to center it inside the screen
        Vector3 gridPosition = new Vector3(-0.5f * size, -0.5f * size, 0);
        this.transform.localPosition = gridPosition;

        GetComponent<MeshFilter>().mesh = m_mesh = new Mesh();
        m_mesh.name = "VoxelGrid Mesh";
        m_vertices = new List<Vector3>();
        m_triangles = new List<int>();
        Refresh();
    }

 public static VoxelCommand Add(Voxel voxel)
 {
     VoxelCommand cmd = new VoxelCommand ();
     cmd._type = Type.Add;
     cmd._voxel = voxel;
     return cmd;
 }

    void detector_Collided(Volume collisonObject, Voxel voxel, Vector3 worldPosition)
    {
        // If the bullet hits an invader and is owned by the player, explode and destroy the invader - and deactivate the bullet
        if (collisonObject.name == "Invader" && Owner is InvadersPlayerShip)
        {
            collisonObject.Destruct(3f, true);
            Destroy(collisonObject.gameObject);
            gameObject.SetActive(false);
        }

        // If we hit a shield, just explode and deactivate the bullet
        if (collisonObject.name == "Shield")
        {
            exploder.ExplosionRadius = 1f;
            exploder.Explode();
            gameObject.SetActive(false);
        }

        // If we hit the player ship
        if (collisonObject.name == "Player Ship")
        {
            collisonObject.Destruct(3f, true);
            collisonObject.GetComponent<InvadersPlayerShip>().Die();
            gameObject.SetActive(false);
        }
    }

    static Voxel[] GetDataFromString(int width, int height, int depth, string dataString)
    {
        string[] layers = dataString.Split ('-');
                int size = height * depth * width;
                Voxel[] data = new Voxel[size];
                int c = 0;
                foreach (string layer in layers) {
                        string[] lines = layer.Split ('\n');
                        foreach (string line in lines) {
                                string row = line.Trim ();
                                for (int i = 0; i < row.Length; i++) {
                                        Voxel v = new Voxel();
                                        int j;
                                        if (int.TryParse (row [i] + "", out j)) {
                                                v.id = (byte)j;
                                        } else {
                                                v.id = 0;
                                        }
                                        // cut in the middle of processing
                                        if (c == size) {
                                                return data;
                                        }
                                        data [c++] = v;
                                }
                        }
                }

                if (c != size) {
                        throw new Exception ("insuficient voxel data");
                }

                return data;
    }

	void DetectVoxels ()
	{
		if (currentVoxel == null)
			currentVoxel = new Voxel ();


	}

    public void RemoveVoxelAnimation(bool hasPreviousBlock, Voxel voxel, Action finishCallback)
    {
        if (_animDic.ContainsKey(voxel.Pos))
        {
            AnimTuple anim = _animDic[voxel.Pos];
            anim.Trans.GetComponent<MeshRenderer>().material.color = voxel.Color;
            anim.Trans.GetComponent<DummyBehavior>().StopAllCoroutines();
            anim.Cor = anim.Trans.GetComponent<DummyBehavior>().StartCoroutine(RemoveVoxelAnimationCor(voxel.Pos, anim.Trans, () =>
            {
                finishCallback();
            }));
        }
        else
        {
            if (hasPreviousBlock)
            {
                AnimTuple anim = new AnimTuple();
                _animDic[voxel.Pos] = anim;
                anim.Trans = CreateAnimTransform(voxel);
                anim.Trans.localScale = Vector3.one;
                anim.Cor = anim.Trans.GetComponent<DummyBehavior>().StartCoroutine(RemoveVoxelAnimationCor(voxel.Pos, anim.Trans, () =>
                {
                    finishCallback();
                }));

            }
        }
    }

    public void InstantiateVoxels(int startx, int starty, int startz, int width, int height, int depth)
    {
        Width = width;
        Height = height;
        Depth = depth;

        Voxels = new Voxel[Width, Height, Depth];

        float voxelSize = VoxelWorld.Inst.PhysicalVoxelSize;
        float halfVoxel = voxelSize * 0.5f;

        for (int x = 0; x < Width; ++x)
        {
            for (int y = 0; y < Height; ++y)
            {
                for (int z = 0; z < Depth; ++z)
                {
                    IntVec3 pos = new IntVec3(startx + x, starty + y, startz + z);
                    BoxCollider collider = gameObject.AddComponent<BoxCollider>();
                    collider.center = new Vector3(pos.X + halfVoxel, pos.Y + halfVoxel, pos.Z + halfVoxel);
                    collider.size = new Vector3(voxelSize, voxelSize, voxelSize);
                    Voxel voxel = new Voxel(this, VoxelType.Air, pos, collider);
                    Voxels[x, y, z] = voxel;
                    ColliderToVoxel[collider] = voxel;
                }
            }
        }
    }

        public void Add(Voxel voxel)
        {
            voxel.position -= this.Position;
            if (Voxels[(int)voxel.position.X, (int)voxel.position.Y, (int)voxel.position.Z] != null) return;
            //if (!inChunk(voxel.position)) return;
            //this.Remove(voxel);
            Voxels[(int)voxel.position.X, (int)voxel.position.Y, (int)voxel.position.Z] = voxel;

            if (((int)voxel.position.X + 1 < this.Size.X && Voxels[(int)voxel.position.X + 1, (int)voxel.position.Y, (int)voxel.position.Z] == null) || (int)voxel.position.X == this.Size.X - 1)
                vertices.AddRange(Face.getFace( Face.Facing.Right, voxel.position, voxel.color));

            if (((int)voxel.position.X - 1 >= 0 && Voxels[(int)voxel.position.X - 1, (int)voxel.position.Y, (int)voxel.position.Z] == null) || (int)voxel.position.X == 0)
                vertices.AddRange(Face.getFace( Face.Facing.Left, voxel.position, voxel.color));

            if (((int)voxel.position.Y + 1 < this.Size.Y && Voxels[(int)voxel.position.X, (int)voxel.position.Y + 1, (int)voxel.position.Z] == null) || (int)voxel.position.Y == this.Size.Y - 1)
                vertices.AddRange(Face.getFace( Face.Facing.Up, voxel.position, voxel.color));

            if (((int)voxel.position.Y - 1 >= 0 && Voxels[(int)voxel.position.X, (int)voxel.position.Y - 1, (int)voxel.position.Z] == null) || (int)voxel.position.Y == 0)
                vertices.AddRange(Face.getFace( Face.Facing.Down, voxel.position, voxel.color));

            if (((int)voxel.position.Z + 1 < this.Size.Z && Voxels[(int)voxel.position.X, (int)voxel.position.Y, (int)voxel.position.Z + 1] == null) || (int)voxel.position.Z == this.Size.Z - 1)
                vertices.AddRange(Face.getFace( Face.Facing.Forward, voxel.position, voxel.color));

            if (((int)voxel.position.Z - 1 >= 0 && Voxels[(int)voxel.position.X, (int)voxel.position.Y, (int)voxel.position.Z - 1] == null) || (int)voxel.position.Z == 0)
                vertices.AddRange(Face.getFace( Face.Facing.Backward, voxel.position, voxel.color));

            this.Build();
        }

 public static Voxel[] GetNeighbours(Point3 worldCoord)
 {
     Voxel[] neighbours = new Voxel[6];
     for (int i=0; i<checkSides.Length; i++) {
         neighbours[i] = ChunkManager.GetBlock(worldCoord + checkSides[i]);
     }
     return neighbours;
 }

 public void AddVoxel(Voxel voxel)
 {
     _voxelAnimation.AddVoxelAnimation(_voxelData.HasVoxelAtPos(voxel.Pos), voxel, () =>
     {
         _voxelData.AddVoxel(voxel);
         _voxelRenderer.RenderMesh(_voxelData);
     });
 }

 private void detector_Collided(Volume collisonObject, Voxel voxel, Vector3 worldPosition)
 {
     if (collisonObject.name.StartsWith("Plane") && Owner is ShmupChopper)
     {
         collisonObject.GetComponent<ShmupPlane>().Die();
         gameObject.SetActive(false);
     }
 }

 public void Set(int x, int y, int z, Voxel voxel)
 {
     if (voxels.GetLength(0) < x ||
         voxels.GetLength(1) < y ||
         voxels.GetLength(2) < z) {
         return;
     }
     voxels[x, y, z] = voxel;
 }

 // TODO: Cache all the binary formatters
 public static byte[] SeralizeVoxel(Voxel voxel)
 {
     BinaryFormatter formatter = new BinaryFormatter();
     using (MemoryStream stream = new MemoryStream())
     {
         formatter.Serialize(stream, voxel);
         return stream.ToArray();
     }
 }

	public void BecomeYDummyOf (Voxel voxel, float offset) {
		state = voxel.state;
		position = voxel.position;
		xEdgePosition = voxel.xEdgePosition;
		yEdgePosition = voxel.yEdgePosition;
		position.y += offset;
		xEdgePosition.y += offset;
		yEdgePosition.y += offset;
	}

 public override Voxel.State Apply(int x, int y, Voxel.State voxel)
 {
     x -= centerX;
     y -= centerY;
     if (x * x + y * y <= sqrRadius)
     {
         return fillType;
     }
     return voxel;
 }

	public void SetVoxel (Voxel vox, Vector3 pos){
		pos = new Vector3((int)pos.x, (int)pos.y, (int)pos.z);
		if (grid.ContainsKey (pos)) {
//			Debug.Log ("voxel " + vox + " overwriting space " + pos + ", previously occupied by " + grid[pos]);
			grid[pos] = vox;
		}
		else{
			grid.Add (pos, vox);
		}
	}

 public void BecomeYDummyOf(Voxel voxel, float offset)
 {
     m_state = voxel.m_state;
     m_position = voxel.m_position;
     m_xEdgePosition = voxel.m_xEdgePosition;
     m_yEdgePosition = voxel.m_yEdgePosition;
     m_position.y += offset;
     m_xEdgePosition.y += offset;
     m_yEdgePosition.y += offset;
 }

 // Requires neighbours to be listed in correct order.
 // Returns the sum of each neighbour's ID.
 public static int GetID(Voxel[] neighbours)
 {
     int id = 0;
     for (int i=0; i<neighbours.Length; i++) {
         if (neighbours[i] == null) {
             continue;
         }
         id += neighbourIDs[i];
     }
     return id;
 }

 public void BecomeYDummyOf(Voxel voxel, float offset)
 {
     state = voxel.state;
     position = voxel.position;
     eastEdge = voxel.eastEdge;
     southEdge = voxel.southEdge;
     cornerPosition = voxel.cornerPosition;
     position.z -= offset;
     eastEdge.z -= offset;
     southEdge.z -= offset;
     cornerPosition.z -= offset;
 }

    // Given new chunk of voxels, reset and rebuild mesh
    public void UseVoxels(Voxel[] src_voxels, int chunkx, int chunky)
    {
        // If this chunk already displays given voxels, do nothing
        if (this.voxels == src_voxels) {
            return;
        }

        this.chunkX = chunkx;
        this.chunkY = chunky;
        this.voxels = src_voxels;
        RebuildMesh();
    }