public Mesh getFromSurfaceNet(List<double[]> vertices, List<int[]> indexes) {
        int[] meshIndexes;
        Vector3f [] meshVertices = new Vector3f[vertices.size() * 4];
        Vector2f[] meshTexCoords = new Vector2f[vertices.size() * 4];


        //Pre calculate the index and vertice buffer size:
        int indexBufferSize = 0;

        Iterator<int[]> countIndexes = indexes.iterator();
        while (countIndexes.hasNext()) {
            int[] array = countIndexes.next();
            for (int i = 0; i < array.length; i++) {
                indexBufferSize++;
            }
        }

        meshIndexes = new int[indexBufferSize];

        //Process vertices
        Iterator<double[]> vertIter = vertices.iterator();
        int verticeCount = 0;

        while (vertIter.hasNext()) {
            double[] verticeQuadlet = vertIter.next();
            for (int i = 0; i < verticeQuadlet.length; i++) {
                if ((verticeQuadlet.length - 3) > -1) {
                    Vector3f vec = new Vector3f((float)verticeQuadlet[i], (float)verticeQuadlet[i+1], (float)verticeQuadlet[+2]);
                    meshVertices[verticeCount] = vec;
                    i++; //Skip the next two floats, we have buffered them in vec.
                    i++;
                    verticeCount++;
                }
            }

        }

        //Check work:
        for (int i = 0; i < meshVertices.length; i++) {
            //log("Vertice: " + meshVertices[i].toString());
        }
        //End check

        log("Before index unpack");
        //Process indexes
        Iterator<int[]> indexIter = indexes.iterator();

        int indexCount = 0;
        while (indexIter.hasNext()) {
            int[] temp = indexIter.next();
            for (int i = 0; i < temp.length; i++) {
                if (temp[i] == 0) {
                    log("ZERO ALERT ############################################");
                }
                meshIndexes[indexCount + i] = temp[i];
            }

            indexCount++;
        }

        //I currently trim this later as I get 5 times as many 0 entries as real ones print out at this point.
        //it doesn't seem to affect the rendering at all though when they are trimmed
        //Check work:
        for (int i = 0; i < meshIndexes.length; i++) {
            //log("Index @ : " + i + " || " + meshIndexes[i]);
        }
        //End check


        //Add texture coords:
        int count = 0;
        for (int i = 0; i < meshTexCoords.length; i++) {

            switch (count) {
                case 0:
                    meshTexCoords[i] = new Vector2f(0,0);
                    break;

                case 1:
                    meshTexCoords[i] = new Vector2f(1, 0);
                    break;

                case 2:
                    meshTexCoords[i] = new Vector2f(0, 1);
                    break;

                case 3:
                    meshTexCoords[i] = new Vector2f(1, 1);
                    break;
            }
            //log("COUNT: " + count);
            count = count + 1;

            if (count == 3) {
                count = 0;
            }
        }
        //Check work:
        for (Vector2f meshTexCoord : meshTexCoords) {
            //log("Tex Coords: " + meshTexCoord);
        }
        //End check

        log("Culling indexes:");
        log("Current meshIndexes length: " + meshIndexes.length);
        int goodCount = 0;
        for (int i = 0; i < meshIndexes.length; i++) {
            if (meshIndexes[i] != 0) {
                goodCount++;
            }
        }

        int[] goodIndexes = new int[goodCount];
        int goodTicker = 0;
        for (int i = 0; i < meshIndexes.length; i++) {
            if (meshIndexes[i] != 0) {
                goodIndexes[goodTicker] = meshIndexes[i];
                goodTicker++;
            }
        }
        log("trimmed meshIndexes to goodIndexes, length: " + goodIndexes.length);

        Mesh mesh = new Mesh();

        mesh.setBuffer(Type.Position, 3, BufferUtils.createFloatBuffer(meshVertices));
        mesh.setBuffer(Type.TexCoord, 2, BufferUtils.createFloatBuffer(meshTexCoords));
        mesh.setBuffer(Type.Index,    3, BufferUtils.createIntBuffer(goodIndexes));
        mesh.updateBound();


        return mesh;

    }