start new slice / layer / render system

app.js

@@ -262,6 +262,7 @@ const script = {
         "kiri/fill",
         "kiri/db",
         "kiri/slice",
+        "kiri/render",
         // "kiri/slicer",
         "mode/fdm/driver",
         "mode/fdm/client",
@@ -306,6 +307,7 @@ const script = {
         "moto/pack",
         "kiri/fill",
         "kiri/slice",
+        "kiri/render",
         "kiri/slicer",
         "kiri/slicer2",
         "mode/fdm/driver",

src/kiri/codec.js

@@ -94,7 +94,8 @@
             bridges: encode(this.bridges, state),
             flats: encode(this.flats, state),
             solids: encode(this.solids, state),
-            supports: encode(this.supports, state)
+            supports: encode(this.supports, state),
+            render: encode(this.render, state)
         };
     };
 
@@ -108,10 +109,38 @@
         slice.flats = decode(v.flats, state);
         slice.solids = decode(v.solids, state);
         slice.supports = decode(v.supports, state);
+        slice.render = decode(v.render, state)
 
         return slice;
     });
 
+    KIRI.Render.prototype.encode = function(state) {
+        let enc = {
+            type: 'render',
+            layers: Object.keys(this.layers),
+            data: Object.values(this.layers).map(layer => { return {
+                polys: encode(layer.polys, state),
+                lines: encodePointArray(layer.lines, state),
+                faces: encodePointArray(layer.faces, state),
+                color: layer.color
+            } })
+        };
+        return enc;
+    };
+
+    registerDecoder('render', function(v, state) {
+        let render = new KIRI.Render();
+        for (let i=0; i<v.layers.length; i++) {
+            render.layers[v.layers[i]] = {
+                polys: decode(v.data[i].polys, state),
+                lines: decodePointArray(v.data[i].lines),
+                faces: decodePointArray(v.data[i].faces),
+                color: v.data[i].color
+            };
+        }
+        return render;
+    });
+
     KIRI.Top.prototype.encode = function(state) {
         return {
             type: 'top',

src/kiri/render.js

@@ -0,0 +1,50 @@
+/** Copyright Stewart Allen <sa@grid.space> -- All Rights Reserved */
+
+"use strict";
+
+(function() {
+    class Render {
+        constructor() {
+            this.layers = {};
+        }
+
+        setLayer(layer, color) {
+            let layers = this.layers;
+            this.current = layers[layer] = layers[layer] || {
+                lines: [],
+                polys: [],
+                faces: [],
+                color: color || 0
+            };
+            return this;
+        }
+
+        addLine(p1, p2) {
+            this.current.lines.push(p1, p2);
+            return this;
+        }
+
+        addPoly(poly) {
+            this.current.polys.push(poly);
+            // const lines = this.current.lines;
+            // const points = poly.points;
+            // const len = points.length;
+            // for (let i=1; i<len; i++) {
+            //     lines.push(points[i-1], points[i]);
+            // }
+            // if (!poly.open) {
+            //     lines.push(points[len - 1], points[0]);
+            // }
+            return this;
+        }
+
+        addPolys(arr) {
+            for (let i=0; i<arr.length; i++) {
+                this.addPoly(arr[i]);
+            }
+            return this;
+        }
+    }
+
+    self.kiri.Render = Render;
+})();

src/kiri/slice.js

@@ -56,6 +56,7 @@
         this.camMode = null; // CAM mode
         this.layers = null;
         this.finger = null; // cached fingerprint
+        this.render = null; // will replace most of the layer output data
 
         if (view) this.addLayers(view);
     }
@@ -112,6 +113,14 @@
      * Slice Prototype Functions
      ******************************************************************* */
 
+    /**
+     * return Render object for this slice. creates it if necessary.
+     */
+    PRO.output = function() {
+        if (this.render) return this.render;
+        return this.render = new KIRI.Render();
+    };
+
     /**
      * returns a cloned slice the option of a deep clone on the top polys
      */

src/mode/cam/client.js

@@ -26,11 +26,50 @@
         });
     }
 
+    CAM.renderSlice = function(slice) {
+        let group = new THREE.Group();
+        let render = slice.render;
+        let view = slice.view;
+
+        function addPoly(vertices, poly) {
+            const points = poly.points, len = points.length;
+            for (let i=1; i<len; i++) {
+                const p1 = points[i-1], p2 = points[i];
+                vertices.push(new THREE.Vector3(p1.x, p1.y, p1.z));
+                vertices.push(new THREE.Vector3(p2.x, p2.y, p2.z));
+            }
+            if (!poly.open) {
+                const p1 = points[len - 1], p2 = points[0];
+                vertices.push(new THREE.Vector3(p1.x, p1.y, p1.z));
+                vertices.push(new THREE.Vector3(p2.x, p2.y, p2.z));
+            }
+        }
+
+        for (const [layer, data] of Object.entries(render.layers)) {
+            const mat = new THREE.LineBasicMaterial({ color: data.color });
+            const geo = new THREE.Geometry(), vertices = geo.vertices;
+            const polys = data.polys;
+            for (let i=0, il=polys.length; i<il; i++) {
+                addPoly(vertices, polys[i]);
+            }
+            const lines = data.lines;
+            for (let i=0, il=lines.length; i<il; i++) {
+                const p = lines[i];
+                vertices.push(new THREE.Vector3(p.x, p.y, p.z));
+            }
+            group.add(new THREE.LineSegments(geo, mat));
+        }
+
+        slice.view.add(group);
+    };
+
     CAM.sliceRender = function(widget) {
         let slices = widget.slices;
         if (!slices) return;
 
         slices.forEach(function(slice) {
+            if (slice.render) return CAM.renderSlice(slice);
+
             let tops = slice.tops,
                 layers = slice.layers,
                 outline = layers.outline,

src/mode/cam/slice.js

@@ -121,13 +121,10 @@
         let terrain = slicer.slice(tzindex, { each: (data, index, total) => {
             tshadow = POLY.union(tshadow.appendAll(data.tops), 0.01, true);
             tslices.push(data.slice);
-            // let slice = data.slice;
+            // sliceAll.push(data.slice);
-            // slice.z = data.z;
+            // data.slice.output()
-            // slice.index = sliceIndex++;
+            //     .setLayer("debug", 0xff0000)
-            // slice.camMode = PRO.LEVEL;
+            //     .addPolys(POLY.setZ(tshadow.clone(true), data.z));
-            // slice.tops[0].inner = POLY.setZ(tshadow.clone(true), data.z);
-            // sliceAll.push(slice);
-            // onupdate(opSum + (index/total) * opOn[1], opOn[0]);
             updateOp(index, total);
         }, genso: true });
         let shadowTop = terrain[terrain.length - 1];