partforge 0.24.0 → 0.25.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "partforge",
-  "version": "0.24.0",
+  "version": "0.25.0",
   "description": "Turn a declarative part definition into a parametric-CAD web app (three.js + Manifold/Replicad). Requires a Vite-based consumer.",
   "type": "module",
   "license": "MIT",

package/src/framework/viewer-lighting.js

@@ -1,13 +1,66 @@
 import * as THREE from "three";
 
+const KEY_COLOR = 0xffffff, KEY_INTENSITY = 1.45;
+const FILL_COLOR = 0xe5efff, FILL_INTENSITY = 0.65;
+
 export function addViewerLights(scene) {
   const hemisphere = new THREE.HemisphereLight(0xdce9ff, 0x687586, 1.35);
-  const key = new THREE.DirectionalLight(0xffffff, 1.45);
+  const key = new THREE.DirectionalLight(KEY_COLOR, KEY_INTENSITY);
   key.position.set(8, 14, 10);
-  const fill = new THREE.DirectionalLight(0xe5efff, 0.65);
+  const fill = new THREE.DirectionalLight(FILL_COLOR, FILL_INTENSITY);
   fill.position.set(-10, 6, -8);
 
   scene.add(hemisphere, key, fill);
 
   return { hemisphere, key, fill };
 }
+
+// The key/fill above are fixed in WORLD space, which is right for a user who orbits
+// into the lit hemisphere and wrong for an offscreen canonical-view capture: `bottom`,
+// `back`, and `left` stare at faces the key at (8,14,10) never reaches, so they come
+// back flat — hemisphere ambient only, with no shading gradient to reveal a chamfer or
+// a 1 mm snap barb. These two lights are the capture-time stand-ins, swapped in for the
+// duration of one offscreen render (see viewer.js renderOffscreen) and posed relative to
+// the view axis, so every canonical view is exposed and shaded the same way.
+export function createCaptureLights() {
+  const key = new THREE.DirectionalLight(KEY_COLOR, KEY_INTENSITY);
+  const fill = new THREE.DirectionalLight(FILL_COLOR, FILL_INTENSITY);
+  return { key, fill };
+}
+
+// Offsets from the camera, in camera-space multiples of the camera-to-target distance:
+// the key sits over the viewer's shoulder (up and to the right, ~41° off the view axis),
+// the fill opposes it from the left at eye level. Both still shine mostly ALONG the view
+// direction, so whatever the camera can see is lit.
+const KEY_OFFSET = { right: 0.45, up: 0.75 };
+const FILL_OFFSET = { right: -0.7, up: 0.15 };
+
+const sub = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+const cross = (a, b) => [
+  a[1] * b[2] - a[2] * b[1],
+  a[2] * b[0] - a[0] * b[2],
+  a[0] * b[1] - a[1] * b[0],
+];
+const length = (v) => Math.hypot(v[0], v[1], v[2]);
+const norm = (v) => {
+  const l = length(v) || 1;
+  return [v[0] / l, v[1] / l, v[2] / l];
+};
+
+// World-space positions for the capture key/fill, given a camera pose (the same
+// `{position, up, target}` shape cameraPoseForView returns). Pure — no THREE, no scene.
+export function captureLightPoses({ position, up, target }) {
+  const forward = norm(sub(target, position));
+  // Camera basis. A canonical view never passes an `up` parallel to its own view axis,
+  // but a caller could, and a degenerate basis would put NaN into the light positions.
+  let right = cross(forward, up);
+  if (length(right) < 1e-6) right = cross(forward, [0, 0, 1]);
+  if (length(right) < 1e-6) right = cross(forward, [0, 1, 0]);
+  right = norm(right);
+  const trueUp = norm(cross(right, forward));
+  const dist = length(sub(target, position)) || 1;
+  const place = (offset) => [0, 1, 2].map(
+    (i) => position[i] + (right[i] * offset.right + trueUp[i] * offset.up) * dist,
+  );
+  return { key: place(KEY_OFFSET), fill: place(FILL_OFFSET) };
+}

package/src/framework/viewer.js

@@ -5,9 +5,35 @@ 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";
+import { addViewerLights, captureLightPoses, createCaptureLights } from "./viewer-lighting.js";
 import { CANONICAL_VIEWS, cameraPoseForView } from "./view-angles.js";
 
+// three renders into a render target in the LINEAR working colour space: as of r184
+// WebGLRenderer only applies `outputColorSpace` on the canvas path (WebGLPrograms
+// substitutes workingColorSpace whenever a render target is bound), so readback pixels
+// are linear no matter what the target texture's colorSpace says. Writing them straight
+// into a JPEG is what made captured views come back muddy and dark compared to the live
+// canvas. Encode the transfer function ourselves. The 8-bit LUT loses precision only in
+// the deepest shadows, which a quality-0.9 JPEG would not have preserved anyway.
+const SRGB8 = (() => {
+  const table = new Uint8Array(256);
+  for (let i = 0; i < 256; i++) {
+    const l = i / 255;
+    table[i] = Math.round(255 * (l <= 0.0031308 ? 12.92 * l : 1.055 * l ** (1 / 2.4) - 0.055));
+  }
+  return table;
+})();
+
+// Linear RGBA bytes → sRGB, in place. Alpha is a coverage value, not a colour: untouched.
+export function srgbEncodeInPlace(data) {
+  for (let i = 0; i < data.length; i += 4) {
+    data[i] = SRGB8[data[i]];
+    data[i + 1] = SRGB8[data[i + 1]];
+    data[i + 2] = SRGB8[data[i + 2]];
+  }
+  return data;
+}
+
 // Render a set of canonical views without disturbing the live camera/canvas.
 // `renderer.renderOffscreen(pose)` does the GL work (temp camera → offscreen
 // target → readback → JPEG data URL); injected so this is unit-testable without
@@ -57,7 +83,7 @@ export function createViewer(container, part) {
   controls.autoRotateSpeed = 1.6;
 
   // --- lights + grid --------------------------------------------------------
-  addViewerLights(scene);
+  const liveLights = 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
@@ -288,19 +314,47 @@ export function createViewer(container, part) {
   // Offscreen render of the shared scene from an arbitrary pose → JPEG data URL.
   // A separate WebGLRenderTarget + temp camera means the visible canvas and the
   // live `camera` are never touched. WebGL pixels are bottom-up, so flip on encode.
-  const _rtSize = 512;
+  //
+  // These captures are read by a model, not shown as a thumbnail (partforge-cloud's
+  // render_part_views tool feeds them straight to the agent), so they are sized and lit
+  // for reading small features: 1024² is the largest square that fits Anthropic's
+  // ~1.15 MP no-downscale budget, 4× MSAA keeps a thin wall from aliasing into noise,
+  // and the light rig follows the camera so no view is a flat silhouette.
+  const _rtSize = 1024;
   let _rt = null;
+  let _capLights = null;
   function renderOffscreen({ position, up, target }) {
-    _rt = _rt ?? new THREE.WebGLRenderTarget(_rtSize, _rtSize);
+    _rt = _rt ?? new THREE.WebGLRenderTarget(_rtSize, _rtSize, { samples: 4 });
+    _capLights = _capLights ?? createCaptureLights();
     const cam = new THREE.PerspectiveCamera(45, 1, 0.1, 1000);
     cam.position.set(position[0], position[1], position[2]);
     cam.up.set(up[0], up[1], up[2]);
     cam.lookAt(target[0], target[1], target[2]);
-    renderer.setRenderTarget(_rt);
-    renderer.render(scene, cam);
     const buf = new Uint8Array(_rtSize * _rtSize * 4);
-    renderer.readRenderTargetPixels(_rt, 0, 0, _rtSize, _rtSize, buf);
-    renderer.setRenderTarget(null);
+    // Swap the world-fixed key/fill for the camera-relative pair, for this one render
+    // only. A DirectionalLight aims at its `target`, whose matrixWorld only updates
+    // while it is in the scene graph, so both go in and both come back out.
+    const poses = captureLightPoses({ position, up, target });
+    const { key: capKey, fill: capFill } = _capLights;
+    capKey.position.set(poses.key[0], poses.key[1], poses.key[2]);
+    capFill.position.set(poses.fill[0], poses.fill[1], poses.fill[2]);
+    for (const light of [capKey, capFill]) light.target.position.set(target[0], target[1], target[2]);
+    liveLights.key.visible = false;
+    liveLights.fill.visible = false;
+    scene.add(capKey, capKey.target, capFill, capFill.target);
+    try {
+      renderer.setRenderTarget(_rt);
+      renderer.render(scene, cam);
+      // render() resolves the multisample renderbuffer into the target texture, so this
+      // reads antialiased pixels.
+      renderer.readRenderTargetPixels(_rt, 0, 0, _rtSize, _rtSize, buf);
+    } finally {
+      // Never leave the user's own view unlit or pointed at the offscreen target.
+      renderer.setRenderTarget(null);
+      scene.remove(capKey, capKey.target, capFill, capFill.target);
+      liveLights.key.visible = true;
+      liveLights.fill.visible = true;
+    }
     const canvas = document.createElement("canvas");
     canvas.width = _rtSize; canvas.height = _rtSize;
     const ctx = canvas.getContext("2d");
@@ -310,8 +364,9 @@ export function createViewer(container, part) {
       const src = (_rtSize - 1 - y) * _rtSize * 4;
       img.data.set(buf.subarray(src, src + _rtSize * 4), y * _rtSize * 4);
     }
+    srgbEncodeInPlace(img.data);
     ctx.putImageData(img, 0, 0);
-    return canvas.toDataURL("image/jpeg", 0.8);
+    return canvas.toDataURL("image/jpeg", 0.9);
   }
 
   // Render the canonical camera angles offscreen, framed to whatever is visible,