update to latest raster code

src/gpu/raster-worker.js

@@ -1 +1 @@
-../../node_modules/@gridspace/raster-path/src/web/webgpu-worker.js
+../../../gs-raster-path/build/webgpu-worker.js

src/gpu/raster.js

@@ -1 +1 @@
-../../node_modules/@gridspace/raster-path/src/index.js
+../../../gs-raster-path/build/raster-path.js

src/kiri/mode/cam/topo3.js

@@ -108,11 +108,15 @@ export class Topo {
         }
 
         if (webGPU) {
+            console.log({ tool });
             // invert tool Z offset for gpu code
-            let gputool = toolOffset.slice();
+            let toolBounds = new THREE.Box3();
-            for (let i=0; i<gputool.length; i+= 3) {
+            let toolPos = tool.profile.slice();
-                gputool[i+2] *= -1;
+            for (let i=0; i<toolPos.length; i+= 3) {
+                toolPos[i+2] *= -1;
+                toolBounds.expandByPoint({ x: toolPos[i], y: toolPos[i+1], z: toolPos[i+2] });
             }
+            let toolData = { positions: toolPos, bounds: toolBounds };
 
             const vertices = widget.getGeoVertices({ unroll: true, translate: true });
             const wbounds = widget.getBoundingBox();
@@ -131,24 +135,25 @@ export class Topo {
                 console.timeEnd('swap XY vertices');
             }
 
-            let gpu = await self.get_raster_gpu();
+            let gpu = await self.get_raster_gpu({
+                mode: "planar",
+                resolution
+            });
             let xStep = density;
             let yStep = Math.round(toolStep / resolution);
             let epsilon = 10e-5;
-            let terrain = await gpu.rasterizeMesh(vertices, resolution, 0, wbounds);
+            let terrainData = await gpu.rasterizeModel({
-            let { positions } = terrain;
+                triangles: vertices,
-            let output = await gpu.generatePlanarToolpath(
+                boundsOverride: wbounds
-                positions,
+            });
-                gputool,
+            let output = await gpu.generateToolpaths({
+                terrainData,
+                toolData,
                 xStep,
                 yStep,
-                zBottom - 1,
+                zFloor: zBottom - 1,
-                resolution,
+                onProgress(pct) { console.log({ pct }); onupdate(pct/100, 100) }
-                {
+            });
-                    terrainBounds: wbounds,
-                    onProgress(pct) { console.log({ pct }); onupdate(pct/100, 100) }
-                }
-            );
             let { numScanlines, pointsPerLine, pathData } = output;
             let xmult = xStep * resolution;
             let ymult = yStep * resolution;

src/kiri/mode/cam/topo4.js

@@ -163,10 +163,13 @@ export class Topo {
         const { angle, linear, offStart, offEnd, resolution, tool, unit, vertices, zBottom } = this;
 
         // invert tool Z offset for gpu code
-        let gputool = tool.slice();
+        let toolBounds = new THREE.Box3();
-        for (let i=0; i<gputool.length; i+= 3) {
+        let toolPos = tool.slice();
-            gputool[i+2] *= -1;
+        for (let i=0; i<toolPos.length; i+= 3) {
+            toolPos[i+2] *= -1;
+            toolBounds.expandByPoint({ x: toolPos[i], y: toolPos[i+1], z: toolPos[i+2] });
         }
+        let toolData = { positions: toolPos, bounds: toolBounds };
 
         console.time('swap XZ vertices');
         // swap XZ vertices for gpu code
@@ -176,30 +179,40 @@ export class Topo {
             vertices[i+0] = tmp;
         }
         console.timeEnd('swap XZ vertices');
+        // let bbox = new THREE.Box3().setFromArray(vertices);
+        // console.log({ bbox, bounds });
 
-        let gpu = await self.get_raster_gpu();
+        let gpu = await self.get_raster_gpu({
-        let tickperstep = Math.round(this.step / resolution);
+            mode: "radial",
-        let bounds = this.bounds.clone();
-        bounds.min.x += offStart * unit;
-        bounds.max.x -= offEnd * unit;
-        let output = await gpu.generateRadialToolpath(
-            vertices,
-            gputool,
-            angle,
-            tickperstep,
-            zBottom,
             resolution,
-            bounds,
+            rotationStep: angle
-            { onProgress(pct) { onupdate(pct/100) } }
+        });
-        );
+        let tickperstep = Math.round(this.step / resolution);
+        let boundsOverride = this.bounds.clone();
+        boundsOverride.min.x += offStart * unit;
+        boundsOverride.max.x -= offEnd * unit;
+        let terrainData = await gpu.rasterizeModel({
+            triangles: vertices,
+            boundsOverride
+        });
+        console.log({ terrainData });
+        let output = await gpu.generateToolpaths({
+            terrainData,
+            toolData,
+            xStep: 1,
+            yStep: this.step,
+            zFloor: zBottom,
+            onProgress(pct) { onupdate(pct/100) }
+        });
+        console.log({ output });
 
-        let { numRotations, pointsPerLine, pathData } = output;
+        let { numScanlines, pointsPerLine, pathData } = output;
-        let degPerRow = 360 / numRotations;
+        let degPerRow = 360 / numScanlines;
         let slices = this.gpu_slices = [];
         let xmult = tickperstep * resolution;
-        let xoff = bounds.min.x;
+        let xoff = toolData.bounds.min.x;
         let rows = [];
-        for (let i=0; i<numRotations; i++) {
+        for (let i=0; i<numScanlines; i++) {
             let lineData = pathData.slice(i * pointsPerLine, i * pointsPerLine + pointsPerLine);
             let points = Array.from(lineData).map((v,j) => newPoint(j * xmult + xoff, 0, v).setA(-i * degPerRow));
             rows.push(points);

src/kiri/run/worker.js

@@ -68,16 +68,18 @@ self.uuid = ((Math.random() * Date.now()) | 0).toString(36);
 /**
  * @returns {RasterPath}
  */
-self.get_raster_gpu = async function() {
+self.get_raster_gpu = async function({ mode, resolution, rotationStep }) {
-    let gpu = self.raster_gpu;
+    console.log({ mode, resolution, rotationStep });
-    if (!gpu) {
+    let gpu = new RasterPath({
-        gpu = self.raster_gpu = new RasterPath({
+        mode,
-            workerName: "/lib/gpu/raster-worker.js",
+        resolution,
-            quiet: true
+        rotationStep,
-        });
+        workerName: "/lib/gpu/raster-worker.js",
-        await gpu.init();
+        maxWorkers: 20,
-        await gpu.initWorkerPool();
+        quiet: false,
-    }
+        debug: true,
+    });
+    await gpu.init();
     return gpu;
 };