partforge 0.73.0 → 0.73.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "partforge",
-  "version": "0.73.0",
+  "version": "0.73.1",
   "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/measure/dim3-place.js

@@ -221,22 +221,91 @@ export function choicesEqual(a, b) {
 // The vertex realizing the extreme along `axis` over the posed meshes; ties
 // within tolerance (a flat base is all "the minimum") break toward `near`, so
 // the anchor lands on the side of the part the dimension is drawn on.
+//
+// placeBox asks for all six ±axis directions, and the naive shape of this —
+// one pass to find the extreme, a second to tie-break, per call — walked every
+// vertex twelve times over. On a soup carrying three points per triangle that
+// is the dominant cost of a placement, so the walk happens ONCE per (geometry,
+// pose) and every later call is answered from `extremeCache`: the six extreme
+// VALUES, plus, per direction, the posed vertices tied with that direction's
+// own extreme. `near` varies per call (it is the side the dim hangs off), so
+// the tie-break itself still runs — over the handful of tied points instead of
+// the whole soup.
+//
+// Per-mesh candidates are exact for the multi-mesh scan they feed: a vertex
+// within TIE_TOL of the GLOBAL extreme is necessarily within TIE_TOL of its own
+// mesh's extreme too (the mesh extreme sits between them), so nothing that
+// could win is missing from the union — and the loop below re-filters against
+// the global value regardless.
+//
+// A candidate is stored as its INDEX into the soup, not as a posed point: four
+// bytes instead of twenty-four, and the tie-break still runs the same f64
+// transform the un-cached version did, so the anchor it picks is bit-identical.
+// The size question that buys is a real one — most parts sit on a flat face, so
+// one direction's tie set can be a whole face of the mesh — and on the parts
+// this was measured against the whole cache lands around 0.1% of the soup.
+const TIE_TOL = 1e-3;
+// The extremes and the tie sets are both POSED, so a record is only valid for
+// the pose it was built from. A mesh's `matrix` is mutated in place by the
+// viewer's pose fast path (setSubPose), so identity says nothing about it — the
+// sixteen elements do.
+const extremeCache = new WeakMap(); // positions -> { pose, lo, hi, cand: Uint32Array[6] }
 const _sv = new THREE.Vector3();
-export function extremeVertex(meshData, axis, sign, near) {
-  let bestVal = sign > 0 ? -Infinity : Infinity;
-  for (const { positions, matrix } of meshData) {
+
+const dirIndex = (axis, sign) => axis * 2 + (sign > 0 ? 0 : 1);
+
+const samePose = (a, b) => {
+  for (let i = 0; i < 16; i++) if (a[i] !== b[i]) return false;
+  return true;
+};
+
+function meshExtremes(positions, matrix) {
+  const hit = extremeCache.get(positions);
+  if (hit && samePose(hit.pose, matrix.elements)) return hit;
+  const lo = [Infinity, Infinity, Infinity];
+  const hi = [-Infinity, -Infinity, -Infinity];
+  for (let i = 0; i < positions.length; i += 3) {
+    _sv.set(positions[i], positions[i + 1], positions[i + 2]).applyMatrix4(matrix);
+    for (let a = 0; a < 3; a++) {
+      const v = _sv.getComponent(a);
+      if (v < lo[a]) lo[a] = v;
+      if (v > hi[a]) hi[a] = v;
+    }
+  }
+  const cand = [[], [], [], [], [], []];
+  if (Number.isFinite(lo[0])) {
     for (let i = 0; i < positions.length; i += 3) {
       _sv.set(positions[i], positions[i + 1], positions[i + 2]).applyMatrix4(matrix);
-      const val = _sv.getComponent(axis);
-      if (sign > 0 ? val > bestVal : val < bestVal) bestVal = val;
+      for (let a = 0; a < 3; a++) {
+        const v = _sv.getComponent(a);
+        if (Math.abs(v - hi[a]) <= TIE_TOL) cand[a * 2].push(i);
+        if (Math.abs(v - lo[a]) <= TIE_TOL) cand[a * 2 + 1].push(i);
+      }
     }
   }
+  const rec = { pose: matrix.elements.slice(), lo, hi, cand: cand.map((c) => Uint32Array.from(c)) };
+  extremeCache.set(positions, rec);
+  return rec;
+}
+
+export function extremeVertex(meshData, axis, sign, near) {
+  const dir = dirIndex(axis, sign);
+  let bestVal = sign > 0 ? -Infinity : Infinity;
+  const scan = [];
+  for (const { positions, matrix } of meshData) {
+    const rec = meshExtremes(positions, matrix);
+    const v = sign > 0 ? rec.hi[axis] : rec.lo[axis];
+    if (!Number.isFinite(v)) continue; // empty mesh
+    scan.push({ positions, matrix, cand: rec.cand[dir] });
+    if (sign > 0 ? v > bestVal : v < bestVal) bestVal = v;
+  }
   if (!Number.isFinite(bestVal)) return null;
   let best = null, bestD = Infinity;
-  for (const { positions, matrix } of meshData) {
-    for (let i = 0; i < positions.length; i += 3) {
+  for (const { positions, matrix, cand } of scan) {
+    for (let k = 0; k < cand.length; k++) {
+      const i = cand[k];
       _sv.set(positions[i], positions[i + 1], positions[i + 2]).applyMatrix4(matrix);
-      if (Math.abs(_sv.getComponent(axis) - bestVal) > 1e-3) continue;
+      if (Math.abs(_sv.getComponent(axis) - bestVal) > TIE_TOL) continue;
       const d = _sv.distanceToSquared(near);
       if (d < bestD) { bestD = d; best = _sv.clone(); }
     }

package/src/framework/measure/measure-mode.js

@@ -19,6 +19,35 @@ import { createPinStore, occurrenceOf } from "./pins.js";
 import { evaluateChoices, choicesEqual, placeDims, specSig, laneCounts } from "./dim3-place.js";
 import { createDimScene } from "./dim3-scene.js";
 
+// How many distinct placements each cache holds. An orbit sweeps a bounded set
+// of side choices, and a session hovers a bounded set of features; anything
+// past that is ground the user has moved on from. Entries are plain drawing
+// records (numbers, no GL objects), so the ceiling is about retention hygiene
+// on a memory-tight device, not about a runaway.
+const PLACEMENT_CACHE_LIMIT = 32;
+
+// Bounded LRU. A Map iterates in insertion order, so re-inserting on a hit
+// moves the entry to the back and the oldest key is always the first one out.
+function keyedCache(limit) {
+  const entries = new Map();
+  return {
+    get(key) {
+      if (!entries.has(key)) return undefined;
+      const value = entries.get(key);
+      entries.delete(key);
+      entries.set(key, value);
+      return value;
+    },
+    set(key, value) {
+      entries.delete(key);
+      entries.set(key, value);
+      if (entries.size > limit) entries.delete(entries.keys().next().value);
+      return value;
+    },
+    clear() { entries.clear(); },
+  };
+}
+
 export function createMeasureMode(viewer, { part, getContext, revealParams, getParamsVersion, schedule = (cb) => requestAnimationFrame(cb) }) {
   const pins = createPinStore();
   const pinListeners = new Set();
@@ -218,7 +247,23 @@ export function createMeasureMode(viewer, { part, getContext, revealParams, getP
   // hover dim, which changes on every pointer move. placeBox scans every
   // vertex of the meshes it covers (tens of ms on a big part), so re-placing
   // the whole set per hover frame is the one path that must not exist.
-  const baseCache = { key: null, drawings: [] };
+  //
+  // Both caches are KEYED and bounded rather than one slot each. A one-slot
+  // cache is right for a monotonic sequence and wrong for an orbit, which
+  // sweeps back and forth over the same handful of side choices — measured at
+  // ~15 flips per 360° turn, every one of them a full re-place of ground
+  // already covered. Keyed, an orbit places each distinct choice once.
+  const baseCache = keyedCache(PLACEMENT_CACHE_LIMIT);
+  // ...and the PAINTED list — base plus the hover dim — cached the same way, on
+  // the base key plus everything the hover pass alone depends on. The hover
+  // spec is identical for every pointer position over one feature, so without
+  // this a pointer resting on a face re-ran that item's vertex scan and its
+  // surface raycasts on every single rAF.
+  const paintCache = keyedCache(PLACEMENT_CACHE_LIMIT);
+  // The drawing list currently on screen, held by IDENTITY: scene.update()
+  // rebuilds every child object (and repaints every label texture), so a list
+  // the cache just handed back unchanged must not reach it.
+  let painted = null;
   const _rc = new THREE.Raycaster();
   const _origin = new THREE.Vector3();
   const _dir = new THREE.Vector3();
@@ -274,12 +319,26 @@ export function createMeasureMode(viewer, { part, getContext, revealParams, getP
     return key;
   }
 
+  // The hover half of the choice table, which baseCacheKey deliberately omits
+  // (hover entries come and go with the pointer and must not evict the base).
+  // A camera move that flips which side the hovered dim hangs off has to
+  // re-place it, so the paint key carries them.
+  function hoverChoiceKey() {
+    let key = "";
+    for (const ck of Object.keys(choices)) {
+      if (!ck.startsWith("hover|")) continue;
+      const c = choices[ck];
+      key += `|${ck}=${c.key ?? ""}${c.du ? `,${c.du.map((n) => n.toFixed(4))}` : ""}`;
+    }
+    return key;
+  }
+
   function rebuild() {
     if (!enabled || !scene) return;
     const { items, meshes, bounds } = buildItems();
     lastItems = items;
     lastBounds = bounds ?? null;
-    if (!items.length || !bounds) { scene.clear(); baseCache.key = null; return; }
+    if (!items.length || !bounds) { scene.clear(); painted = null; return; }
     const env = buildEnv(meshes);
     choices = evaluateChoices(items, { camPos: env.camPos, center: centerOf(bounds), prev: choices });
     const place = (list, suppress, lanes) =>
@@ -287,10 +346,8 @@ export function createMeasureMode(viewer, { part, getContext, revealParams, getP
     const hoverItem = items.find((i) => i.id === "hover");
     const baseItems = hoverItem ? items.filter((i) => i !== hoverItem) : items;
     const key = baseCacheKey(`${units}|${meshSig()}`, baseItems);
-    if (baseCache.key !== key) {
-      baseCache.key = key;
-      baseCache.drawings = place(baseItems);
-    }
+    let baseDrawings = baseCache.get(key);
+    if (!baseDrawings) baseDrawings = baseCache.set(key, place(baseItems));
     // The hover pass can't see the base pass's items (they're cached), so it
     // hands over (a) their sigs as `suppress` — a hover duplicating an
     // already-drawn measurement (the sub-part bounds over the overall, a
@@ -298,13 +355,20 @@ export function createMeasureMode(viewer, { part, getContext, revealParams, getP
     // occupancy, so a hovered dim staggers into the SAME lane it will occupy
     // once pinned (pins append after the base items in the same order) and
     // clicking never moves it.
-    scene.update(hoverItem
-      ? baseCache.drawings.concat(place(
-          [hoverItem],
-          new Set(baseItems.map((i) => specSig(i.spec))),
-          laneCounts(baseCache.drawings),
-        ))
-      : baseCache.drawings);
+    const paintKey = hoverItem
+      ? `h|${key}|${specSig(hoverItem.spec)}|${hoverChoiceKey()}`
+      : `b|${key}`;
+    let drawings = paintCache.get(paintKey);
+    if (!drawings) {
+      drawings = paintCache.set(paintKey, hoverItem
+        ? baseDrawings.concat(place(
+            [hoverItem],
+            new Set(baseItems.map((i) => specSig(i.spec))),
+            laneCounts(baseDrawings),
+          ))
+        : baseDrawings);
+    }
+    if (painted !== drawings) { painted = drawings; scene.update(drawings); }
   }
 
   // ---- frame dirty check ---------------------------------------------------
@@ -500,8 +564,9 @@ export function createMeasureMode(viewer, { part, getContext, revealParams, getP
       scene?.clear();
       lastItems = [];
       lastBounds = null;
-      baseCache.key = null;
-      baseCache.drawings = [];
+      baseCache.clear();
+      paintCache.clear();
+      painted = null;
       dom.style.cursor = "";
     }
     notifyMode();