three-slicer 0.2.3 → 0.2.4

package/engine/src/client.js

@@ -21,6 +21,7 @@ export { SLA_CAPABILITIES, SLA_JOB_VERSION, SlaRequestError } from './sla_reques
 const REPLY_OF = {
   warmup: 'warm', prepare: 'prepared', paint: 'painted', erase: 'painted', clear: 'painted',
   importPaint: 'painted', exportPaint: 'paintExport', overlay: 'overlay', slice: 'done', sla: 'done',
+  fillPreview: 'fillPreview', paintMode: 'paintMode',
 }
 
 const asBuffer = (data) => (data instanceof ArrayBuffer ? data : data?.buffer ?? data)
@@ -143,6 +144,14 @@ export function createSlicerClient(worker = new Worker(new URL('./slicer.worker.
     overlay: (states) => send({ cmd: 'overlay', ...(states ? { states } : {}) })
       .then(reply => ({ enforcer: reply.enf, blocker: reply.blk, overlays: reply.overlays })),
 
+    /** What a fill would select under `{tool, facet, hx, hy, hz, angle}`, without applying it. `{clear:true}`
+     *  drops the standing selection. `supported` is false on a kernel built before the preview existed. */
+    fillPreview: (args) => send({ cmd: 'fillPreview', ...args })
+      .then(reply => ({ supported: reply.supported, triangles: reply.tris })),
+    /** Brush-wide options: `{overhangDeg}` restricts every stroke to overhangs (0 = off), `{clipPlane:[nx,ny,nz,d]}`
+     *  sets the section plane every cursor clips against (null turns it off). */
+    paintMode: (args) => send({ cmd: 'paintMode', ...args }).then(() => undefined),
+
     /** Load a 3mf's painting. Replaces every mark, so run it directly after `prepare`. */
     importPaint: (facets, hex, states) => brush('importPaint', { facets, hex, ...(states ? { states } : {}) }),
     exportPaint: () => send({ cmd: 'exportPaint' })

package/engine/src/slicer.worker.js

@@ -95,6 +95,16 @@ const cursorShapeOf = (message) => (message.cursor === 'circle' ? 1 : 0)
 //  a radius or a camera: what they select comes from the mesh's own topology, which is why they are a branch rather
 //  than more optional fields on the brush call. `state === null` means erase (the entry points with no state
 //  argument), matching how the brush splits paint from erase.
+// The previous sample of the current stroke, when the message carries one. Upstream paints the CAPSULE between two
+//  consecutive mouse positions (DoublePointCursor, GLGizmoPainterBase.cpp:878) — a pointer stream is sampled, not
+//  continuous, so a ball per sample leaves a fast drag as a row of blobs with gaps between them. Optional on the
+//  wire and feature-detected on the kernel, so a caller or a build without it keeps painting single points.
+const strokeFrom = (message) =>
+  Number.isFinite(message.px) && Number.isFinite(message.py) && Number.isFinite(message.pz)
+
+// The fill modes the kernel's fill_preview takes (selector_bridge.h FILL_*), by the tool name the protocol uses.
+const FILL_PREVIEW_MODE = { smart: 0, bucket: 1, triangle: 2 }
+
 const FILL_TOOLS = new Set(['smart', 'bucket', 'triangle'])
 const applyFill = (Module, message, state) => {
   const angle = Number.isFinite(message.angle) ? message.angle : 30
@@ -224,6 +234,8 @@ self.onmessage = async (e) => {
         applyFill(Module, d, paintedState)
       }
       else if (paintedState === null) Module.selector_paint(d.facet, d.hx, d.hy, d.hz, d.cx, d.cy, d.cz, d.radius, d.enforcer)
+      else if (strokeFrom(d) && Module.selector_paint_stroke)
+        Module.selector_paint_stroke(d.facet, d.px, d.py, d.pz, d.hx, d.hy, d.hz, d.cx, d.cy, d.cz, d.radius, paintedState, cursorShapeOf(d))
       else Module.selector_paint_shape(d.facet, d.hx, d.hy, d.hz, d.cx, d.cy, d.cz, d.radius, paintedState, cursorShapeOf(d))
       self.postMessage(paintedReply(Module, d, paintedState)); return
     }
@@ -236,6 +248,11 @@ self.onmessage = async (e) => {
     //  change to the same counts, and the viewer's listeners must not need to know which brush produced it.
     if (d.cmd === 'erase')   {
       if (FILL_TOOLS.has(d.tool)) applyFill(Module, d, null)
+      else if (strokeFrom(d) && Module.selector_erase_stroke)
+        Module.selector_erase_stroke(d.facet, d.px, d.py, d.pz, d.hx, d.hy, d.hz, d.cx, d.cy, d.cz, d.radius, cursorShapeOf(d))
+      // The eraser gets the cursor shape too, or a shift+drag with the circle brush rubs out the far side of a wall
+      //  the paint brush never touched. `selector_erase` (no shape) stays the fallback for an older kernel.
+      else if (Module.selector_erase_shape) Module.selector_erase_shape(d.facet, d.hx, d.hy, d.hz, d.cx, d.cy, d.cz, d.radius, cursorShapeOf(d))
       else Module.selector_erase(d.facet, d.hx, d.hy, d.hz, d.cx, d.cy, d.cz, d.radius)
       self.postMessage(paintedReply(Module, d, null)); return
     }
@@ -292,6 +309,34 @@ self.onmessage = async (e) => {
       self.postMessage(reply, transfer); return
     }
 
+    // fillPreview: what a fill WOULD select, without applying it. Upstream runs this on every mouse move while a
+    //  fill tool is active and draws the result in a lighter shade (GLGizmoPainterBase.cpp:929) — a preview marks
+    //  nothing, so it needs no state at all and there is no NONE for a stray boolean to become. `{clear:true}`
+    //  drops the standing selection, which is what leaving the model under the pointer means.
+    if (d.cmd === 'fillPreview') {
+      if (!Module.selector_fill_preview) { self.postMessage({ type: 'fillPreview', supported: false, tris: EMPTY_OVERLAY }); return }
+      if (d.clear) { Module.selector_fill_preview_clear(); self.postMessage({ type: 'fillPreview', supported: true, tris: EMPTY_OVERLAY }); return }
+      const angle = Number.isFinite(d.angle) ? d.angle : 30
+      const mode = FILL_PREVIEW_MODE[d.tool] ?? FILL_PREVIEW_MODE.smart
+      // Upstream's -1 for the non-propagating case, the same value applyFill sends: one facet has no neighbour to
+      //  measure an angle against.
+      const tris = Module.selector_fill_preview(d.facet, d.hx, d.hy, d.hz, mode === FILL_PREVIEW_MODE.triangle ? -1 : angle, mode)
+      self.postMessage({ type: 'fillPreview', supported: true, tris },
+                       tris?.buffer && tris.byteLength > 0 ? [tris.buffer] : [])
+      return
+    }
+    // paintMode: the brush-wide options upstream keeps on the gizmo — the overhang restriction and the section
+    //  plane. Both are set once and read by every stroke, so they are their own command rather than fields on one.
+    if (d.cmd === 'paintMode') {
+      if (Number.isFinite(d.overhangDeg) && Module.selector_set_overhang_limit) Module.selector_set_overhang_limit(d.overhangDeg)
+      if (Module.selector_set_clip_plane) {
+        const plane = d.clipPlane
+        if (plane) Module.selector_set_clip_plane(plane[0], plane[1], plane[2], plane[3], true)
+        else if (d.clipPlane === null) Module.selector_set_clip_plane(0, 0, 1, 0, false)
+      }
+      self.postMessage({ type: 'paintMode', ok: true }); return
+    }
+
     if (d.stall) return   // stage-30 test hook: simulate a hang -> verifies the main-thread watchdog fires (not set in production)
     // mt (SAB): share the address of the real support progress counter (u32) with main once — even while the kernel is
     //  blocked inside C++, the UI thread polls the SAB directly to show support progress. st (non-shared buffer) is unsupported -> not sent.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "three-slicer",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "description": "Browser/WASM 3D-printing slicer reverse-engineered from OrcaSlicer: slicing engine (Arachne walls, tree/grid supports, multi-material), SLA resin slicing with PrusaSlicer's ported support/pad chain and .sl1 export, React viewer with GPU toolpath preview, and schema-driven settings UI.",
   "license": "AGPL-3.0-or-later",
   "type": "module",

package/types/.omc/state/sessions/02e5ddf5-4378-46e1-8fca-e90412c30804/pre-tool-advisory-throttle.json

@@ -0,0 +1,10 @@
+{
+  "version": 1,
+  "entries": {
+    "79a93d4a2f8f50b95f852280616242fee1855dc99a3c75211917f55e72e95fae": {
+      "last_emitted_at_ms": 1788437194779,
+      "message": "Use parallel execution for independent tasks. Use run_in_background for long operations (npm install, builds, tests)."
+    }
+  },
+  "updated_at": "2026-09-03T12:06:34.779Z"
+}

package/types/worker.d.ts

@@ -13,6 +13,14 @@ export interface BrushArgs {
   hx: number; hy: number; hz: number
   cx: number; cy: number; cz: number
   radius: number
+  /**
+   * The PREVIOUS sample of this stroke. Present, the kernel paints the capsule swept from there to `(hx,hy,hz)`
+   * instead of a ball at the hit — which is what upstream does between two consecutive mouse positions
+   * (`DoublePointCursor`, GLGizmoPainterBase.cpp:878). A pointer stream is sampled, not continuous, so without it
+   * a fast drag lands as a row of separate blobs. Omit on the first sample of a stroke; a kernel built before the
+   * capsule existed ignores it and paints the ball, so it is safe to always send.
+   */
+  px?: number; py?: number; pz?: number
 }
 
 /**
@@ -56,6 +64,23 @@ export type SlicerRequest =
   | { cmd: 'clear'; states?: PaintState[] }
   /** The painted overlay triangles. `enf`/`blk` always; `states` adds those states. Reply: `overlay`. */
   | { cmd: 'overlay'; states?: PaintState[] }
+
+  /**
+   * What a fill tool WOULD select under the cursor, without marking anything — upstream draws this on every mouse
+   * move while a fill is active (GLGizmoPainterBase.cpp:929) so a click is aimed rather than tried. No state
+   * argument at all: a preview marks nothing, so there is no NONE for a stray boolean to become.
+   * `{clear:true}` drops the standing selection. Reply: `fillPreview`.
+   */
+  | { cmd: 'fillPreview'; facet?: number; hx?: number; hy?: number; hz?: number
+      tool?: PaintTool; angle?: number; clear?: boolean }
+
+  /**
+   * Brush-wide options, set once and read by every stroke and fill — upstream keeps both on the gizmo.
+   * `overhangDeg` restricts painting to facets overhanging by more than that angle (`0` = off, the default);
+   * `clipPlane` is the section plane `[nx, ny, nz, offset]` in KERNEL coords that every cursor clips against
+   * (`null` turns it off), which is the only way a brush reaches an interior surface. Reply: `paintMode`.
+   */
+  | { cmd: 'paintMode'; overhangDeg?: number; clipPlane?: [number, number, number, number] | null }
   /**
    * Legacy single-object SLA (resin) slice. `params` accepts a JSON string or an object (this path parses either). Same reply stream as
    * a slice: `progress` and `layer` while it runs, then `done` (stats only; layers arrived as `layer`) — or `error`.
@@ -83,6 +108,9 @@ export type SlicerResponse =
   /** `supported: false` from a kernel built before the export binding existed — it does not throw. */
   | { type: 'paintExport'; supported: boolean; facets: number[]; hex: string }
   | { type: 'overlay'; enf: Float32Array; blk: Float32Array; overlays?: Record<number, Float32Array> }
+  /** `supported` false on a kernel built before the preview existed; `tris` is flat x,y,z, 3 vertices per triangle. */
+  | { type: 'fillPreview'; supported: boolean; tris: Float32Array }
+  | { type: 'paintMode'; ok: boolean }
   /**
    * Sent once, unprompted, by the multithreaded kernel only: the address of the support-progress counter and of
    * the cancel flag, inside a SharedArrayBuffer. Writing 1 to the cancel flag stops a slice the worker is

package/viewer/README.md

@@ -180,6 +180,26 @@ arrows and Delete working.
 | `Z` · `B` | Zoom to all · zoom to bed |
 | `Esc` | Back to Prepare |
 
+While a brush is open these take over the same letters — the object shortcuts come back the moment it closes.
+
+| Painting | |
+| --- | --- |
+| `C` · `S` | Brush shape: circle (the visible surface) · sphere (reaches through a thin wall) |
+| `F` · `B` · `T` | Smart fill · bucket fill · single triangle |
+| `V` · `H` | Lock the stroke to a vertical · horizontal line — press again to release |
+| `1`…`9` | Paint with that filament (material brush only) |
+| `Shift + drag` | Erase instead of paint |
+| Drag off the model | Rotate the camera — a press that misses the model is not the brush's, so orbiting never means closing it |
+| `Ctrl/⌘ + wheel` | Brush radius, or the fill angle for a fill tool — the bare wheel stays the camera zoom |
+| `Alt + wheel` | Scrub the section plane, which is what lets a brush reach a surface inside the model |
+| `Esc` | Close the brush, and put back whatever the section plane cut away |
+
+The brush draws itself while it is open — a ring for the circle cursor, a translucent ball for the sphere — and a
+fill tool shades what a click would flood before you click it. A drag paints the **capsule** swept between samples
+rather than one ball per sample, so a fast stroke is continuous instead of a row of blobs. A press that misses the
+model falls through to the camera, so the view can be turned mid-paint without closing the brush. The support brush also
+offers *on overhangs only*, which restricts every stroke to facets steeper than the support threshold.
+
 Mouse selection follows upstream's rules: a plain click **replaces** the selection, `Ctrl/⌘ + click` adds or
 removes, a plain click on something already selected **keeps** the set (which is what makes dragging several
 objects work), `Shift + drag` is a box select, and clicking empty space clears. Alt is not a de-select, in