partforge 0.121.0 → 0.122.0

package/src/framework/realistic-controls.js

@@ -0,0 +1,78 @@
+// Viewbar chrome for realistic mode: a toggle button and an environment <select>.
+// Both optional (a host without the elements simply has no built-in controls and
+// drives runtime.renderMode / runtime.environment itself). Same shape as
+// viewer-controls.js. The state shown is always the viewer's: the toggle is
+// pressed only once realistic has actually landed, and the menu shows the
+// environment in effect (a failed switch snaps it back).
+import { ENVIRONMENTS } from "./materials/environments.js";
+import { saveRenderMode, saveEnvironment } from "./view-state.js";
+import { attachButtonTooltips } from "./tooltip.js";
+
+const LABEL = "Realistic view";
+const ERROR_LABEL = "Couldn't load realistic view";
+
+export function attachRealisticControls(viewer, { toggle, envMenu } = {}, { tooltip } = {}) {
+  const binding = tooltip && toggle ? attachButtonTooltips(tooltip, [{ element: toggle }]) : null;
+  if (envMenu && !envMenu.options.length) {
+    for (const env of Object.values(ENVIRONMENTS)) {
+      const o = document.createElement("option");
+      o.value = env.id;
+      o.textContent = env.label;
+      envMenu.append(o);
+    }
+    envMenu.setAttribute("aria-label", "Environment");
+  }
+
+  // The last mode event's busy/error, so an environment event or sync() —
+  // which carry neither — re-render without clearing them.
+  let busy = false;
+  let error = null;
+
+  function render() {
+    const mode = viewer.getRenderMode();
+    if (toggle) {
+      const on = mode === "realistic";
+      toggle.classList.toggle("on", on);
+      toggle.setAttribute("aria-pressed", String(on));
+      if (busy) toggle.dataset.busy = "true"; else delete toggle.dataset.busy;
+      const label = error ? ERROR_LABEL : LABEL;
+      toggle.setAttribute("aria-label", label);
+      if (!tooltip) toggle.title = label;
+    }
+    if (envMenu) {
+      envMenu.hidden = mode !== "realistic";
+      envMenu.value = viewer.getEnvironment();
+    }
+    binding?.sync();
+  }
+
+  // A click while realistic is still loading is a change of mind: back to CAD.
+  // What persists is what the viewer says took effect, not what was asked for.
+  const onToggle = () => {
+    const next = viewer.getRenderMode() === "realistic" || busy ? "cad" : "realistic";
+    viewer.setRenderMode(next).then(saveRenderMode, () => {});
+  };
+  const onEnv = () => {
+    viewer.setEnvironment(envMenu.value).then(saveEnvironment, () => {});
+  };
+  toggle?.addEventListener("click", onToggle);
+  envMenu?.addEventListener("change", onEnv);
+  const offMode = viewer.onRenderModeChange((e) => {
+    busy = !!e?.busy;
+    error = e?.error ?? null;
+    render();
+  });
+  const offEnv = viewer.onEnvironmentChange(() => render());
+  render();
+
+  return {
+    sync: render,
+    detach() {
+      toggle?.removeEventListener("click", onToggle);
+      envMenu?.removeEventListener("change", onEnv);
+      offMode();
+      offEnv();
+      binding?.detach();
+    },
+  };
+}

package/src/framework/selection/feature-highlight.js

@@ -40,6 +40,8 @@ export function createFeatureHighlight(viewer) {
   const overlay = new THREE.Mesh(emptyOverlayGeometry, material);
   overlay.visible = false;
   overlay.renderOrder = CUTAWAY_OVERLAY_RENDER_ORDER;
+  // Pointer feedback, never part of a capture (it tints what it covers).
+  const unregisterCapture = viewer.registerCaptureHidden?.(overlay) ?? (() => {});
   let overlayParent = null;
   // Subset cache per sub-part: rebuilt when the sub-part's geometry object
   // changes (i.e. after a regenerate) — keyed on the geometry instance.
@@ -91,6 +93,7 @@ export function createFeatureHighlight(viewer) {
         () => subsets.clear(),
         () => emptyOverlayGeometry?.dispose(),
         unregisterCutaway,
+        unregisterCapture,
         () => material.dispose(),
       );
       runCleanupSteps(steps, "feature highlight cleanup failed");

package/src/framework/view-state.js

@@ -6,12 +6,17 @@
 // and a fresh session opens on the part's own default (see default-view.js).
 // Reads/writes are guarded: if storage is unavailable (private mode, disabled) or a
 // value is corrupt, reads return the documented default and writes are no-ops —
-// persistence never throws.
+// persistence never throws. `renderMode` and `environment` are viewer
+// preferences like `theme`; in the cloud's opaque-origin sandbox storage throws,
+// so there the host carries them in viewerState instead.
+import { ENVIRONMENTS } from "./materials/environments.js";
 
 const KEY = {
   camera: "partforge:camera",
   theme: "partforge:theme",
   projection: "partforge:projection",
+  renderMode: "partforge:renderMode",
+  environment: "partforge:environment",
 };
 
 const viewKey = (partKey) => `partforge:view:${partKey}`;
@@ -64,6 +69,27 @@ export function saveProjection(mode) {
   if (mode === "perspective" || mode === "orthographic") write(KEY.projection, mode);
 }
 
+// null = nothing (valid) stored — the caller falls back to "cad".
+export function loadRenderMode() {
+  const raw = read(KEY.renderMode);
+  return raw === "realistic" || raw === "cad" ? raw : null;
+}
+
+export function saveRenderMode(mode) {
+  if (mode === "cad" || mode === "realistic") write(KEY.renderMode, mode);
+}
+
+// null = nothing stored, or an id this version doesn't know — the caller falls
+// back to the part's own meta.environment.
+export function loadEnvironment() {
+  const raw = read(KEY.environment);
+  return raw && Object.hasOwn(ENVIRONMENTS, raw) ? raw : null;
+}
+
+export function saveEnvironment(id) {
+  if (typeof id === "string" && Object.hasOwn(ENVIRONMENTS, id)) write(KEY.environment, id);
+}
+
 // `partKey` identifies the part — createViewTabs passes `meta.title`. Without one
 // there is nothing safe to key on, so both calls no-op rather than falling back to a
 // shared key (the cross-part bleed this scoping exists to remove).