3DPMaze - MazeMesh

import java.util.ArrayList;

public class MazeMesh {

  float[][] vertices;
  int[] triangles;

  public MazeMesh(boolean[][][] maze, float cellSizeX, float cellSizeY, float edgeSize) {
    ArrayList<float[]> vert = new ArrayList<float[]>();
    ArrayList<Integer> tri = new ArrayList<Integer>();

    for (int y = 0; y <= maze[0].length; y++) {
      for (int x = 0; x <= maze.length; x++) {
        for (int n = 0; n <= 1; n++) {
          vert.add(new float[] {edgeSize*x + cellSizeX*x, edgeSize*y + cellSizeY*y, n});
          vert.add(new float[] {edgeSize*(x+1) + cellSizeX*x, edgeSize*y + cellSizeY*y, n});
          vert.add(new float[] {edgeSize*x + cellSizeX*x, edgeSize*(y+1) + cellSizeY*y, n});
          vert.add(new float[] {edgeSize*(x+1) + cellSizeX*x, edgeSize*(y+1) + cellSizeY*y, n});
          appendQuad(tri, vert.size(), n == 0);
        }
        if (x == 0) {
          for (int i = 0; i <= 1; i++) {
            vert.add(new float[] {edgeSize*x + cellSizeX*x, edgeSize*y + cellSizeY*y, i});
            vert.add(new float[] {edgeSize*x + cellSizeX*x, edgeSize*(y+1) + cellSizeY*y, i});
          }
          appendQuad(tri, vert.size(), true);
        }
        if (y == 0) {
          for (int i = 0; i <= 1; i++) {
            vert.add(new float[] {edgeSize*x + cellSizeX*x, edgeSize*y + cellSizeY*y, i});
            vert.add(new float[] {edgeSize*(x+1) + cellSizeX*x, edgeSize*y + cellSizeY*y, i});
          }
          appendQuad(tri, vert.size(), true);
        }
        if (x == maze.length) {
          for (int i = 0; i <= 1; i++) {
            vert.add(new float[] {edgeSize*(x+1) + cellSizeX*x, edgeSize*y + cellSizeY*y, i});
            vert.add(new float[] {edgeSize*(x+1) + cellSizeX*x, edgeSize*(y+1) + cellSizeY*y, i});
          }
          appendQuad(tri, vert.size(), true);
        }
        if (y == maze[0].length) {
          for (int i = 0; i <= 1; i++) {
            vert.add(new float[] {edgeSize*x + cellSizeX*x, edgeSize*(y+1) + cellSizeY*y, i});
            vert.add(new float[] {edgeSize*(x+1) + cellSizeX*x, edgeSize*(y+1) + cellSizeY*y, i});
          }
          appendQuad(tri, vert.size(), true);
        }
      }
    }

    for (int x = 1; x < maze.length; x++) {
      vert.add(new float[] {edgeSize*(x+1) + cellSizeX*x, 0, 1});
      vert.add(new float[] {edgeSize*(x+1) + cellSizeX*(x+1), 0, 1});
      vert.add(new float[] {edgeSize*(x+1) + cellSizeX*x, edgeSize, 1});
      vert.add(new float[] {edgeSize*(x+1) + cellSizeX*(x+1), edgeSize, 1});
      appendQuad(tri, vert.size(), true);
      vert.add(new float[] {edgeSize*(x+1) + cellSizeX*x, edgeSize, 0});
      vert.add(new float[] {edgeSize*(x+1) + cellSizeX*(x+1), edgeSize, 0});
      appendQuad(tri, vert.size(), true);
      vert.add(new float[] {edgeSize*(x+1) + cellSizeX*x, 0, 0});
      vert.add(new float[] {edgeSize*(x+1) + cellSizeX*(x+1), 0, 0});
      appendQuad(tri, vert.size(), false);
      vert.add(new float[] {edgeSize*(x+1) + cellSizeX*x, 0, 1});
      vert.add(new float[] {edgeSize*(x+1) + cellSizeX*(x+1), 0, 1});
      appendQuad(tri, vert.size(), false);
    }
    for (int i = 0; i <= 1; i++) {
      vert.add(new float[] {edgeSize, 0, i});
      vert.add(new float[] {edgeSize, edgeSize, i});
    }
      appendQuad(tri, vert.size(), false);
    for (int i = 0; i <= 1; i++) {
      vert.add(new float[] {edgeSize + cellSizeX, 0, i});
      vert.add(new float[] {edgeSize + cellSizeX, edgeSize, i});
    }
    appendQuad(tri, vert.size(), false);
    for (int y = 0; y < maze[0].length; y++) {
      vert.add(new float[] {0, edgeSize*(y+1) + cellSizeY*y, 1});
      vert.add(new float[] {0, edgeSize*(y+1) + cellSizeY*(y+1), 1});
      vert.add(new float[] {edgeSize, edgeSize*(y+1) + cellSizeY*y, 1});
      vert.add(new float[] {edgeSize, edgeSize*(y+1) + cellSizeY*(y+1), 1});
      appendQuad(tri, vert.size(), true);
      vert.add(new float[] {edgeSize, edgeSize*(y+1) + cellSizeY*y, 0});
      vert.add(new float[] {edgeSize, edgeSize*(y+1) + cellSizeY*(y+1), 0});
      appendQuad(tri, vert.size(), true);
      vert.add(new float[] {0, edgeSize*(y+1) + cellSizeY*y, 0});
      vert.add(new float[] {0, edgeSize*(y+1) + cellSizeY*(y+1), 0});
      appendQuad(tri, vert.size(), false);
      vert.add(new float[] {0, edgeSize*(y+1) + cellSizeY*y, 1});
      vert.add(new float[] {0, edgeSize*(y+1) + cellSizeY*(y+1), 1});
      appendQuad(tri, vert.size(), false);
    }

    for (int y = 0; y < maze[0].length; y++) {
      for (int x = 0; x < maze.length; x++) {
        if (maze[x][y][1]) {
          vert.add(new float[] {edgeSize*(x+1) + cellSizeX*(x+1), edgeSize*(y+1) + cellSizeY*y, 1});
          vert.add(new float[] {edgeSize*(x+1) + cellSizeX*(x+1), edgeSize*(y+1) + cellSizeY*(y+1), 1});
          vert.add(new float[] {edgeSize*(x+2) + cellSizeX*(x+1), edgeSize*(y+1) + cellSizeY*y, 1});
          vert.add(new float[] {edgeSize*(x+2) + cellSizeX*(x+1), edgeSize*(y+1) + cellSizeY*(y+1), 1});
          appendQuad(tri, vert.size(), true);
          vert.add(new float[] {edgeSize*(x+2) + cellSizeX*(x+1), edgeSize*(y+1) + cellSizeY*y, 0});
          vert.add(new float[] {edgeSize*(x+2) + cellSizeX*(x+1), edgeSize*(y+1) + cellSizeY*(y+1), 0});
          appendQuad(tri, vert.size(), true);
          vert.add(new float[] {edgeSize*(x+1) + cellSizeX*(x+1), edgeSize*(y+1) + cellSizeY*y, 0});
          vert.add(new float[] {edgeSize*(x+1) + cellSizeX*(x+1), edgeSize*(y+1) + cellSizeY*(y+1), 0});
          appendQuad(tri, vert.size(), false);
          vert.add(new float[] {edgeSize*(x+1) + cellSizeX*(x+1), edgeSize*(y+1) + cellSizeY*y, 1});
          vert.add(new float[] {edgeSize*(x+1) + cellSizeX*(x+1), edgeSize*(y+1) + cellSizeY*(y+1), 1});
          appendQuad(tri, vert.size(), false);
        } else {
          for (int n = 0; n < 2; n++) {
            vert.add(new float[] {edgeSize*(x+1) + cellSizeX*(x+1), edgeSize*(y+1) + cellSizeY*y, n});
            vert.add(new float[] {edgeSize*(x+2) + cellSizeX*(x+1), edgeSize*(y+1) + cellSizeY*y, n});
          }
          appendQuad(tri, vert.size(), true);
          for (int n = 0; n < 2; n++) {
            vert.add(new float[] {edgeSize*(x+1) + cellSizeX*(x+1), edgeSize*(y+1) + cellSizeY*(y+1), n});
            vert.add(new float[] {edgeSize*(x+2) + cellSizeX*(x+1), edgeSize*(y+1) + cellSizeY*(y+1), n});
          }
          appendQuad(tri, vert.size(), true);
        }
        if (maze[x][y][2]) {
          vert.add(new float[] {edgeSize*(x+1) + cellSizeX*x, edgeSize*(y+1) + cellSizeY*(y+1), 1});
          vert.add(new float[] {edgeSize*(x+1) + cellSizeX*(x+1), edgeSize*(y+1) + cellSizeY*(y+1), 1});
          vert.add(new float[] {edgeSize*(x+1) + cellSizeX*x, edgeSize*(y+2) + cellSizeY*(y+1), 1});
          vert.add(new float[] {edgeSize*(x+1) + cellSizeX*(x+1), edgeSize*(y+2) + cellSizeY*(y+1), 1});
          appendQuad(tri, vert.size(), true);
          vert.add(new float[] {edgeSize*(x+1) + cellSizeX*x, edgeSize*(y+2) + cellSizeY*(y+1), 0});
          vert.add(new float[] {edgeSize*(x+1) + cellSizeX*(x+1), edgeSize*(y+2) + cellSizeY*(y+1), 0});
          appendQuad(tri, vert.size(), true);
          vert.add(new float[] {edgeSize*(x+1) + cellSizeX*x, edgeSize*(y+1) + cellSizeY*(y+1), 0});
          vert.add(new float[] {edgeSize*(x+1) + cellSizeX*(x+1), edgeSize*(y+1) + cellSizeY*(y+1), 0});
          appendQuad(tri, vert.size(), false);
          vert.add(new float[] {edgeSize*(x+1) + cellSizeX*x, edgeSize*(y+1) + cellSizeY*(y+1), 1});
          vert.add(new float[] {edgeSize*(x+1) + cellSizeX*(x+1), edgeSize*(y+1) + cellSizeY*(y+1), 1});
          appendQuad(tri, vert.size(), false);
        } else {
          for (int n = 0; n < 2; n++) {
            vert.add(new float[] {edgeSize*(x+1) + cellSizeX*x, edgeSize*(y+1) + cellSizeY*(y+1), n});
            vert.add(new float[] {edgeSize*(x+1) + cellSizeX*x, edgeSize*(y+2) + cellSizeY*(y+1), n});
          }
          appendQuad(tri, vert.size(), true);
          for (int n = 0; n < 2; n++) {
            vert.add(new float[] {edgeSize*(x+1) + cellSizeX*(x+1), edgeSize*(y+1) + cellSizeY*(y+1), n});
            vert.add(new float[] {edgeSize*(x+1) + cellSizeX*(x+1), edgeSize*(y+2) + cellSizeY*(y+1), n});
          }
          appendQuad(tri, vert.size(), true);
        }
      }
    }

    float w = edgeSize*(maze.length+1)+cellSizeX*maze.length;
    float h = edgeSize*(maze[0].length+1)+cellSizeY*maze[0].length;

    for (int i = 0; i >= -1; i--) {
      vert.add(new float[] {0, 0, i*edgeSize});
      vert.add(new float[] {w, 0, i*edgeSize});
      vert.add(new float[] {0, h, i*edgeSize});
      vert.add(new float[] {w, h, i*edgeSize});
      appendQuad(tri, vert.size(), i == 1);
    }

    for (int i = 0; i >= -1; i--) {
      vert.add(new float[] {0, 0, i*edgeSize});
    }
    for (int i = 0; i >= -1; i--) {
      vert.add(new float[] {w, 0, i*edgeSize});
    }
    appendQuad(tri, vert.size(), false);
    for (int i = 0; i >= -1; i--) {
      vert.add(new float[] {w, h, i*edgeSize});
    }
    appendQuad(tri, vert.size(), false);
    for (int i = 0; i >= -1; i--) {
      vert.add(new float[] {0, h, i*edgeSize});
    }
    appendQuad(tri, vert.size(), false);
    for (int i = 0; i >= -1; i--) {
      vert.add(new float[] {0, 0, i*edgeSize});
    }
    appendQuad(tri, vert.size(), false);

    triangles = new int[tri.size()];
    for (int i = 0; i < tri.size(); i++) {
      triangles[i] = tri.get(i).intValue();
    }
    vertices = new float[vert.size()][3];
    for (int i = 0; i < vert.size(); i++) {
      for (int n = 0; n < 3; n++) {
        vertices[i][n] = vert.get(i)[n];
      }
    }

    flip(maze.length);
    rescale(10, 10, 10);
  }

  public String getSTL() {
    String result = "solid s\n";
    for (int i = 0; i < triangles.length; i+=3) {
      result = result + writeFacet(getFacetFromIndex(i));
    }
    result = result + "endsolid s";
    return result;
  }

  public String writeFacet(float[][] f) {
    String result = "facet normal 0 0 0\nouter loop\n";
    result = result + "vertex " + f[0][0] + " " + f[0][1] + " " + f[0][2] + "\n";
    result = result + "vertex " + f[1][0] + " " + f[1][1] + " " + f[1][2] + "\n";
    result = result + "vertex " + f[2][0] + " " + f[2][1] + " " + f[2][2] + "\n";
    result = result + "endloop\nendfacet\n";
    return result;
  }

  public void rescale(float x, float y, float z) {
    for (float[] v: vertices) {
      v = new float[] {v[0]*x, v[1]*y, v[2]*z};
    }
  }

  private void appendQuad(ArrayList<Integer> triangles, int start, boolean normalUp) {
    if (normalUp) {
      triangles.add(new Integer(start-2)); //2
      triangles.add(new Integer(start-3)); //1
      triangles.add(new Integer(start-4)); //0
      triangles.add(new Integer(start-1)); //3
      triangles.add(new Integer(start-3)); //1
      triangles.add(new Integer(start-2)); //2
    } else {
      triangles.add(new Integer(start-4)); //0
      triangles.add(new Integer(start-3)); //1
      triangles.add(new Integer(start-2)); //2
      triangles.add(new Integer(start-2)); //2
      triangles.add(new Integer(start-3)); //1
      triangles.add(new Integer(start-1)); //3
    }
  }

  public float[][] getFacetFromIndex(int index) {
    float[][] facet = new float[3][3];
    for (int i = 0; i < 3; i++) {
      for (int n = 0; n < 3; n++) {
        facet[i][n] = vertices[triangles[i+index]][n];
      }
    }
    return facet;
  }

  private void flip(int w) {
    for (int i = 0; i < vertices.length; i++) {
      vertices[i][0] = w - vertices[i][0] - 1;
    }
  }

}