From 4ca0a26af54401eb10fb965c35f6ba4b597ae1cd Mon Sep 17 00:00:00 2001
From: Stewart Allen <stewart.allen@gmail.com>
Date: Fri, 6 Nov 2020 21:43:28 -0500
Subject: [PATCH] start new slice / layer / render system

---
 app.js                 |  2 ++
 src/kiri/codec.js      | 31 +++++++++++++++++++++++++-
 src/kiri/render.js     | 50 ++++++++++++++++++++++++++++++++++++++++++
 src/kiri/slice.js      |  9 ++++++++
 src/mode/cam/client.js | 39 ++++++++++++++++++++++++++++++++
 src/mode/cam/slice.js  | 11 ++++------
 6 files changed, 134 insertions(+), 8 deletions(-)
 create mode 100644 src/kiri/render.js

diff --git a/app.js b/app.js
index b83c1e4d..f65154b4 100644
--- a/app.js
+++ b/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",
diff --git a/src/kiri/codec.js b/src/kiri/codec.js
index 1b2bcbc1..e69214d6 100644
--- a/src/kiri/codec.js
+++ b/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',
diff --git a/src/kiri/render.js b/src/kiri/render.js
new file mode 100644
index 00000000..ed9a5ee5
--- /dev/null
+++ b/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;
+})();
diff --git a/src/kiri/slice.js b/src/kiri/slice.js
index f4233480..88aeb972 100644
--- a/src/kiri/slice.js
+++ b/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
      */
diff --git a/src/mode/cam/client.js b/src/mode/cam/client.js
index 58677e25..db617d89 100644
--- a/src/mode/cam/client.js
+++ b/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,
diff --git a/src/mode/cam/slice.js b/src/mode/cam/slice.js
index 7ac5cd96..538ddbb3 100644
--- a/src/mode/cam/slice.js
+++ b/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;
-            // slice.z = data.z;
-            // slice.index = sliceIndex++;
-            // slice.camMode = PRO.LEVEL;
-            // slice.tops[0].inner = POLY.setZ(tshadow.clone(true), data.z);
-            // sliceAll.push(slice);
-            // onupdate(opSum + (index/total) * opOn[1], opOn[0]);
+            // sliceAll.push(data.slice);
+            // data.slice.output()
+            //     .setLayer("debug", 0xff0000)
+            //     .addPolys(POLY.setZ(tshadow.clone(true), data.z));
             updateOp(index, total);
         }, genso: true });
         let shadowTop = terrain[terrain.length - 1];