fix normals for vertices

- now stl output can be porcessed directly by slic3r without intermediate fix wihtin blender - created Wall3dStream instead of keeping all within Wall3d - can save only stl output ( 'Save stl' )
2020-10-11 22:14:10 +02:00
parent 0f1a15916c
commit f07767dcfd
3 changed files with 216 additions and 121 deletions
--- a/java/org/artisanlogiciel/games/stl/Wall3dStream.java
+++ b/java/org/artisanlogiciel/games/stl/Wall3dStream.java
@@ -0,0 +1,102 @@
+package org.artisanlogiciel.games.stl;
+
+import org.artisanlogiciel.games.Brick;
+import org.artisanlogiciel.games.LabyModel;
+
+import java.io.IOException;
+import java.io.OutputStream;
+
+public class Wall3dStream
+{
+
+    public final static Wall3d South = new Wall3d(10, 1, 10, 0, 0, 0);
+    public final static Wall3d West = new Wall3d(1, 10, 10, 0, 0, 0);
+    public final static Wall3d North = new Wall3d(10, 1, 10, 0, 10, 0);
+    public final static Wall3d East = new Wall3d(1, 10, 10, 10, 0, 0);
+    public final static Wall3d HighGround = new Wall3d(10, 10, 3, 0, 0, 0);
+    public final static Wall3d LowGround = new Wall3d(10, 10, 2, 0, 0, 0);
+
+    String name;
+    LabyModel provider;
+    OutputStream stream;
+    boolean reverse;
+
+    /**
+     * reverse : means that resolved path will be HighGround actual making maze more difficult to play with
+     *
+     * @param name
+     * @param provider
+     * @param stream
+     * @param reverse
+     */
+    public Wall3dStream(String name, LabyModel provider, OutputStream stream, boolean reverse)
+    {
+        this.name = name;
+        this.provider = provider;
+        this.stream = stream;
+        this.reverse = reverse;
+    }
+
+    public static void prepare() {
+        System.out.println(South.toString());
+        System.out.println(East.toString());
+        System.out.println(North.toString());
+        System.out.println(West.toString());
+    }
+
+    private void writeWall3D(Wall3d wall3d)
+            throws IOException
+    {
+        stream.write(wall3d.toString().getBytes());
+    }
+
+    public void stream(int xl, int yl, int zl) throws IOException {
+        int width = provider.getWidth();
+        int height = provider.getHeight();
+
+        // WARNING DOWN - UP reversed ( in 2D Y is oriented to lower, in 3D it
+        // is to upper ).
+        stream.write(("solid " + name + "\n").getBytes());
+        for (int x = 0; x < width; x++) {
+            short walls = provider.getWalls(x, 0);
+            if ((walls & Brick.UP) != 0) {
+                writeWall3D(new Wall3d(South, x * xl, 0, 0));
+            }
+            if ((walls & Brick.LEFT) != 0) {
+                writeWall3D(new Wall3d(West, x * xl, 0, 0));
+            }
+        }
+
+        for (int y = 0; y < height; y++) {
+            short walls = provider.getWalls(0, y);
+            if ((walls & Brick.LEFT) != 0) {
+                writeWall3D(new Wall3d(West, 0, y * yl, 0));
+            }
+            for (int x = 0; x < width; x++) {
+                // south and east
+                walls = provider.getWalls(x, y);
+                if ((walls & Brick.DOWN) != 0) {
+                    writeWall3D(new Wall3d(North, x * xl, y * yl, 0));
+                }
+                if ((walls & Brick.RIGHT) != 0) {
+                    writeWall3D(new Wall3d(East, x * xl, y * yl, 0));
+                }
+                short path = provider.getPath(x, y);
+
+                // where resolved path is leaked to stl model.
+                Wall3d ground = reverse ? LowGround : HighGround;
+                if ((path & LabyModel.SOLVED) == LabyModel.SOLVED)
+                //		if ( (walls & ( Brick.GOAL | Brick.ENTRY ) ) == 0 )
+                {
+                    // if ( ( (x+y) % 2) == 0 )
+                    ground = reverse ? HighGround : LowGround;
+                }
+                writeWall3D(new Wall3d(ground, x * xl, y * yl, 0));
+            }
+        }
+
+        stream.write("endsolid wall\n\n".getBytes());
+
+        stream.flush();
+    }
+}