partforge 0.134.0 → 0.136.0

package/src/framework/viewer.js

@@ -12,6 +12,7 @@ import { ensureBoxUVs } from "./materials/uv.js";
 import { loadEnvironmentRig } from "./materials/environment.js";
 import { assetUrl } from "./materials/assets.js";
 import { resolveEnvironmentId } from "./materials/resolve.js";
+import { burnsFor, realisticDisplay } from "./materials/sheet-look.js";
 import { neutralToneMapToSrgb8 } from "./materials/tonemap-readback.js";
 import { createCutaway } from "./cutaway.js";
 import { CUTAWAY_OVERLAY_RENDER_ORDER } from "./cutaway-render.js";
@@ -591,9 +592,11 @@ export function createViewer(container, part) {
   const textureCache = new Map();    // asset file name -> Texture
   const textureLoader = new THREE.TextureLoader();
   let pmrem = null;
-  let printFrames = {};
-  let printFrameSource = null;       // () => frames; mount's lazy provider (setPrintFrameSource)
-  let printFramesStale = false;      // the source has frames the materials have not seen
+  let printFrames = {};              // name -> mat4 array: layer lines' display → export map
+  let sheetFrames = {};              // name -> { frame, t, plies }: a burning sheet's canonical frame (sheet-look.js)
+  let frameSource = null;            // () => { print, sheet }; mount's lazy provider (setFrameSource)
+  let framesStale = false;           // the source has frames the materials have not seen
+  const IDENTITY_MAT4 = new THREE.Matrix4().toArray();
   const modeListeners = new Set();
   const envListeners = new Set();
   const SHADOW_LOWRES_MS = 100;      // at most one low-res shadow per this, while a part moves
@@ -728,9 +731,14 @@ export function createViewer(container, part) {
   function physicalFor(name) {
     let m = physicalMats.get(name);
     if (!m) {
-      m = cloneKeepsPattern(buildPhysicalMaterial(part.parts[name].display, { printFrame: printFrames[name], loadTexture }));
+      const sp = part.parts[name];
+      // `burn` is decided once per sub-part (sheet-look.js burnsFor): only a laser sheet in
+      // a wood compiles the burn pass, so every other program is exactly what it was.
+      // realisticDisplay: a laser sheet with no material draws as its stock (sheet-look.js).
+      m = cloneKeepsPattern(buildPhysicalMaterial(realisticDisplay(sp), { printFrame: printFrames[name], burn: burnsFor(sp), loadTexture }));
       physicalMats.set(name, m);
       syncGrain(name);
+      applySheetFrame(m, sheetFrames[name]);
     }
     return m;
   }
@@ -859,7 +867,7 @@ export function createViewer(container, part) {
   // ground only moves on showAssembly, never because a capture happened.
   function enterRealistic(rig, { live = true, reground = true } = {}) {
     try {
-      syncPrintFrames(); // before the swap: the first realistic frame has the export-pose layers
+      syncFrames(); // before the swap: the first realistic frame has the export-pose layers and the sheets' burns
       renderMode = "realistic";
       // A regen can land between the proxy compile and here, while the mode
       // was still CAD, so setSubGeometry skipped the UVs. Idempotent.
@@ -929,7 +937,7 @@ export function createViewer(container, part) {
   // target bound — each only for the synchronous compile() inside
   // compileAsync, so the view on screen is untouched while it waits.
   function compileRealistic(rig, { forCapture = false } = {}) {
-    syncPrintFrames();
+    syncFrames();
     const proxy = new THREE.Scene();
     proxy.environment = rig.envMap;
     for (const n of names) {
@@ -1030,30 +1038,45 @@ export function createViewer(container, part) {
     for (const [n, m] of physicalMats) m.userData.patternUniforms?.pfPrintFrame.value.fromArray(printFrames[n] ?? identity);
   }
 
-  // The lazy form mount uses. Computing a frame runs the sub-part's pose probe
-  // (two geometry-free builds for a placed sub-part), and every sub-part with
-  // no material draws layer lines, so frames are PULLED only when something is
-  // about to draw the realistic look: the live view (or a switch loading),
-  // and any capture that borrows it — compileRealistic and enterRealistic are
-  // the two doors every such path goes through. A delivery just marks them
-  // stale (invalidatePrintFrames); in CAD nothing is computed.
-  function setPrintFrameSource(source) {
-    printFrameSource = typeof source === "function" ? source : null;
-    invalidatePrintFrames();
-  }
-  function invalidatePrintFrames() {
-    printFramesStale = true;
-    if (renderMode === "realistic" || realisticPending) syncPrintFrames();
-  }
-  function syncPrintFrames() {
-    if (!printFrameSource || !printFramesStale) return;
-    printFramesStale = false;
+  // A burning sheet's canonical frame (sheet-look.js sheetFrameFor). No frame — not yet
+  // delivered, or not computable at these params — is pfSheetT = 0: plain wood.
+  function applySheetFrame(m, f) {
+    const u = m.userData.patternUniforms;
+    if (!u?.pfSheetFrame) return;
+    u.pfSheetFrame.value.fromArray(f?.frame ?? IDENTITY_MAT4);
+    u.pfSheetT.value = f?.t ?? 0;
+    u.pfPlies.value = f?.plies ?? 0;
+  }
+  function setSheetFrames(frames) {
+    sheetFrames = frames ?? {};
+    for (const [n, m] of physicalMats) applySheetFrame(m, sheetFrames[n]);
+  }
+
+  // The lazy form mount uses. Frames are PULLED only when something is about to draw the
+  // realistic look: the live view (or a switch loading), and any capture that borrows it —
+  // compileRealistic and enterRealistic are the two doors every such path goes through. A
+  // delivery just marks them stale (invalidateFrames); in CAD nothing is computed. One
+  // source carries both kinds: `print` (layer lines; a placed sub-part's costs two
+  // geometry-free probe builds, and every sub-part with no material draws layer lines) and
+  // `sheet` (a burning sheet's canonical frame, from data).
+  function setFrameSource(source) {
+    frameSource = typeof source === "function" ? source : null;
+    invalidateFrames();
+  }
+  function invalidateFrames() {
+    framesStale = true;
+    if (renderMode === "realistic" || realisticPending) syncFrames();
+  }
+  function syncFrames() {
+    if (!frameSource || !framesStale) return;
+    framesStale = false;
     let frames;
-    try { frames = printFrameSource(); } catch (e) {
-      console.warn("partforge: computing print frames failed", e);
+    try { frames = frameSource(); } catch (e) {
+      console.warn("partforge: computing material frames failed", e);
       return;
     }
-    setPrintFrames(frames);
+    setPrintFrames(frames?.print);
+    setSheetFrames(frames?.sheet);
   }
 
   // Resolves once the current environment's rig is loaded (captures wait on it).
@@ -2735,8 +2758,9 @@ export function createViewer(container, part) {
     isRealisticPending: () => realisticPending,
     onEnvironmentChange: (cb) => { envListeners.add(cb); return () => envListeners.delete(cb); },
     setPrintFrames,
-    setPrintFrameSource,
-    invalidatePrintFrames,
+    setSheetFrames,
+    setFrameSource,
+    invalidateFrames,
     whenRealisticReady,
     dispose,
   }, () => requestRender(API_GRACE_MS));

package/src/parts/laser-box.js

@@ -42,7 +42,7 @@ const hingeSlots = (k, p, d, pose, z) => d.hingeX.flatMap((hx) =>
   [hx - HINGE.tongueX, hx + HINGE.tongueX].map((x) =>
     k.shape2d(tab(p).slot).translate(worldToSheet(pose, [x, p.depth / 2, z]))));
 
-const PLY = { views: ["box"], display: { material: "oak" }, material: "birch plywood", thickness: (p) => p.t };
+const PLY = { views: ["box"], display: { material: "plywood" }, material: "birch plywood", thickness: (p) => p.t };
 const panel = (name, label, extra = {}) => sheetPart({
   ...PLY, label,
   profile: (k, p, d) => d.box[name].outline,       // drawn as seen from outside

package/src/parts/material-swatches.js

@@ -1,7 +1,10 @@
 // Dev-only contact sheet for the material library: one 30 mm sample per preset,
 // laid out in a grid, so a change to a preset or the pattern shader can be
-// judged by eye in every environment (materials.html). Not a reference part.
+// judged by eye in every environment (materials.html). The "Laser-cut" views
+// (below) do the same for the laser burn. Not a reference part.
 import { PRESETS } from "../framework/materials/presets.js";
+import { sheetPart } from "../framework/sheet/part.js";
+import { sheetHole } from "../framework/sheet/joinery.js";
 
 const ids = Object.keys(PRESETS);
 const COLS = 6, PITCH = 40;
@@ -19,10 +22,59 @@ const FILAMENT_COLOURS = [
 const withHole = (k) =>
   k.box({ size: [30, 30, 12] }).fillet({ r: 3 }).cut(k.cylinder({ r: 5, h: 20 }).translate([0, 0, -4]));
 
+// The "Laser-cut" view: sheet swatches as the laser burn draws them — each 30 × 30 with a
+// cut hole, an engraved label (its thickness) and a score line — in every wood at 3, 6 and
+// 9 mm; one oak panel standing on edge (posed, so its frame is not the identity); and the
+// looks that must NOT burn: a clear-acrylic sheet and an oak block that is not a sheet part.
+// "Laser-cut, unburnt" is its twin: the same swatches with an identity author `place`,
+// which shows plain wood (materials/sheet-look.js) — same geometry, same place, same
+// material — so the two views differ ONLY by the burn and scripts/capture-contact-sheet.mjs
+// can diff them pixel for pixel — and one row of sheets that name no material, drawn as
+// their stock (sheet-look.js STOCK_LOOKS).
+const SW = 30;
+const WOODS = ["plywood", "oak", "walnut"];
+const CONTROLS_Y = -WOODS.length * PITCH;
+const LASER_SWATCHES = [
+  ...WOODS.flatMap((material, row) => [3, 6, 9].map((t, col) => ({
+    key: `${material}_${t}`, label: `${PRESETS[material].label}, ${t} mm`, at: [col * PITCH, -row * PITCH], t, display: { material },
+  }))),
+  { key: "acrylic_3", label: "Clear acrylic, 3 mm", at: [0, CONTROLS_Y], t: 3, display: { material: "clear-acrylic" }, stock: "clear acrylic" },
+  { key: "oak_standing", label: "Oak, 3 mm, standing", at: [PITCH, CONTROLS_Y], t: 3, display: { material: "oak" }, standing: true },
+  { key: "oak_block", label: "Oak block (not a sheet part)", at: [2 * PITCH, CONTROLS_Y], t: 3, display: { material: "oak" }, block: true },
+  { key: "stock_plywood", label: "No material, \"birch plywood\" stock", at: [0, CONTROLS_Y - PITCH], t: 3, stock: "birch plywood" },
+  { key: "stock_acrylic", label: "No material, \"clear acrylic\" stock", at: [PITCH, CONTROLS_Y - PITCH], t: 3, stock: "clear acrylic" },
+  { key: "stock_stained", label: "A bare colour on \"birch plywood\" stock", at: [2 * PITCH, CONTROLS_Y - PITCH], t: 3, stock: "birch plywood", display: { color: 0x2e8b3d } },
+];
+
+function laserSwatch(s, unburnt) {
+  const [x, y] = s.at;
+  const common = {
+    label: unburnt ? `${s.label} (unburnt)` : s.label,
+    views: [unburnt ? "unburnt" : "laser"],
+    ...(s.display ? { display: s.display } : {}),
+  };
+  if (s.block) {
+    return { ...common, build: (k) => k.box({ min: [x, y, 0], max: [x + SW, y + SW, s.t] })
+      .cut(k.cylinder({ d: 8, h: s.t + 2 }).translate([x + 21, y + 21, -1])) };
+  }
+  // A standing swatch is drawn at the drawing origin; its pose stands it on edge at `at`.
+  const [u, v] = s.standing ? [0, 0] : [x, y];
+  return sheetPart({
+    ...common,
+    material: s.stock ?? "birch plywood",
+    thickness: s.t,
+    profile: (k) => k.shape2d([[u, v], [u + SW, v], [u + SW, v + SW], [u, v + SW]]).cut(sheetHole({ d: 8, at: [u + 21, v + 21] })),
+    engrave: (k) => k.text2d(String(s.t), { size: 10, align: "center", valign: "middle" }).translate([u + 9, v + 20]),
+    score: () => [[[u + 3, v + 7], [u + SW - 3, v + 7]]],
+    ...(s.standing ? { pose: { face: "-Y", up: "+Z", at: [x, y, 0] } } : {}),
+    ...(unburnt ? { place: (solid) => solid } : {}),
+  });
+}
+
 export default {
   meta: { title: "Material swatches", units: "mm", environment: "studio" },
   defaults: {},
-  views: { all: { label: "All presets", default: true }, colours: { label: "PLA colours" }, petg: { label: "PETG colours" }, print: { label: "Layer lines" } },
+  views: { all: { label: "All presets", default: true }, colours: { label: "PLA colours" }, petg: { label: "PETG colours" }, print: { label: "Layer lines" }, laser: { label: "Laser-cut" }, unburnt: { label: "Laser-cut, unburnt" } },
   parts: {
     ...Object.fromEntries(ids.map((id, i) => [id.replaceAll("-", "_"), {
       label: PRESETS[id].label,
@@ -65,5 +117,9 @@ export default {
       build: (k) => k.box({ size: [30, 12, 40] }).translate([50, 0, 0]),
       display: { material: "pla-print", color: 0xe0592a },
     },
+    ...Object.fromEntries(LASER_SWATCHES.flatMap((s) => [
+      [`laser_${s.key}`, laserSwatch(s, false)],
+      [`unburnt_${s.key}`, laserSwatch(s, true)],
+    ])),
   },
 };

package/types/part.d.ts

@@ -441,6 +441,10 @@ export interface SheetDeclaration<P = ResolvedParams, D = Derived> {
   pose: SheetPose | ((p: P, d: D) => SheetPose | null) | null;
   /** The build `sheetPart` made; `sub.build !== sub.sheet.generatedBuild` is a custom build. */
   generatedBuild: (k: GeometryKernel, p: P, d: D) => Solid;
+  /** The author's own `place` (the spec's), run after the pose; `null` when there is none. */
+  place: ((solid: Solid, ctx: PlaceContext<P, D>) => Solid) | null;
+  /** The `place` `sheetPart` installed (the pose, then the author's own), or `null`; `sub.place !== sub.sheet.generatedPlace` is a replaced place. */
+  generatedPlace: ((solid: Solid, ctx: PlaceContext<P, D>) => Solid) | null;
 }
 
 export interface ViewDefinition {