partforge 0.19.0 → 0.20.0

package/src/framework/viewer.js

@@ -4,12 +4,14 @@ import { toCreasedNormals } from "three/addons/utils/BufferGeometryUtils.js";
 import { LineSegments2 } from "three/addons/lines/LineSegments2.js";
 import { LineSegmentsGeometry } from "three/addons/lines/LineSegmentsGeometry.js";
 import { LineMaterial } from "three/addons/lines/LineMaterial.js";
+import { createCutaway } from "./cutaway.js";
+import { addViewerLights } from "./viewer-lighting.js";
 
 export function createViewer(container, part) {
   const names = Object.keys(part.parts);
 
   // --- renderer / scene / camera --------------------------------------------
-  const renderer = new THREE.WebGLRenderer({ antialias: true });
+  const renderer = new THREE.WebGLRenderer({ antialias: true, stencil: true });
   renderer.setPixelRatio(Math.min(devicePixelRatio, 2));
   container.appendChild(renderer.domElement);
 
@@ -32,10 +34,7 @@ export function createViewer(container, part) {
   controls.autoRotateSpeed = 1.6;
 
   // --- lights + grid --------------------------------------------------------
-  scene.add(new THREE.HemisphereLight(0xbfd4ff, 0x202024, 1.1));
-  const key = new THREE.DirectionalLight(0xffffff, 1.4);
-  key.position.set(8, 14, 10);
-  scene.add(key);
+  addViewerLights(scene);
   // 1 cm grid (mm units): 300 mm wide, 30 divisions -> 10 mm (1 cm) squares.
   const GRID_SIZE = 300, GRID_DIVS = 30;
   let floorY = 0; // world Y of the grid plane; set to the part's bbox bottom in frameTo
@@ -86,7 +85,7 @@ export function createViewer(container, part) {
 
   // CAD-style feature edge lines (anti-aliased "fat" lines), one per sub-part.
   const EDGE_ANGLE = 35; // deg — OCCT fallback threshold (Manifold supplies seam-aware edges)
-  const lineMaterial = new LineMaterial({ color: 0x1c232d, linewidth: 1.0 }); // ~10% lighter, 1 px
+  const lineMaterial = new LineMaterial({ color: THEME.dark.line, linewidth: 1.0 }); // ~10% lighter, 1 px
   lineMaterial.resolution.set(1, 1); // real size set by resize() below
   const subLines = Object.fromEntries(
     names.map((n) => [n, new LineSegments2(new LineSegmentsGeometry(), lineMaterial)])
@@ -96,6 +95,32 @@ export function createViewer(container, part) {
     partsGroup.add(l);
   }
 
+  // The cutaway plane lives in world space, so its initial/reset bounds must
+  // include the pivot rotation and the per-view recentering transform.
+  const _worldBounds = new THREE.Box3();
+  function getVisibleWorldBounds() {
+    _worldBounds.makeEmpty();
+    for (const mesh of Object.values(subMesh)) {
+      if (!mesh.visible || !mesh.geometry) continue;
+      mesh.updateWorldMatrix(true, false);
+      _worldBounds.expandByObject(mesh);
+    }
+    return _worldBounds;
+  }
+
+  const cutaway = createCutaway({
+    renderer,
+    scene,
+    camera,
+    orbitControls: controls,
+    domElement: renderer.domElement,
+    getBounds: getVisibleWorldBounds,
+    edgeColor: THEME.dark.line,
+  });
+  for (const name of names) {
+    cutaway.setSubpart(name, subMesh[name], subLines[name]);
+  }
+
   // Smooth shading within CREASE_ANGLE of a shared edge, hard edge past it — so the
   // round body and helical groove read smooth while bore rims, drum faces, and
   // groove walls stay crisp. Lower = more hard edges; raise toward Math.PI/3 for
@@ -135,9 +160,13 @@ export function createViewer(container, part) {
   const subCache = Object.fromEntries(names.map((n) => [n, null]));
 
   function setSubGeometry(name, payload) {
-    const prev = subCache[name]; // free the geometry this replaces (its own buffers + edge lines)
+    const prev = subCache[name];
+    const next = buildGeometry(payload);
+    subCache[name] = next;
+    // Section helpers must stop referring to the old buffers before those
+    // buffers are released.
+    cutaway.updateGeometry(name, next);
     if (prev) { prev.userData.edges?.dispose(); prev.dispose(); }
-    subCache[name] = buildGeometry(payload);
   }
 
   // Cache queries for the app's regenerate loop (so it never reaches into subCache).
@@ -178,6 +207,7 @@ export function createViewer(container, part) {
       subLines[name].visible = on;
     }
     if (frame) frameTo(visibleNames);
+    cutaway.setVisible(visibleNames);
   }
 
   // Re-frame whatever is currently visible (the reframe button).
@@ -185,7 +215,19 @@ export function createViewer(container, part) {
     frameTo(names.filter((n) => subMesh[n].visible && subCache[n]));
   }
 
-  function setAutoRotate(on) { controls.autoRotate = on; }
+  let autoRotateRequested = true;
+  function syncAutoRotate() {
+    controls.autoRotate = autoRotateRequested && !cutaway.isEnabled;
+  }
+  function setAutoRotate(on) {
+    autoRotateRequested = !!on;
+    syncAutoRotate();
+  }
+  function setCutawayEnabled(on) {
+    const changed = cutaway.setEnabled(on);
+    syncAutoRotate();
+    return changed;
+  }
 
   // Swap the scene background, grid, and edge-line colors for the given theme.
   function setTheme(mode) {
@@ -196,11 +238,13 @@ export function createViewer(container, part) {
     grid.position.y = floorY; // keep the floor at the bbox bottom across theme swaps
     scene.add(grid);
     lineMaterial.color.set(t.line);
+    cutaway.setTheme(mode, t.line);
   }
 
   function hideAssembly() {
     for (const m of Object.values(subMesh)) m.visible = false;
     for (const l of Object.values(subLines)) l.visible = false;
+    cutaway.setVisible([]);
   }
 
   // --- resize ---------------------------------------------------------------
@@ -211,6 +255,7 @@ export function createViewer(container, part) {
     camera.aspect = w / h;
     camera.updateProjectionMatrix();
     lineMaterial.resolution.set(w, h); // fat lines need the viewport size for px width
+    cutaway.setViewportSize(w, h, renderer.getPixelRatio());
   }
   const ro = new ResizeObserver(resize);
   ro.observe(container);
@@ -219,7 +264,9 @@ export function createViewer(container, part) {
   // --- render loop ----------------------------------------------------------
   renderer.setAnimationLoop(() => {
     controls.update();
+    if (cutaway.isEnabled) cutaway.updateForCamera();
     renderer.render(scene, camera);
+    cutaway.renderOverlay(renderer, camera);
   });
 
   // --- camera state (read/write for persistence; mount.js owns storage) -------
@@ -265,6 +312,7 @@ export function createViewer(container, part) {
     controls.dispose();
     for (const t of flashTimers) clearTimeout(t);
     flashTimers.clear();
+    cutaway.dispose();
     for (const n of names) {
       const g = subCache[n];
       if (g) { g.userData.edges?.dispose(); g.dispose(); subCache[n] = null; }
@@ -279,5 +327,30 @@ export function createViewer(container, part) {
     renderer.domElement.remove();
   }
 
-  return { showAssembly, hideAssembly, setSubGeometry, hasSubMesh, subTriangles, frame, setAutoRotate, setTheme, getCameraState, setCameraState, onCameraEnd, camera, domElement: renderer.domElement, _subMeshes: subMesh, flashPoint, dispose };
+  return {
+    showAssembly,
+    hideAssembly,
+    setSubGeometry,
+    hasSubMesh,
+    subTriangles,
+    frame,
+    setAutoRotate,
+    setTheme,
+    getCameraState,
+    setCameraState,
+    onCameraEnd,
+    camera,
+    domElement: renderer.domElement,
+    _subMeshes: subMesh,
+    flashPoint,
+    cutawaySupported: () => cutaway.isSupported,
+    cutawayEnabled: () => cutaway.isEnabled,
+    setCutawayEnabled,
+    flipCutaway: cutaway.flip,
+    resetCutaway: cutaway.reset,
+    isWorldPointVisible: cutaway.isPointVisible,
+    registerCutawayMaterial: cutaway.registerClippableMaterial,
+    onCutawayHandleHover: cutaway.onHandleHoverChange,
+    dispose,
+  };
 }

package/src/nameplate-worker.js

@@ -0,0 +1,3 @@
+import part from "./parts/nameplate.js";
+import { runWorker } from "./framework/worker.js";
+runWorker(part);

package/src/parts/bracket.js

@@ -0,0 +1,76 @@
+// Demo part — a cross bracket. Showcases the 2-D Shape2D toolkit end to end:
+//   • union      — two rounded-rectangle bars fused into a plus
+//   • intersect  — optionally clipped to a disc so the arm tips round off
+//   • cutAll      — four corner bolt holes drilled in one batch
+//   • cut         — a central bore
+//   • offset      — an optional print-clearance grow with rounded corners
+// The rounded corners and circular holes are true arcs (curve-native profiles), so
+// the whole outline stays curve-exact. Open /bracket.html after `npm run dev`.
+import { roundedRectPolygon, circleProfile } from "partforge/geometry";
+
+export default {
+  meta: { title: "Cross bracket", units: "mm", background: 0x15181d },
+  parameters: [
+    {
+      id: "size",
+      title: "Bracket",
+      description: "A plus-shaped plate made by **union**-ing a horizontal and a vertical rounded bar.",
+      advanced: [
+        { key: "span", label: "Span", unit: "mm", min: 30, max: 100, step: 1,
+          description: "Overall arm length, tip to tip, in both directions." },
+        { key: "bar", label: "Arm width", unit: "mm", min: 10, max: 40, step: 1,
+          description: "Width of each arm." },
+        { key: "corner", label: "Corner radius", unit: "mm", min: 0, max: 12, step: 0.5,
+          description: "Rounding on the bar corners (arcs, kept exact to STEP)." },
+        { key: "thickness", label: "Thickness", unit: "mm", min: 2, max: 10, step: 0.5,
+          description: "Plate thickness." },
+      ],
+    },
+    {
+      id: "holes",
+      title: "Holes",
+      description: "Four corner bolt holes (**cutAll** in one batch) and an optional central bore (**cut**).",
+      advanced: [
+        { key: "hole_d", label: "Bolt hole ø", unit: "mm", min: 2, max: 10, step: 0.5,
+          description: "Diameter of the four corner holes." },
+        { key: "inset", label: "Hole inset", unit: "mm", min: 5, max: 24, step: 1,
+          description: "How far the corner holes sit in from the arm tips." },
+        { key: "center_d", label: "Center bore ø", unit: "mm", min: 0, max: 30, step: 1,
+          description: "Central through-bore. Set to 0 for none." },
+      ],
+    },
+    {
+      id: "shape",
+      title: "Shape ops",
+      toggles: [
+        { key: "clip", label: "Clip arms to a disc (intersect)", on: 1,
+          description: "**Intersect** the cross with a circle so the four arm tips are rounded off to a common radius." },
+      ],
+      advanced: [
+        { key: "clearance", label: "Print-clearance offset", unit: "mm", min: 0, max: 1, step: 0.1,
+          description: "**Offset** the whole outline outward (round corners) for a looser slip fit. 0 = none." },
+      ],
+    },
+  ],
+  defaults: { span: 60, bar: 22, corner: 4, thickness: 4, hole_d: 5, inset: 8, center_d: 16, clip: 0, clearance: 0 },
+  parts: {
+    bracket: {
+      label: "Cross bracket",
+      views: ["bracket"],
+      export: { name: "cross-bracket" },
+      build: (k, p) => {
+        const barH = k.shape2d(roundedRectPolygon(p.span, p.bar, p.corner));
+        const barV = k.shape2d(roundedRectPolygon(p.bar, p.span, p.corner));
+        let plate = barH.union(barV);                                        // union
+        if (p.clip) plate = plate.intersect(k.shape2d(circleProfile(p.span / 2)));  // intersect
+        const d = p.span / 2 - p.inset;
+        const holes = [[d, d], [-d, d], [d, -d], [-d, -d]].map((c) => circleProfile(p.hole_d / 2, c));
+        plate = plate.cutAll(holes);                                         // batch cut
+        if (p.center_d > 0) plate = plate.cut(k.shape2d(circleProfile(p.center_d / 2)));  // cut
+        if (p.clearance) plate = plate.offset(p.clearance, { corners: "round" });  // offset
+        return k.extrude({ profile: plate, h: p.thickness });
+      },
+    },
+  },
+  views: { bracket: { label: "Cross bracket" } },
+};

package/src/parts/nameplate.js

@@ -0,0 +1,67 @@
+// Demo part — a lettered nameplate. Showcases k.text2d (the vector-text feature):
+// two lines of text with counters and curves (P A R T F O R G E, digits) resolved to
+// exact curve regions, then either raised above (emboss) or cut into (deboss) a
+// rounded plate. The plate itself is a Shape2D rounded-rectangle, so the part also
+// exercises shape2d + the extrude/boolean path. Open /nameplate.html after `npm run dev`.
+import { roundedRectPolygon } from "partforge/geometry";
+
+const LABEL = "PARTFORGE\nv0.20";
+
+export default {
+  meta: { title: "Nameplate", units: "mm", background: 0x15181d },
+  parameters: [
+    {
+      id: "text",
+      title: "Lettering",
+      description: "The text is a two-line label (`PARTFORGE` over `v0.20`). It is resolved to exact glyph curves — counters in **A R O G** and the **0** stay open — and sized by cap height.",
+      advanced: [
+        { key: "size", label: "Cap height", unit: "mm", min: 4, max: 16, step: 0.5,
+          description: "Height of the uppercase letters. The second line scales with it." },
+        { key: "depth", label: "Relief depth", unit: "mm", min: 0.4, max: 3, step: 0.1,
+          description: "How far the lettering is raised above (emboss) or recessed into (engrave) the plate face." },
+      ],
+    },
+    {
+      id: "plate",
+      title: "Plate",
+      description: "A rounded-rectangle backing plate, sized automatically from the text bounding box plus the border.",
+      advanced: [
+        { key: "margin", label: "Border", unit: "mm", min: 2, max: 12, step: 0.5,
+          description: "Clear space between the lettering and the plate edge." },
+        { key: "corner", label: "Corner radius", unit: "mm", min: 0, max: 10, step: 0.5,
+          description: "Rounding on the plate corners (clamped so it never exceeds half the shorter side)." },
+        { key: "thickness", label: "Thickness", unit: "mm", min: 1.5, max: 8, step: 0.5,
+          description: "Plate thickness." },
+      ],
+    },
+    {
+      id: "style",
+      title: "Style",
+      toggles: [
+        { key: "engrave", label: "Engrave (recessed)", on: 1,
+          description: "Cut the lettering into the top face instead of raising it above the plate." },
+      ],
+    },
+  ],
+  defaults: { size: 8, depth: 1.2, margin: 4, corner: 3, thickness: 3, engrave: 0 },
+  parts: {
+    plate: {
+      label: "Nameplate",
+      views: ["plate"],
+      export: { name: "nameplate" },
+      build: (k, p) => {
+        const text = k.text2d(LABEL, { size: p.size, align: "center", valign: "middle", lineHeight: p.size * 1.7 });
+        const bb = text.boundingBox();
+        const w = (bb.max[0] - bb.min[0]) + 2 * p.margin;
+        const h = (bb.max[1] - bb.min[1]) + 2 * p.margin;
+        const corner = Math.max(0, Math.min(p.corner, Math.min(w, h) / 2 - 0.5));
+        const plate = k.extrude({ profile: k.shape2d(roundedRectPolygon(w, h, corner)), h: p.thickness }).label("Plate");
+        const relief = k.extrude({ profile: text, h: p.depth });
+        return p.engrave
+          ? plate.cut(relief.translate([0, 0, p.thickness - p.depth]))
+          : plate.union(relief.translate([0, 0, p.thickness]).label("Lettering"));
+      },
+    },
+  },
+  views: { plate: { label: "Nameplate" } },
+};

package/src/parts/text-smoke.js

@@ -0,0 +1,21 @@
+// Dev/CI worker-safety fixture (Task 3): a real text-bearing part, wired through
+// the actual app/worker path so scripts/check-app.mjs can boot it in real Chromium.
+// This is the definitive proof that paper.js (via resolveCurveFill) actually
+// executes inside the Vite geometry Web Worker, not just under Node/vitest.
+export default {
+  meta: { title: "Text worker smoke", units: "mm", background: 0x15181d },
+  parameters: [],
+  defaults: {},
+  parts: {
+    text: {
+      label: "Text",
+      views: ["text"],
+      export: { name: "text-smoke" },
+      build: (k) => k.extrude({
+        profile: k.text2d("B8&", { size: 10, align: "center", valign: "middle" }),
+        h: 2,
+      }).label("Resolved text"),
+    },
+  },
+  views: { text: { label: "Text" } },
+};

package/src/testing/manifold.js

@@ -3,9 +3,13 @@
 // in the same process — they crash together.)
 import Module from "manifold-3d";
 import { createManifoldKernel } from "../framework/geometry/manifold-backend.js";
+import { resolveFonts } from "../framework/fonts.js";
 
-export async function bootManifoldKernel({ quality = "preview" } = {}) {
+export async function bootManifoldKernel({ quality = "preview", fonts } = {}) {
   const wasm = await Module();
   wasm.setup();
-  return createManifoldKernel(wasm, { quality });
+  const kernel = createManifoldKernel(wasm, { quality });
+  if (fonts) { const opentype = (await import("opentype.js")).default;
+    for (const [name, buf] of await resolveFonts(fonts)) kernel._fonts.set(name, opentype.parse(buf)); }
+  return kernel;
 }

package/src/testing/occt.js

@@ -5,8 +5,9 @@ import { fileURLToPath } from "url";
 import path from "path";
 import fs from "fs";
 import { createOcctKernel } from "../framework/geometry/occt-backend.js";
+import { resolveFonts } from "../framework/fonts.js";
 
-export async function bootOcctKernel() {
+export async function bootOcctKernel({ fonts } = {}) {
   const require = createRequire(import.meta.url);
   globalThis.require = globalThis.require ?? require;
   globalThis.__dirname = globalThis.__dirname ?? path.dirname(fileURLToPath(import.meta.url));
@@ -14,5 +15,8 @@ export async function bootOcctKernel() {
   const OC = await init({ wasmBinary: fs.readFileSync(require.resolve("replicad-opencascadejs/src/replicad_single.wasm")) });
   const replicad = await import("replicad");
   replicad.setOC(OC);
-  return createOcctKernel(replicad);
+  const kernel = createOcctKernel(replicad);
+  if (fonts) { const opentype = (await import("opentype.js")).default;
+    for (const [name, buf] of await resolveFonts(fonts)) kernel._fonts.set(name, opentype.parse(buf)); }
+  return kernel;
 }

package/src/text-smoke-worker.js

@@ -0,0 +1,3 @@
+import part from "./parts/text-smoke.js";
+import { runWorker } from "./framework/worker.js";
+runWorker(part);