add new fdm-driver slice rendering

src/geo/polygons.js

@@ -28,6 +28,7 @@
         trimTo : trimTo,
         expand2 : expand2,
         expand : expand,
+        expand_lines: expand_lines,
         union : union,
         nest : nest,
         diff : doDiff,
@@ -407,6 +408,27 @@
         return sum;
     }
 
+    /**
+     * @param {Polygon[]} polys
+     * @param {number} distance offset
+     * @param {number} [z] defaults to 0
+     */
+    function expand_lines(poly, distance, z) {
+        let fact = CONF.clipper,
+            clib = self.ClipperLib,
+            clip = clib.Clipper,
+            cpft = clib.PolyFillType,
+            cjnt = clib.JoinType,
+            cety = clib.EndType,
+            coff = new clib.ClipperOffset(),
+            ctre = new clib.PolyTree();
+
+        coff.AddPaths(poly.toClipper(), cjnt.jtMiter, cety.etOpenSquare);
+        coff.Execute(ctre, distance * fact);
+
+        return fromClipperTree(ctre, z, null, null, 0);
+    }
+
     /**
      * @param {Polygon[]} polys
      * @param {number} distance offset

src/kiri/init.js

@@ -1409,18 +1409,18 @@
             ]),
 
             layers:        UC.setGroup($("layers")),
-            layerOutline:  UC.newBoolean(LANG.la_olin, onLayerToggle, {modes:ALL}),
             layerTrace:    UC.newBoolean(LANG.la_trce, onLayerToggle, {modes:FDM_LASER}),
             layerFacing:   UC.newBoolean(LANG.la_face, onLayerToggle, {modes:[]}), // see sliceRender() in CAM
             layerRough:    UC.newBoolean(LANG.la_ruff, onLayerToggle, {modes:CAM}),
             layerFinish:   UC.newBoolean(LANG.la_fini, onLayerToggle, {modes:CAM}),
             layerFinishX:  UC.newBoolean(LANG.la_finx, onLayerToggle, {modes:CAM}),
             layerFinishY:  UC.newBoolean(LANG.la_finy, onLayerToggle, {modes:CAM}),
-            layerDelta:    UC.newBoolean(LANG.la_dlta, onLayerToggle, {modes:FDM_SLA}),
-            layerSolid:    UC.newBoolean(LANG.la_slds, onLayerToggle, {modes:FDM_SLA}),
             layerFill:     UC.newBoolean(LANG.la_fill, onLayerToggle, {modes:FDM}),
             layerSparse:   UC.newBoolean(LANG.la_sprs, onLayerToggle, {modes:FDM}),
             layerSupport:  UC.newBoolean(LANG.la_sprt, onLayerToggle, {modes:FDM_SLA}),
+            layerOutline:  UC.newBoolean(LANG.la_olin, onLayerToggle, {modes:ALL}),
+            layerDelta:    UC.newBoolean(LANG.la_dlta, onLayerToggle, {modes:FDM_SLA}),
+            layerSolid:    UC.newBoolean(LANG.la_slds, onLayerToggle, {modes:FDM_SLA}),
             layerPrint:    UC.newBoolean(LANG.la_prnt, onLayerToggle),
             layerMoves:    UC.newBoolean(LANG.la_move, onLayerToggle, {modes:GCODE})
         });

src/kiri/layer.js

@@ -132,6 +132,7 @@
     };
 
     LP.noodle = function(poly, offset, color, traceColor, open) {
+        if (!poly) return;
         if (Array.isArray(poly)) {
             poly = POLY.flatten(poly, [], true);
         } else {
@@ -152,6 +153,32 @@
         this.changed = true;
     };
 
+    LP.noodle_open = function(poly, offset, color, traceColor, z) {
+        poly = POLY.expand_lines(poly, offset, z);
+        poly.forEach(p => {
+            this.add(color, {solid: p});
+            p = p.setZ(z + 0.01);
+            this.add(traceColor, {poly: p, deep: false, open: true});
+        })
+        this.changed = true;
+    };
+
+    LP.noodle_lines = function(points, offset, color, traceColor, z) {
+        if (!(points && points.length)) return;
+        for (let i=0; i<points.length; i += 2) {
+            let p1 = points[i];
+            let p2 = points[i+1];
+            let l1 = p1.offsetLineTo(p2, offset);
+            let l2 = p2.offsetLineTo(p1, offset);
+            let poly = base.newPolygon().addPoints([
+                l1.p1, l1.p2, l2.p1, l2.p2
+            ]).setZ(z + 0.01);
+            this.add(color, {solid: poly});
+            this.add(traceColor, {poly: poly, deep: false, open: true});
+        }
+        this.changed = true;
+    };
+
     LP.points = function(points, color, size, opacity) {
         let layer = this,
             sz = size/2;

src/kiri/widget.js

@@ -722,7 +722,7 @@
             driver = DRIVERS[settings.mode.toUpperCase()];
 
         // allow driver to override widget slice rendering (new in SLA)
-        if (driver.sliceRender) return driver.sliceRender(this);
+        if (driver.sliceRender) return driver.sliceRender(this, renderMode);
 
         let extruder = this.getExtruder(settings);
         // render outline

src/mode/fdm/driver.js

@@ -15,8 +15,11 @@
         POLY = BASE.polygons,
         FDM = KIRI.driver.FDM = {
             slice,
+            sliceRender,
             printSetup,
-            printExport
+            printExport,
+            // printDownload,
+            // printRender
         },
         SLICER = KIRI.slicer,
         newPoint = BASE.newPoint;
@@ -386,6 +389,118 @@
 
     };
 
+    /**
+     * DRIVER SLICE RENDER CONTRACT
+     *
+     * @param {Object} widget to render
+     * @param {number} mode to use to select colors
+     */
+    function sliceRender(widget, mode) {
+        let slices = widget.slices;
+        let settings = widget.settings;
+        let extruder = widget.getExtruder(settings);
+
+        if (!slices) return;
+
+        // render outline
+        slices.forEach(function(s) {
+            let layers = s.layers;
+            let tops = s.tops;
+            let outline = layers.outline;
+            let shells = layers.trace;
+            let solids = layers.fill;
+            let sparse = layers.sparse;
+            let support = layers.support;
+            let outsolid = layers.solid;
+            let outbridge = layers.bridge;
+            let outflat = layers.flat;
+
+            outline.clear();
+            shells.clear();
+            solids.clear();
+            sparse.clear();
+            support.clear();
+            outsolid.clear();
+            outbridge.clear();
+            outflat.clear();
+
+            outline.setTransparent(true);
+            shells.setTransparent(false);
+            solids.setTransparent(false);
+            sparse.setTransparent(false);
+            support.setTransparent(false);
+            outsolid.setTransparent(true);
+            outbridge.setTransparent(true);
+            outflat.setTransparent(true);
+
+            tops.forEach(function(top) {
+                // outline
+                outline.poly(top.poly, 0xdddddd, true, false);
+                outline.solid(top.poly, 0xcccccc);
+                if (top.inner) outline.poly(top.inner, 0xdddddd, true);
+                // if (top.thinner) outline.poly(top.thinner, 0x559999, true, null);
+
+                // shells
+                shells.noodle(top.traces, 0.2, 0x88aadd, 0x77bbcc);
+                if (top.polish) {
+                    shells.poly(top.polish.x, 0x880000, true, null);
+                    shells.poly(top.polish.y, 0x880000, true, null);
+                }
+
+                // solid fill
+                solids.noodle_lines(top.fill_lines, 0.2, 0x88aadd, 0x77bbcc, s.z);
+
+                // sparse fill
+                if (top.fill_sparse) {
+                    top.fill_sparse.forEach(function(poly) {
+                        // todo cull polys with single point before this
+                        sparse.noodle_open(poly, 0.2, 0x88aadd, 0x77bbcc, s.z);
+                        // poly.render(sparse, 0x0, false, true);
+                    });
+                }
+
+                // support
+                if (s.supports) {
+                    support.noodle(s.supports, 0.2, 0x88aadd, 0x77bbcc);
+                    s.supports.forEach(function(poly) {
+                        support.noodle_lines(poly.fills, 0.2, 0x88aadd, 0x77bbcc, s.z);
+                    });
+                }
+            });
+
+            // solid outlines
+            let trimmed = s.solids.trimmed;
+            if (trimmed) trimmed.forEach(function(poly) {
+                poly.setZ(s.z + 0.025);
+                outsolid.poly(poly, 0x00cc00, true, false);
+                outsolid.solid(poly, 0x00dd00);
+            });
+
+            // diff bridges
+            if (s.bridges) s.bridges.forEach(function (poly) {
+                poly.setZ(s.z + 0.05);
+                outbridge.poly(poly, 0x0099ee, true, false);
+                outbridge.solid(poly, 0x00aaff);
+            });
+
+            // diff flats
+            if (s.flats) s.flats.forEach(function (poly) {
+                poly.setZ(s.z + 0.05);
+                outflat.poly(poly, 0xee0099, true, false);
+                outflat.solid(poly, 0xff00aa);
+            });
+
+            outline.renderAll();
+            shells.renderAll();
+            solids.renderAll();
+            sparse.renderAll();
+            support.renderAll();
+            outsolid.renderAll();
+            outbridge.renderAll();
+            outflat.renderAll();
+        });
+    }
+
     /**
      * DRIVER PRINT CONTRACT
      *

web/kiri/lang/en.js

@@ -135,7 +135,7 @@ kiri.lang['en-us'] = {
     // LAYERS pop-menu
     la_menu:        "layers",
     la_olin:        "outline",
-    la_trce:        "trace",
+    la_trce:        "shells",
     la_face:        "facing",
     la_ruff:        "roughing",
     la_fini:        "finishing",
@@ -144,8 +144,8 @@ kiri.lang['en-us'] = {
     la_dlta:        "delta",
     la_slds:        "solids",
     la_fill:        "solid fill",
-    la_sprs:        "sparse",
+    la_sprs:        "infill",
-    la_sprt:        "support",
+    la_sprt:        "supports",
     la_prnt:        "print",
     la_move:        "moves",