CaptainSpaceCat

3DPMaze - MazeMesh

Jul 18th, 2016
79
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. import java.util.ArrayList;
  2.  
  3. public class MazeMesh {
  4.  
  5.   float[][] vertices;
  6.   int[] triangles;
  7.  
  8.   public MazeMesh(boolean[][][] maze, float cellSizeX, float cellSizeY, float edgeSize) {
  9.     ArrayList<float[]> vert = new ArrayList<float[]>();
  10.     ArrayList<Integer> tri = new ArrayList<Integer>();
  11.    
  12.     for (int y = 0; y <= maze[0].length; y++) {
  13.       for (int x = 0; x <= maze.length; x++) {
  14.         for (int n = 0; n <= 1; n++) {
  15.           vert.add(new float[] {edgeSize*x + cellSizeX*x, edgeSize*y + cellSizeY*y, n});
  16.           vert.add(new float[] {edgeSize*(x+1) + cellSizeX*x, edgeSize*y + cellSizeY*y, n});
  17.           vert.add(new float[] {edgeSize*x + cellSizeX*x, edgeSize*(y+1) + cellSizeY*y, n});
  18.           vert.add(new float[] {edgeSize*(x+1) + cellSizeX*x, edgeSize*(y+1) + cellSizeY*y, n});
  19.           appendQuad(tri, vert.size(), n == 0);
  20.         }
  21.         if (x == 0) {
  22.           for (int i = 0; i <= 1; i++) {
  23.             vert.add(new float[] {edgeSize*x + cellSizeX*x, edgeSize*y + cellSizeY*y, i});
  24.             vert.add(new float[] {edgeSize*x + cellSizeX*x, edgeSize*(y+1) + cellSizeY*y, i});
  25.           }
  26.           appendQuad(tri, vert.size(), true);
  27.         }
  28.         if (y == 0) {
  29.           for (int i = 0; i <= 1; i++) {
  30.             vert.add(new float[] {edgeSize*x + cellSizeX*x, edgeSize*y + cellSizeY*y, i});
  31.             vert.add(new float[] {edgeSize*(x+1) + cellSizeX*x, edgeSize*y + cellSizeY*y, i});
  32.           }
  33.           appendQuad(tri, vert.size(), true);
  34.         }
  35.         if (x == maze.length) {
  36.           for (int i = 0; i <= 1; i++) {
  37.             vert.add(new float[] {edgeSize*(x+1) + cellSizeX*x, edgeSize*y + cellSizeY*y, i});
  38.             vert.add(new float[] {edgeSize*(x+1) + cellSizeX*x, edgeSize*(y+1) + cellSizeY*y, i});
  39.           }
  40.           appendQuad(tri, vert.size(), true);
  41.         }
  42.         if (y == maze[0].length) {
  43.           for (int i = 0; i <= 1; i++) {
  44.             vert.add(new float[] {edgeSize*x + cellSizeX*x, edgeSize*(y+1) + cellSizeY*y, i});
  45.             vert.add(new float[] {edgeSize*(x+1) + cellSizeX*x, edgeSize*(y+1) + cellSizeY*y, i});
  46.           }
  47.           appendQuad(tri, vert.size(), true);
  48.         }
  49.       }
  50.     }
  51.    
  52.     for (int x = 1; x < maze.length; x++) {
  53.       vert.add(new float[] {edgeSize*(x+1) + cellSizeX*x, 0, 1});
  54.       vert.add(new float[] {edgeSize*(x+1) + cellSizeX*(x+1), 0, 1});
  55.       vert.add(new float[] {edgeSize*(x+1) + cellSizeX*x, edgeSize, 1});
  56.       vert.add(new float[] {edgeSize*(x+1) + cellSizeX*(x+1), edgeSize, 1});
  57.       appendQuad(tri, vert.size(), true);
  58.       vert.add(new float[] {edgeSize*(x+1) + cellSizeX*x, edgeSize, 0});
  59.       vert.add(new float[] {edgeSize*(x+1) + cellSizeX*(x+1), edgeSize, 0});
  60.       appendQuad(tri, vert.size(), true);
  61.       vert.add(new float[] {edgeSize*(x+1) + cellSizeX*x, 0, 0});
  62.       vert.add(new float[] {edgeSize*(x+1) + cellSizeX*(x+1), 0, 0});
  63.       appendQuad(tri, vert.size(), false);
  64.       vert.add(new float[] {edgeSize*(x+1) + cellSizeX*x, 0, 1});
  65.       vert.add(new float[] {edgeSize*(x+1) + cellSizeX*(x+1), 0, 1});
  66.       appendQuad(tri, vert.size(), false);
  67.     }
  68.     for (int i = 0; i <= 1; i++) {
  69.       vert.add(new float[] {edgeSize, 0, i});
  70.       vert.add(new float[] {edgeSize, edgeSize, i});
  71.     }
  72.       appendQuad(tri, vert.size(), false);
  73.     for (int i = 0; i <= 1; i++) {
  74.       vert.add(new float[] {edgeSize + cellSizeX, 0, i});
  75.       vert.add(new float[] {edgeSize + cellSizeX, edgeSize, i});
  76.     }
  77.     appendQuad(tri, vert.size(), false);
  78.     for (int y = 0; y < maze[0].length; y++) {
  79.       vert.add(new float[] {0, edgeSize*(y+1) + cellSizeY*y, 1});
  80.       vert.add(new float[] {0, edgeSize*(y+1) + cellSizeY*(y+1), 1});
  81.       vert.add(new float[] {edgeSize, edgeSize*(y+1) + cellSizeY*y, 1});
  82.       vert.add(new float[] {edgeSize, edgeSize*(y+1) + cellSizeY*(y+1), 1});
  83.       appendQuad(tri, vert.size(), true);
  84.       vert.add(new float[] {edgeSize, edgeSize*(y+1) + cellSizeY*y, 0});
  85.       vert.add(new float[] {edgeSize, edgeSize*(y+1) + cellSizeY*(y+1), 0});
  86.       appendQuad(tri, vert.size(), true);
  87.       vert.add(new float[] {0, edgeSize*(y+1) + cellSizeY*y, 0});
  88.       vert.add(new float[] {0, edgeSize*(y+1) + cellSizeY*(y+1), 0});
  89.       appendQuad(tri, vert.size(), false);
  90.       vert.add(new float[] {0, edgeSize*(y+1) + cellSizeY*y, 1});
  91.       vert.add(new float[] {0, edgeSize*(y+1) + cellSizeY*(y+1), 1});
  92.       appendQuad(tri, vert.size(), false);
  93.     }
  94.    
  95.     for (int y = 0; y < maze[0].length; y++) {
  96.       for (int x = 0; x < maze.length; x++) {
  97.         if (maze[x][y][1]) {
  98.           vert.add(new float[] {edgeSize*(x+1) + cellSizeX*(x+1), edgeSize*(y+1) + cellSizeY*y, 1});
  99.           vert.add(new float[] {edgeSize*(x+1) + cellSizeX*(x+1), edgeSize*(y+1) + cellSizeY*(y+1), 1});
  100.           vert.add(new float[] {edgeSize*(x+2) + cellSizeX*(x+1), edgeSize*(y+1) + cellSizeY*y, 1});
  101.           vert.add(new float[] {edgeSize*(x+2) + cellSizeX*(x+1), edgeSize*(y+1) + cellSizeY*(y+1), 1});
  102.           appendQuad(tri, vert.size(), true);
  103.           vert.add(new float[] {edgeSize*(x+2) + cellSizeX*(x+1), edgeSize*(y+1) + cellSizeY*y, 0});
  104.           vert.add(new float[] {edgeSize*(x+2) + cellSizeX*(x+1), edgeSize*(y+1) + cellSizeY*(y+1), 0});
  105.           appendQuad(tri, vert.size(), true);
  106.           vert.add(new float[] {edgeSize*(x+1) + cellSizeX*(x+1), edgeSize*(y+1) + cellSizeY*y, 0});
  107.           vert.add(new float[] {edgeSize*(x+1) + cellSizeX*(x+1), edgeSize*(y+1) + cellSizeY*(y+1), 0});
  108.           appendQuad(tri, vert.size(), false);
  109.           vert.add(new float[] {edgeSize*(x+1) + cellSizeX*(x+1), edgeSize*(y+1) + cellSizeY*y, 1});
  110.           vert.add(new float[] {edgeSize*(x+1) + cellSizeX*(x+1), edgeSize*(y+1) + cellSizeY*(y+1), 1});
  111.           appendQuad(tri, vert.size(), false);
  112.         } else {
  113.           for (int n = 0; n < 2; n++) {
  114.             vert.add(new float[] {edgeSize*(x+1) + cellSizeX*(x+1), edgeSize*(y+1) + cellSizeY*y, n});
  115.             vert.add(new float[] {edgeSize*(x+2) + cellSizeX*(x+1), edgeSize*(y+1) + cellSizeY*y, n});
  116.           }
  117.           appendQuad(tri, vert.size(), true);
  118.           for (int n = 0; n < 2; n++) {
  119.             vert.add(new float[] {edgeSize*(x+1) + cellSizeX*(x+1), edgeSize*(y+1) + cellSizeY*(y+1), n});
  120.             vert.add(new float[] {edgeSize*(x+2) + cellSizeX*(x+1), edgeSize*(y+1) + cellSizeY*(y+1), n});
  121.           }
  122.           appendQuad(tri, vert.size(), true);
  123.         }
  124.         if (maze[x][y][2]) {
  125.           vert.add(new float[] {edgeSize*(x+1) + cellSizeX*x, edgeSize*(y+1) + cellSizeY*(y+1), 1});
  126.           vert.add(new float[] {edgeSize*(x+1) + cellSizeX*(x+1), edgeSize*(y+1) + cellSizeY*(y+1), 1});
  127.           vert.add(new float[] {edgeSize*(x+1) + cellSizeX*x, edgeSize*(y+2) + cellSizeY*(y+1), 1});
  128.           vert.add(new float[] {edgeSize*(x+1) + cellSizeX*(x+1), edgeSize*(y+2) + cellSizeY*(y+1), 1});
  129.           appendQuad(tri, vert.size(), true);
  130.           vert.add(new float[] {edgeSize*(x+1) + cellSizeX*x, edgeSize*(y+2) + cellSizeY*(y+1), 0});
  131.           vert.add(new float[] {edgeSize*(x+1) + cellSizeX*(x+1), edgeSize*(y+2) + cellSizeY*(y+1), 0});
  132.           appendQuad(tri, vert.size(), true);
  133.           vert.add(new float[] {edgeSize*(x+1) + cellSizeX*x, edgeSize*(y+1) + cellSizeY*(y+1), 0});
  134.           vert.add(new float[] {edgeSize*(x+1) + cellSizeX*(x+1), edgeSize*(y+1) + cellSizeY*(y+1), 0});
  135.           appendQuad(tri, vert.size(), false);
  136.           vert.add(new float[] {edgeSize*(x+1) + cellSizeX*x, edgeSize*(y+1) + cellSizeY*(y+1), 1});
  137.           vert.add(new float[] {edgeSize*(x+1) + cellSizeX*(x+1), edgeSize*(y+1) + cellSizeY*(y+1), 1});
  138.           appendQuad(tri, vert.size(), false);
  139.         } else {
  140.           for (int n = 0; n < 2; n++) {
  141.             vert.add(new float[] {edgeSize*(x+1) + cellSizeX*x, edgeSize*(y+1) + cellSizeY*(y+1), n});
  142.             vert.add(new float[] {edgeSize*(x+1) + cellSizeX*x, edgeSize*(y+2) + cellSizeY*(y+1), n});
  143.           }
  144.           appendQuad(tri, vert.size(), true);
  145.           for (int n = 0; n < 2; n++) {
  146.             vert.add(new float[] {edgeSize*(x+1) + cellSizeX*(x+1), edgeSize*(y+1) + cellSizeY*(y+1), n});
  147.             vert.add(new float[] {edgeSize*(x+1) + cellSizeX*(x+1), edgeSize*(y+2) + cellSizeY*(y+1), n});
  148.           }
  149.           appendQuad(tri, vert.size(), true);
  150.         }
  151.       }
  152.     }
  153.    
  154.     float w = edgeSize*(maze.length+1)+cellSizeX*maze.length;
  155.     float h = edgeSize*(maze[0].length+1)+cellSizeY*maze[0].length;
  156.    
  157.     for (int i = 0; i >= -1; i--) {
  158.       vert.add(new float[] {0, 0, i*edgeSize});
  159.       vert.add(new float[] {w, 0, i*edgeSize});
  160.       vert.add(new float[] {0, h, i*edgeSize});
  161.       vert.add(new float[] {w, h, i*edgeSize});
  162.       appendQuad(tri, vert.size(), i == 1);
  163.     }
  164.    
  165.     for (int i = 0; i >= -1; i--) {
  166.       vert.add(new float[] {0, 0, i*edgeSize});
  167.     }
  168.     for (int i = 0; i >= -1; i--) {
  169.       vert.add(new float[] {w, 0, i*edgeSize});
  170.     }
  171.     appendQuad(tri, vert.size(), false);
  172.     for (int i = 0; i >= -1; i--) {
  173.       vert.add(new float[] {w, h, i*edgeSize});
  174.     }
  175.     appendQuad(tri, vert.size(), false);
  176.     for (int i = 0; i >= -1; i--) {
  177.       vert.add(new float[] {0, h, i*edgeSize});
  178.     }
  179.     appendQuad(tri, vert.size(), false);
  180.     for (int i = 0; i >= -1; i--) {
  181.       vert.add(new float[] {0, 0, i*edgeSize});
  182.     }
  183.     appendQuad(tri, vert.size(), false);
  184.    
  185.     triangles = new int[tri.size()];
  186.     for (int i = 0; i < tri.size(); i++) {
  187.       triangles[i] = tri.get(i).intValue();
  188.     }
  189.     vertices = new float[vert.size()][3];
  190.     for (int i = 0; i < vert.size(); i++) {
  191.       for (int n = 0; n < 3; n++) {
  192.         vertices[i][n] = vert.get(i)[n];
  193.       }
  194.     }
  195.    
  196.     flip(maze.length);
  197.     rescale(10, 10, 10);
  198.   }
  199.  
  200.   public String getSTL() {
  201.     String result = "solid s\n";
  202.     for (int i = 0; i < triangles.length; i+=3) {
  203.       result = result + writeFacet(getFacetFromIndex(i));
  204.     }
  205.     result = result + "endsolid s";
  206.     return result;
  207.   }
  208.  
  209.   public String writeFacet(float[][] f) {
  210.     String result = "facet normal 0 0 0\nouter loop\n";
  211.     result = result + "vertex " + f[0][0] + " " + f[0][1] + " " + f[0][2] + "\n";
  212.     result = result + "vertex " + f[1][0] + " " + f[1][1] + " " + f[1][2] + "\n";
  213.     result = result + "vertex " + f[2][0] + " " + f[2][1] + " " + f[2][2] + "\n";
  214.     result = result + "endloop\nendfacet\n";
  215.     return result;
  216.   }
  217.  
  218.   public void rescale(float x, float y, float z) {
  219.     for (float[] v: vertices) {
  220.       v = new float[] {v[0]*x, v[1]*y, v[2]*z};
  221.     }
  222.   }
  223.  
  224.   private void appendQuad(ArrayList<Integer> triangles, int start, boolean normalUp) {
  225.     if (normalUp) {
  226.       triangles.add(new Integer(start-2)); //2
  227.       triangles.add(new Integer(start-3)); //1
  228.       triangles.add(new Integer(start-4)); //0
  229.       triangles.add(new Integer(start-1)); //3
  230.       triangles.add(new Integer(start-3)); //1
  231.       triangles.add(new Integer(start-2)); //2
  232.     } else {
  233.       triangles.add(new Integer(start-4)); //0
  234.       triangles.add(new Integer(start-3)); //1
  235.       triangles.add(new Integer(start-2)); //2
  236.       triangles.add(new Integer(start-2)); //2
  237.       triangles.add(new Integer(start-3)); //1
  238.       triangles.add(new Integer(start-1)); //3
  239.     }
  240.   }
  241.  
  242.   public float[][] getFacetFromIndex(int index) {
  243.     float[][] facet = new float[3][3];
  244.     for (int i = 0; i < 3; i++) {
  245.       for (int n = 0; n < 3; n++) {
  246.         facet[i][n] = vertices[triangles[i+index]][n];
  247.       }
  248.     }
  249.     return facet;
  250.   }
  251.  
  252.   private void flip(int w) {
  253.     for (int i = 0; i < vertices.length; i++) {
  254.       vertices[i][0] = w - vertices[i][0] - 1;
  255.     }
  256.   }
  257.  
  258. }
RAW Paste Data Copied