checkpoint range work

src/kiri/init.js

@@ -1840,6 +1840,9 @@
             slaFirstOffset:      UC.newInput(LANG.sa_opzo_s, {title:LANG.sa_opzo_l, convert:UC.toFloat, bound:UC.bound(0,1), modes:SLA}),
             slaAntiAlias:        UC.newSelect(LANG.sa_opaa_s, {title:LANG.sa_opaa_l, modes:SLA}, "antialias"),
 
+            rangeGroup:    UC.newGroup("ranges", null, {modes:FDM, group:"ranges"}),
+            rangeList:     UC.newRow([], {}),
+
             settingsGroup: UC.newGroup(LANG.se_menu, $('settings')),
             settingsTable: UC.newRow([ UI.settingsLoad = UC.newButton(LANG.se_load, settingsLoad) ]),
             settingsTable: UC.newRow([ UI.settingsSave = UC.newButton(LANG.se_save, settingsSave) ]),
@@ -1851,9 +1854,6 @@
             return settings().device.spindleMax > 0;
         }
 
-        // FDM region override setup
-        UI.sliceFillSparse.region = true;
-
         // slider setup
         const slbar = 30;
         const slbar2 = slbar * 2;

src/kiri/main.js

@@ -681,8 +681,10 @@
         return ranges;
     }
 
-    function updateRange(lo, hi, values) {
+    // set process override values for a range
+    function updateRange(lo, hi, values, noadd) {
         let exact;
+        let empty = [];
         // remove matching values from overlapping ranges
         for (let range of getOverlappingRanges(lo, hi)) {
             if (range.lo === lo && range.hi === hi) {
@@ -691,22 +693,46 @@
             for (let key of Object.keys(values)) {
                 delete range.fields[key];
             }
+            if (Object.keys(range.fields).length === 0) {
+                empty.push(range);
+            }
+        }
+        let ranges = settings.process.ranges;
+        // clear out empty ranges
+        if (empty.length) {
+            for (let range of empty) {
+                let pos = ranges.indexOf(range);
+                if (pos >= 0) {
+                    ranges.splice(pos,1);
+                }
+            }
+        }
+        // noadd flag present when range is 0-max
+        if (noadd) {
+            API.event.emit("range.updates", ranges);
+            return;
         }
         // add values to matched range or new range
         if (!exact) {
             exact = { lo, hi, fields: {} };
-            settings.process.ranges.push(exact);
+            ranges.push(exact);
         }
         for (let key of Object.keys(values)) {
             exact.fields[key] = values[key];
         }
+        API.event.emit("range.updates", ranges);
     }
 
     let overrides = {};
 
-    // updates that are region (slice range) dependent
+    // updates editable fields that are range dependent
     function updateFieldsFromRange() {
         if (settings.mode !== 'FDM' || viewMode !== VIEWS.SLICE || !settings.process.ranges) {
+            let okeys = Object.keys(overrides);
+            if (okeys.length) {
+                updateFieldsFromSettings(overrides);
+                overrides = {};
+            }
             return;
         }
         let match = 0;
@@ -731,6 +757,7 @@
                 delete overrides[key];
             }
         }
+        UC.refresh();
     }
 
     function updateSlider() {
@@ -2074,18 +2101,20 @@
             return;
         }
         updateSettingsFromFields(device);
+        // range-specific values
         if (settings.mode === 'FDM' && viewMode === VIEWS.SLICE) {
             let changes = {};
             let values = process;
             let { layer_lo, layer_hi, layer_max } = API.var;
-            let range;
+            let range = { lo: layer_lo, hi: layer_hi };
+            let add = false;
             if (layer_lo > 0 || layer_hi < layer_max) {
                 values = Object.clone(process);
-                range = { lo: layer_lo, hi: layer_hi };
+                add = true;
             }
             updateSettingsFromFields(values, undefined, changes);
             if (range) {
-                updateRange(range.lo, range.hi, changes);
+                updateRange(range.lo, range.hi, changes, !add);
             }
         } else {
             updateSettingsFromFields(process);

src/mode/fdm/client.js

@@ -8,18 +8,31 @@
         BASE = self.base,
         UTIL = BASE.util,
         FDM = KIRI.driver.FDM,
-        SPACE, API,
+        SPACE, API, VIEWS, PROC, UI, UC,
         p1, p2, iw,
         lastMode, lastView, lastPillar,
         isFdmMode = false,
         addingSupports = false,
         alert = [],
         boxes = {},
-        func = {};
+        func = {},
+        rangeVars = {
+            "sliceShells": "shell count",
+            "sliceFillType": "fill type",
+            "sliceFillSparse": "fill fraction"
+        };
 
     FDM.init = function(kiri, api) {
+        UI = api.ui;
+        UC = api.uc;
         API = api;
         SPACE = api.const.SPACE;
+        VIEWS = api.const.VIEWS;
+        PROC = Object.keys(kiri.conf.defaults.fdm.p);
+
+        for (let key of Object.keys(rangeVars)) {
+            UI[key].range = true;
+        }
 
         function filterSynth() {
             api.widgets.filter((widget) => {
@@ -31,6 +44,17 @@
             });
         }
 
+        function updateRanges(ranges = []) {
+            console.log({ranges});
+            UI.rangeGroup.style.display = isFdmMode && ranges && ranges.length ? 'flex' : 'none';
+            let html = [];
+            for (let range of ranges) {
+                html.push(`<div>${range.lo}-${range.hi}<button>x<button></div>`);
+            }
+            // console.log(UI.rangeGroup.innerHTML);
+            // UI.rangeGroup.innerHTML = html.join('');
+        }
+
         api.event.on("mode.set", mode => {
             isFdmMode = mode === 'FDM';
             lastMode = mode;
@@ -40,14 +64,33 @@
             lastView = view;
             updateVisiblity();
             filterSynth();
+            // let ranges = API.conf.get().process.ranges;
+            if (isFdmMode) {
+                if (lastView === VIEWS.SLICE) {
+                    for (let key of PROC) {
+                        if (UI[key] && !UI[key].range) {
+                            UI[key].disabled = true;
+                        }
+                    }
+                } else {
+                    for (let key of PROC) {
+                        if (UI[key]) UI[key].disabled = false;
+                    }
+                }
+            }
+            // UI.rangeGroup.style.display = ranges && ranges.length ? 'flex' : 'none';
         });
+        api.event.on("range.updates", updateRanges);
         api.event.on("settings.load", (settings) => {
             if (settings.mode !== 'FDM') return;
             settings.process.outputOriginCenter = (settings.device.originCenter || false);
             restoreSupports(api.widgets.all());
+            updateRanges(settings.process.ranges);
         });
         api.event.on("settings.saved", (settings) => {
-            // api.ui.fdmSupport.style.display = lastMode !== 'FDM' || settings.device.bedBelt ? 'none' : 'flex';
+            updateRanges(settings.process.ranges);
+            // let ranges = settings.process.ranges;
+            // UI.rangeGroup.style.display = isFdmMode && ranges && ranges.length ? 'flex' : 'none';
         });
         api.event.on("button.click", target => {
             switch (target) {
@@ -311,7 +354,7 @@
 
     function updateVisiblity() {
         API.widgets.all().forEach(w => {
-            setSupportVisiblity(w, lastMode === 'FDM' && lastView === API.const.VIEWS.ARRANGE);
+            setSupportVisiblity(w, lastMode === 'FDM' && lastView === VIEWS.ARRANGE);
         });
     }
 

src/mode/fdm/slice.js

@@ -42,6 +42,23 @@
         return opt;
     }
 
+    function getRangeParameters(settings, index) {
+        let ranges = settings.process.ranges;
+        if (!(ranges && ranges.length)) {
+            return settings.process;
+        }
+        let params = Object.clone(settings.process);
+        for (let range of ranges) {
+            if (index >= range.lo && index <= range.hi) {
+                for (let [key,value] of Object.entries(range.fields)) {
+                    params[key] = value;
+                    params._range = true;
+                }
+            }
+        }
+        return params;
+    }
+
     /**
      * DRIVER SLICE CONTRACT
      *
@@ -274,6 +291,7 @@
 
             // create shells and diff inner fillable areas
             forSlices(0.0, 0.2, slice => {
+                let params = getRangeParameters(settings, slice.index);
                 let first = slice.index === 0;
                 let solid = (
                     slice.index < spro.sliceBottomLayers ||
@@ -283,7 +301,7 @@
                 let spaceMult = first ? spro.firstLayerLineMult || 1 : 1;
                 let offset = shellOffset * spaceMult;
                 let fillOff = fillOffset * spaceMult;
-                let count = isSynth ? 1 : spro.sliceShells;
+                let count = isSynth ? 1 : params.sliceShells;
                 doShells(slice, count, offset, fillOff, {
                     vase: vaseMode,
                     thin: spro.detectThinWalls && !isSynth,
@@ -376,16 +394,18 @@
             // sparse layers only present when non-vase mose and sparse % > 0
             if (doSparseFill && !isSynth) {
                 forSlices(0.5, 0.7, slice => {
+                    let params = getRangeParameters(settings, slice.index);
                     doSparseLayerFill(slice, {
                         settings: settings,
                         process: spro,
                         device: sdev,
                         lineWidth: lineWidth,
                         spacing: fillOffset,
-                        density: spro.sliceFillSparse,
+                        density: params.sliceFillSparse,
                         bounds: widget.getBoundingBox(),
                         height: sliceHeight,
-                        type: spro.sliceFillType
+                        type: params.sliceFillType,
+                        cache: params._range !== true
                     });
                 }, "infill");
             } else if (isSynth && supportDensity) {
@@ -665,6 +685,7 @@
             density = options.density,  // density of infill 0.0 - 1.0
             bounds = options.bounds,    // bounding box of widget
             height = options.height,    // z layer height
+            cache = !(options.cache === false),
             type = options.type || 'hex';
 
         if (slice.tops.length === 0 || density === 0.0 || slice.isSolidLayer) {
@@ -736,7 +757,7 @@
         // update fill fingerprint for this slice
         slice._fill_finger = POLY.fingerprint(polys);
 
-        let skippable = FILLFIXED[type] ? true : false;
+        let skippable = cache && FILLFIXED[type] ? true : false;
         let miss = false;
         // if the layer below has the same fingerprint,
         // we may be able to clone the infill instead of regenerating it