package electrosphere.renderer.meshgen;

import static org.junit.jupiter.api.Assertions.*;

import java.util.LinkedList;
import java.util.List;

import org.joml.Vector2f;
import org.joml.Vector3f;

import electrosphere.client.block.BlockChunkData;
import electrosphere.renderer.meshgen.BlockMeshgen.BlockMeshData;
import electrosphere.renderer.meshgen.BlockMeshgen.QuadMesh;
import electrosphere.test.annotations.UnitTest;

/**
 * Tests for block mesh generation
 */
public class BlockMeshgenTests {
    
    /**
     * If a normal vector has same length across all three axis, this will be the length
     */
    static final float NORMAL_MULTIPLIER = 0.57735026f;

    @UnitTest
    public void test_fillQuadMeshes_1(){

        //expected data
        QuadMesh[] expectedData = new QuadMesh[]{
            new QuadMesh(0,0,0,1,1),
        };

        //setup data
        BlockChunkData chunkData = new BlockChunkData();
        short[] types = new short[BlockChunkData.CHUNK_DATA_WIDTH * BlockChunkData.CHUNK_DATA_WIDTH * BlockChunkData.CHUNK_DATA_WIDTH];
        chunkData.setType(types);
        chunkData.setType(0, 0, 0, (short)1);
        List<QuadMesh> quadMeshes = new LinkedList<QuadMesh>();

        //call
        BlockMeshgen.fillQuadMeshes(quadMeshes, chunkData);


        //error check result
        assertEquals(expectedData.length, quadMeshes.size());

        for(QuadMesh expected : expectedData){
            boolean found = false;
            for(QuadMesh actual : quadMeshes){
                if(expected.x == actual.x && expected.y == actual.y && expected.w == actual.w && expected.h == actual.h){
                    found = true;
                    assertEquals(expected.x, actual.x);
                    assertEquals(expected.y, actual.y);
                    assertEquals(expected.w, actual.w);
                    assertEquals(expected.h, actual.h);
                    break;
                }
            }
            assertEquals(true, found);
        }
    }

    @UnitTest
    public void test_fillQuadMeshes_2(){
        //expected data
        QuadMesh[] expectedData = new QuadMesh[]{
            new QuadMesh(0,0,0,1,2),
        };

        //setup data
        BlockChunkData chunkData = new BlockChunkData();
        short[] types = new short[BlockChunkData.CHUNK_DATA_WIDTH * BlockChunkData.CHUNK_DATA_WIDTH * BlockChunkData.CHUNK_DATA_WIDTH];
        chunkData.setType(types);
        chunkData.setType(0, 0, 0, (short)1);
        chunkData.setType(0, 1, 0, (short)1);
        List<QuadMesh> quadMeshes = new LinkedList<QuadMesh>();

        //call
        BlockMeshgen.fillQuadMeshes(quadMeshes, chunkData);


        //error check result
        assertEquals(expectedData.length, quadMeshes.size());

        for(QuadMesh expected : expectedData){
            boolean found = false;
            for(QuadMesh actual : quadMeshes){
                if(expected.x == actual.x && expected.y == actual.y && expected.w == actual.w && expected.h == actual.h){
                    found = true;
                    assertEquals(expected.x, actual.x);
                    assertEquals(expected.y, actual.y);
                    assertEquals(expected.w, actual.w);
                    assertEquals(expected.h, actual.h);
                    break;
                }
            }
            assertEquals(true, found);
        }
    }

    @UnitTest
    public void test_fillQuadMeshes_3(){
        //expected data
        QuadMesh[] expectedData = new QuadMesh[]{
            new QuadMesh(0,0,0,2,2),
        };

        //setup data
        BlockChunkData chunkData = new BlockChunkData();
        short[] types = new short[BlockChunkData.CHUNK_DATA_WIDTH * BlockChunkData.CHUNK_DATA_WIDTH * BlockChunkData.CHUNK_DATA_WIDTH];
        chunkData.setType(types);
        chunkData.setType(0, 0, 0, (short)1);
        chunkData.setType(0, 1, 0, (short)1);
        chunkData.setType(1, 0, 0, (short)1);
        chunkData.setType(1, 1, 0, (short)1);
        List<QuadMesh> quadMeshes = new LinkedList<QuadMesh>();

        //call
        BlockMeshgen.fillQuadMeshes(quadMeshes, chunkData);


        //error check result
        assertEquals(expectedData.length, quadMeshes.size());

        for(QuadMesh expected : expectedData){
            boolean found = false;
            for(QuadMesh actual : quadMeshes){
                if(expected.x == actual.x && expected.y == actual.y && expected.w == actual.w && expected.h == actual.h){
                    found = true;
                    assertEquals(expected.x, actual.x);
                    assertEquals(expected.y, actual.y);
                    assertEquals(expected.w, actual.w);
                    assertEquals(expected.h, actual.h);
                    break;
                }
            }
            assertEquals(true, found);
        }
    }

    @UnitTest
    public void test_fillQuadMeshes_4(){
        //expected data
        QuadMesh[] expectedData = new QuadMesh[]{
            new QuadMesh(0,0,0,1,1),
            new QuadMesh(0,2,0,1,1),
        };

        //setup data
        BlockChunkData chunkData = new BlockChunkData();
        short[] types = new short[BlockChunkData.CHUNK_DATA_WIDTH * BlockChunkData.CHUNK_DATA_WIDTH * BlockChunkData.CHUNK_DATA_WIDTH];
        chunkData.setType(types);
        chunkData.setType(0, 0, 0, (short)1);
        chunkData.setType(0, 2, 0, (short)1);
        List<QuadMesh> quadMeshes = new LinkedList<QuadMesh>();

        //call
        BlockMeshgen.fillQuadMeshes(quadMeshes, chunkData);


        //error check result
        assertEquals(expectedData.length, quadMeshes.size());

        for(QuadMesh expected : expectedData){
            boolean found = false;
            for(QuadMesh actual : quadMeshes){
                if(expected.x == actual.x && expected.y == actual.y && expected.w == actual.w && expected.h == actual.h){
                    found = true;
                    assertEquals(expected.x, actual.x);
                    assertEquals(expected.y, actual.y);
                    assertEquals(expected.w, actual.w);
                    assertEquals(expected.h, actual.h);
                    break;
                }
            }
            assertEquals(true, found);
        }
    }

    @UnitTest
    public void test_fillQuadMeshes_5(){
        //setup data
        BlockChunkData chunkData = new BlockChunkData();
        short[] types = new short[BlockChunkData.CHUNK_DATA_WIDTH * BlockChunkData.CHUNK_DATA_WIDTH * BlockChunkData.CHUNK_DATA_WIDTH];
        chunkData.setType(types);
        List<QuadMesh> quadMeshes = new LinkedList<QuadMesh>();

        //call
        BlockMeshgen.fillQuadMeshes(quadMeshes, chunkData);

        //error check result
        assertEquals(0, quadMeshes.size());
    }

    @UnitTest
    public void test_meshifyBox_verts(){
        //expected data
        float[] expectedData = new float[]{
            0,0,0,
            1,0,0,
            0,1,0,
            1,1,0,

            0,0,0,
            0,0,1,
            0,1,0,
            0,1,1,

            0,0,0,
            0,0,1,
            1,0,0,
            1,0,1,

            0,0,1,
            1,0,1,
            0,1,1,
            1,1,1,

            1,0,0,
            1,0,1,
            1,1,0,
            1,1,1,

            0,1,0,
            0,1,1,
            1,1,0,
            1,1,1,
        };
        for(int i = 0; i < expectedData.length; i++){
            expectedData[i] = expectedData[i] * BlockChunkData.BLOCK_SIZE_MULTIPLIER;
        }

        //setup data
        List<Vector3f> verts = new LinkedList<Vector3f>();
        List<Vector3f> normals = new LinkedList<Vector3f>();
        List<Vector2f> uvs = new LinkedList<Vector2f>();
        List<Integer> indices = new LinkedList<Integer>();
        QuadMesh quad = new QuadMesh(0, 0, 0, 1, 1);

        //call
        BlockMeshgen.meshifyBox(verts, normals, uvs, indices, quad, 1);


        //error check result
        assertEquals(expectedData.length / 3, verts.size());

        int i = 0;
        for(Vector3f vert : verts){
            assertEquals(expectedData[i + 0], vert.x);
            assertEquals(expectedData[i + 1], vert.y);
            assertEquals(expectedData[i + 2], vert.z);
            i = i + 3;
        }
    }

    @UnitTest
    public void test_meshifyBox_normals(){
        //expected data
        float[] expectedData = new float[]{
             0, 0,-1,
             0, 0,-1,
             0, 0,-1,
             0, 0,-1,

             -1, 0, 0,
             -1, 0, 0,
             -1, 0, 0,
             -1, 0, 0,

             0,-1, 0,
             0,-1, 0,
             0,-1, 0,
             0,-1, 0,

             0, 0, 1,
             0, 0, 1,
             0, 0, 1,
             0, 0, 1,


             1, 0, 0,
             1, 0, 0,
             1, 0, 0,
             1, 0, 0,


             0, 1, 0,
             0, 1, 0,
             0, 1, 0,
             0, 1, 0,
        };

        //setup data
        List<Vector3f> verts = new LinkedList<Vector3f>();
        List<Vector3f> normals = new LinkedList<Vector3f>();
        List<Vector2f> uvs = new LinkedList<Vector2f>();
        List<Integer> indices = new LinkedList<Integer>();
        QuadMesh quad = new QuadMesh(0, 0, 0, 1, 1);

        //call
        BlockMeshgen.meshifyBox(verts, normals, uvs, indices, quad, 1);


        //error check result
        assertEquals(expectedData.length / 3, normals.size());

        int i = 0;
        for(Vector3f normal : normals){
            assertEquals(expectedData[i + 0], normal.x);
            assertEquals(expectedData[i + 1], normal.y);
            assertEquals(expectedData[i + 2], normal.z);
            i = i + 3;
        }
    }

    @UnitTest
    public void test_meshifyBox_uvs(){
        //expected data
        float[] expectedData = new float[]{
            0, 0,
            1, 0,
            0, 1,
            1, 1,

            0, 0,
            1, 0,
            0, 1,
            1, 1,

            0, 0,
            1, 0,
            0, 1,
            1, 1,

            0, 0,
            1, 0,
            0, 1,
            1, 1,

            0, 0,
            1, 0,
            0, 1,
            1, 1,

            0, 0,
            1, 0,
            0, 1,
            1, 1,
        };

        //setup data
        List<Vector3f> verts = new LinkedList<Vector3f>();
        List<Vector3f> normals = new LinkedList<Vector3f>();
        List<Vector2f> uvs = new LinkedList<Vector2f>();
        List<Integer> indices = new LinkedList<Integer>();
        QuadMesh quad = new QuadMesh(0, 0, 0, 1, 1);

        //call
        BlockMeshgen.meshifyBox(verts, normals, uvs, indices, quad, 1);


        //error check result
        assertEquals(expectedData.length / 2, uvs.size());

        int i = 0;
        for(Vector2f uv : uvs){
            assertEquals(expectedData[i + 0], uv.x);
            assertEquals(expectedData[i + 1], uv.y);
            i = i + 2;
        }
    }

    @UnitTest
    public void test_rasterize_1(){
        //expected data
        float[] expectedData = new float[]{
            0,0,0,
            1,0,0,
            0,1,0,
            1,1,0,

            0,0,0,
            0,0,1,
            0,1,0,
            0,1,1,

            0,0,0,
            0,0,1,
            1,0,0,
            1,0,1,

            0,0,1,
            1,0,1,
            0,1,1,
            1,1,1,

            1,0,0,
            1,0,1,
            1,1,0,
            1,1,1,

            0,1,0,
            0,1,1,
            1,1,0,
            1,1,1,
        };
        for(int i = 0; i < expectedData.length; i++){
            expectedData[i] = expectedData[i] * BlockChunkData.BLOCK_SIZE_MULTIPLIER;
        }

        //setup data
        BlockChunkData chunkData = new BlockChunkData();
        short[] types = new short[BlockChunkData.CHUNK_DATA_WIDTH * BlockChunkData.CHUNK_DATA_WIDTH * BlockChunkData.CHUNK_DATA_WIDTH];
        chunkData.setType(types);
        chunkData.setType(0, 0, 0, (short)1);

        //call
        BlockMeshData meshData = BlockMeshgen.rasterize(chunkData);


        //error check result
        assertEquals(expectedData.length, meshData.vertices.length);

        for(int i = 0; i < expectedData.length; i++){
            assertEquals(expectedData[i], meshData.vertices[i]);
        }
    }

    @UnitTest
    public void test_rasterize_2(){
        //expected data
        float[] expectedData = new float[]{
            0,0,0,
            1,0,0,
            0,2,0,
            1,2,0,

            0,0,0,
            0,0,1,
            0,2,0,
            0,2,1,

            0,0,0,
            0,0,1,
            1,0,0,
            1,0,1,

            0,0,1,
            1,0,1,
            0,2,1,
            1,2,1,

            1,0,0,
            1,0,1,
            1,2,0,
            1,2,1,

            0,2,0,
            0,2,1,
            1,2,0,
            1,2,1,
        };
        for(int i = 0; i < expectedData.length; i++){
            expectedData[i] = expectedData[i] * BlockChunkData.BLOCK_SIZE_MULTIPLIER;
        }

        //setup data
        BlockChunkData chunkData = new BlockChunkData();
        short[] types = new short[BlockChunkData.CHUNK_DATA_WIDTH * BlockChunkData.CHUNK_DATA_WIDTH * BlockChunkData.CHUNK_DATA_WIDTH];
        chunkData.setType(types);
        chunkData.setType(0, 0, 0, (short)1);
        chunkData.setType(0, 1, 0, (short)1);

        //call
        BlockMeshData meshData = BlockMeshgen.rasterize(chunkData);


        //error check result
        assertEquals(expectedData.length, meshData.vertices.length);

        for(int i = 0; i < expectedData.length; i++){
            assertEquals(expectedData[i], meshData.vertices[i]);
        }
    }

    @UnitTest
    public void test_rasterize_3(){
        //expected data
        float[] expectedData = new float[]{
            0,0,0,
            2,0,0,
            0,2,0,
            2,2,0,

            0,0,0,
            0,0,1,
            0,2,0,
            0,2,1,

            0,0,0,
            0,0,1,
            2,0,0,
            2,0,1,

            0,0,1,
            2,0,1,
            0,2,1,
            2,2,1,

            2,0,0,
            2,0,1,
            2,2,0,
            2,2,1,

            0,2,0,
            0,2,1,
            2,2,0,
            2,2,1,
        };
        for(int i = 0; i < expectedData.length; i++){
            expectedData[i] = expectedData[i] * BlockChunkData.BLOCK_SIZE_MULTIPLIER;
        }

        //setup data
        BlockChunkData chunkData = new BlockChunkData();
        short[] types = new short[BlockChunkData.CHUNK_DATA_WIDTH * BlockChunkData.CHUNK_DATA_WIDTH * BlockChunkData.CHUNK_DATA_WIDTH];
        chunkData.setType(types);
        chunkData.setType(0, 0, 0, (short)1);
        chunkData.setType(0, 1, 0, (short)1);
        chunkData.setType(1, 0, 0, (short)1);
        chunkData.setType(1, 1, 0, (short)1);

        //call
        BlockMeshData meshData = BlockMeshgen.rasterize(chunkData);


        //error check result
        assertEquals(expectedData.length, meshData.vertices.length);

        for(int i = 0; i < expectedData.length; i++){
            assertEquals(expectedData[i], meshData.vertices[i]);
        }
    }

    @UnitTest
    public void test_rasterize_4(){
        //expected data
        float[] expectedData = new float[]{
            0,0,0,
            2,0,0,
            0,2,0,
            2,2,0,

            0,0,0,
            0,0,2,
            0,2,0,
            0,2,2,

            0,0,0,
            0,0,2,
            2,0,0,
            2,0,2,

            0,0,2,
            2,0,2,
            0,2,2,
            2,2,2,

            2,0,0,
            2,0,2,
            2,2,0,
            2,2,2,

            0,2,0,
            0,2,2,
            2,2,0,
            2,2,2,
        };
        for(int i = 0; i < expectedData.length; i++){
            expectedData[i] = expectedData[i] * BlockChunkData.BLOCK_SIZE_MULTIPLIER;
        }

        //setup data
        BlockChunkData chunkData = new BlockChunkData();
        short[] types = new short[BlockChunkData.CHUNK_DATA_WIDTH * BlockChunkData.CHUNK_DATA_WIDTH * BlockChunkData.CHUNK_DATA_WIDTH];
        chunkData.setType(types);
        chunkData.setType(0, 0, 0, (short)1);
        chunkData.setType(0, 1, 0, (short)1);
        chunkData.setType(1, 0, 0, (short)1);
        chunkData.setType(1, 1, 0, (short)1);
        chunkData.setType(0, 0, 1, (short)1);
        chunkData.setType(0, 1, 1, (short)1);
        chunkData.setType(1, 0, 1, (short)1);
        chunkData.setType(1, 1, 1, (short)1);

        //call
        BlockMeshData meshData = BlockMeshgen.rasterize(chunkData);


        //error check result
        assertEquals(expectedData.length, meshData.vertices.length);

        for(int i = 0; i < expectedData.length; i++){
            assertEquals(expectedData[i], meshData.vertices[i]);
        }
    }

    @UnitTest
    public void test_rasterize_5(){
        //expected data
        float[] expectedData = new float[]{
            //block 1
            0,0,0,
            1,0,0,
            0,1,0,
            1,1,0,

            0,0,0,
            0,0,1,
            0,1,0,
            0,1,1,

            0,0,0,
            0,0,1,
            1,0,0,
            1,0,1,

            0,0,1,
            1,0,1,
            0,1,1,
            1,1,1,

            1,0,0,
            1,0,1,
            1,1,0,
            1,1,1,

            0,1,0,
            0,1,1,
            1,1,0,
            1,1,1,
            
            //block 2
            0,2,0,
            1,2,0,
            0,3,0,
            1,3,0,

            0,2,0,
            0,2,1,
            0,3,0,
            0,3,1,

            0,2,0,
            0,2,1,
            1,2,0,
            1,2,1,

            0,2,1,
            1,2,1,
            0,3,1,
            1,3,1,

            1,2,0,
            1,2,1,
            1,3,0,
            1,3,1,

            0,3,0,
            0,3,1,
            1,3,0,
            1,3,1,
        };
        for(int i = 0; i < expectedData.length; i++){
            expectedData[i] = expectedData[i] * BlockChunkData.BLOCK_SIZE_MULTIPLIER;
        }

        //setup data
        BlockChunkData chunkData = new BlockChunkData();
        short[] types = new short[BlockChunkData.CHUNK_DATA_WIDTH * BlockChunkData.CHUNK_DATA_WIDTH * BlockChunkData.CHUNK_DATA_WIDTH];
        chunkData.setType(types);
        //block 1
        chunkData.setType(0, 0, 0, (short)1);

        //block 2
        chunkData.setType(0, 2, 0, (short)1);

        //call
        BlockMeshData meshData = BlockMeshgen.rasterize(chunkData);


        //error check result
        assertEquals(expectedData.length, meshData.vertices.length);

        for(int i = 0; i < expectedData.length; i++){
            assertEquals(expectedData[i], meshData.vertices[i]);
        }
    }

    @UnitTest
    public void test_rasterize_6(){
        //expected data
        float[] expectedData = new float[]{
            //block 1
            0,0,0,
            1,0,0,
            0,1,0,
            1,1,0,

            0,0,0,
            0,0,1,
            0,1,0,
            0,1,1,

            0,0,0,
            0,0,1,
            1,0,0,
            1,0,1,

            0,0,1,
            1,0,1,
            0,1,1,
            1,1,1,

            1,0,0,
            1,0,1,
            1,1,0,
            1,1,1,

            0,1,0,
            0,1,1,
            1,1,0,
            1,1,1,
            
            //block 2
            0,0,2,
            1,0,2,
            0,1,2,
            1,1,2,

            0,0,2,
            0,0,3,
            0,1,2,
            0,1,3,

            0,0,2,
            0,0,3,
            1,0,2,
            1,0,3,

            0,0,3,
            1,0,3,
            0,1,3,
            1,1,3,

            1,0,2,
            1,0,3,
            1,1,2,
            1,1,3,

            0,1,2,
            0,1,3,
            1,1,2,
            1,1,3,
        };
        for(int i = 0; i < expectedData.length; i++){
            expectedData[i] = expectedData[i] * BlockChunkData.BLOCK_SIZE_MULTIPLIER;
        }

        //setup data
        BlockChunkData chunkData = new BlockChunkData();
        short[] types = new short[BlockChunkData.CHUNK_DATA_WIDTH * BlockChunkData.CHUNK_DATA_WIDTH * BlockChunkData.CHUNK_DATA_WIDTH];
        chunkData.setType(types);
        //block 1
        chunkData.setType(0, 0, 0, (short)1);

        //block 2
        chunkData.setType(0, 0, 2, (short)1);

        //call
        BlockMeshData meshData = BlockMeshgen.rasterize(chunkData);


        //error check result
        assertEquals(expectedData.length, meshData.vertices.length);

        for(int i = 0; i < expectedData.length; i++){
            assertEquals(expectedData[i], meshData.vertices[i]);
        }
    }

    @UnitTest
    public void test_rasterize_7(){
        //expected data
        float[] expectedData = new float[]{
            //block 1
            0,0,0,
            1,0,0,
            0,1,0,
            1,1,0,

            0,0,0,
            0,0,1,
            0,1,0,
            0,1,1,

            0,0,0,
            0,0,1,
            1,0,0,
            1,0,1,

            0,0,1,
            1,0,1,
            0,1,1,
            1,1,1,

            1,0,0,
            1,0,1,
            1,1,0,
            1,1,1,

            0,1,0,
            0,1,1,
            1,1,0,
            1,1,1,
            
            //block 2
            2,0,0,
            3,0,0,
            2,1,0,
            3,1,0,

            2,0,0,
            2,0,1,
            2,1,0,
            2,1,1,

            2,0,0,
            2,0,1,
            3,0,0,
            3,0,1,

            2,0,1,
            3,0,1,
            2,1,1,
            3,1,1,

            3,0,0,
            3,0,1,
            3,1,0,
            3,1,1,

            2,1,0,
            2,1,1,
            3,1,0,
            3,1,1,
        };
        for(int i = 0; i < expectedData.length; i++){
            expectedData[i] = expectedData[i] * BlockChunkData.BLOCK_SIZE_MULTIPLIER;
        }

        //setup data
        BlockChunkData chunkData = new BlockChunkData();
        short[] types = new short[BlockChunkData.CHUNK_DATA_WIDTH * BlockChunkData.CHUNK_DATA_WIDTH * BlockChunkData.CHUNK_DATA_WIDTH];
        chunkData.setType(types);
        //block 1
        chunkData.setType(0, 0, 0, (short)1);

        //block 2
        chunkData.setType(2, 0, 0, (short)1);

        //call
        BlockMeshData meshData = BlockMeshgen.rasterize(chunkData);


        //error check result
        assertEquals(expectedData.length, meshData.vertices.length);

        for(int i = 0; i < expectedData.length; i++){
            assertEquals(expectedData[i], meshData.vertices[i]);
        }
    }

    @UnitTest
    public void test_rasterize_8(){
        //expected data
        float[] expectedData = new float[]{};

        //setup data
        BlockChunkData chunkData = new BlockChunkData();
        short[] types = new short[BlockChunkData.CHUNK_DATA_WIDTH * BlockChunkData.CHUNK_DATA_WIDTH * BlockChunkData.CHUNK_DATA_WIDTH];
        chunkData.setType(types);

        //call
        BlockMeshData meshData = BlockMeshgen.rasterize(chunkData);


        //error check result
        assertEquals(expectedData.length, meshData.vertices.length);

        for(int i = 0; i < expectedData.length; i++){
            assertEquals(expectedData[i], meshData.vertices[i]);
        }
    }

    @UnitTest
    public void test_rasterize_9(){
        //expected data
        float[] expectedData = new float[]{
            //block 1
            0,0,0,
            1,0,0,
            0,2,0,
            1,2,0,

            0,0,0,
            0,0,2,
            0,2,0,
            0,2,2,

            0,0,0,
            0,0,2,
            1,0,0,
            1,0,2,

            0,0,2,
            1,0,2,
            0,2,2,
            1,2,2,

            1,0,0,
            1,0,2,
            1,2,0,
            1,2,2,

            0,2,0,
            0,2,2,
            1,2,0,
            1,2,2,
            
            //block 2
            2,0,0,
            3,0,0,
            2,1,0,
            3,1,0,

            2,0,0,
            2,0,1,
            2,1,0,
            2,1,1,

            2,0,0,
            2,0,1,
            3,0,0,
            3,0,1,

            2,0,1,
            3,0,1,
            2,1,1,
            3,1,1,

            3,0,0,
            3,0,1,
            3,1,0,
            3,1,1,

            2,1,0,
            2,1,1,
            3,1,0,
            3,1,1,
        };
        for(int i = 0; i < expectedData.length; i++){
            expectedData[i] = expectedData[i] * BlockChunkData.BLOCK_SIZE_MULTIPLIER;
        }

        //setup data
        BlockChunkData chunkData = new BlockChunkData();
        short[] types = new short[BlockChunkData.CHUNK_DATA_WIDTH * BlockChunkData.CHUNK_DATA_WIDTH * BlockChunkData.CHUNK_DATA_WIDTH];
        chunkData.setType(types);
        //block 1
        chunkData.setType(0, 0, 0, (short)1);
        chunkData.setType(0, 1, 0, (short)1);
        chunkData.setType(0, 1, 1, (short)1);
        chunkData.setType(0, 0, 1, (short)1);

        //block 2
        chunkData.setType(2, 0, 0, (short)1);

        //call
        BlockMeshData meshData = BlockMeshgen.rasterize(chunkData);


        //error check result
        assertEquals(expectedData.length, meshData.vertices.length);

        for(int i = 0; i < expectedData.length; i++){
            assertEquals(expectedData[i], meshData.vertices[i]);
        }
    }

    @UnitTest
    public void test_rasterize_10(){
        //expected data
        float[] expectedData = new float[]{
            //block 1
            0,0,0,
            1,0,0,
            0,2,0,
            1,2,0,

            0,0,0,
            0,0,2,
            0,2,0,
            0,2,2,

            0,0,0,
            0,0,2,
            1,0,0,
            1,0,2,

            0,0,2,
            1,0,2,
            0,2,2,
            1,2,2,

            1,0,0,
            1,0,2,
            1,2,0,
            1,2,2,

            0,2,0,
            0,2,2,
            1,2,0,
            1,2,2,
            
            //block 2
            1,0,0,
            2,0,0,
            1,1,0,
            2,1,0,

            1,0,0,
            1,0,1,
            1,1,0,
            1,1,1,

            1,0,0,
            1,0,1,
            2,0,0,
            2,0,1,

            1,0,1,
            2,0,1,
            1,1,1,
            2,1,1,

            2,0,0,
            2,0,1,
            2,1,0,
            2,1,1,

            1,1,0,
            1,1,1,
            2,1,0,
            2,1,1,
        };
        for(int i = 0; i < expectedData.length; i++){
            expectedData[i] = expectedData[i] * BlockChunkData.BLOCK_SIZE_MULTIPLIER;
        }

        //setup data
        BlockChunkData chunkData = new BlockChunkData();
        short[] types = new short[BlockChunkData.CHUNK_DATA_WIDTH * BlockChunkData.CHUNK_DATA_WIDTH * BlockChunkData.CHUNK_DATA_WIDTH];
        chunkData.setType(types);
        //block 1
        chunkData.setType(0, 0, 0, (short)1);
        chunkData.setType(0, 1, 0, (short)1);
        chunkData.setType(0, 1, 1, (short)1);
        chunkData.setType(0, 0, 1, (short)1);

        //block 2
        chunkData.setType(1, 0, 0, (short)1);

        //call
        BlockMeshData meshData = BlockMeshgen.rasterize(chunkData);


        //error check result
        assertEquals(expectedData.length, meshData.vertices.length);

        for(int i = 0; i < expectedData.length; i++){
            assertEquals(expectedData[i], meshData.vertices[i]);
        }
    }

}