partforge 0.19.0 → 0.20.1

package/src/framework/cutaway.js

@@ -0,0 +1,469 @@
+import * as THREE from "three";
+
+import { createCutawayGizmo } from "./cutaway-gizmo.js";
+import {
+  initialCutawayPose,
+  planeFromPose,
+  pointSurvivesPlane,
+} from "./cutaway-math.js";
+import { createSectionRenderSet } from "./cutaway-render.js";
+
+const IDLE_DELAY_MS = 800;
+
+function defaultSchedule(callback, delay) {
+  const timer = setTimeout(callback, delay);
+  return () => clearTimeout(timer);
+}
+
+function validBounds(getBounds) {
+  try {
+    const bounds = getBounds?.();
+    return bounds?.isBox3 && !bounds.isEmpty() ? bounds : null;
+  } catch {
+    return null;
+  }
+}
+
+export function createCutaway({
+  renderer,
+  scene,
+  camera,
+  orbitControls,
+  domElement,
+  getBounds,
+  edgeColor,
+  schedule = defaultSchedule,
+}) {
+  let supported = false;
+  try {
+    supported = Boolean(
+      renderer.getContext().getContextAttributes().stencil,
+    );
+  } catch {
+    supported = false;
+  }
+
+  const plane = new THREE.Plane();
+  const planeNormal = new THREE.Vector3();
+  const capGeometry = new THREE.PlaneGeometry(1, 1);
+  const overlayScene = new THREE.Scene();
+  const renderSets = new Map();
+  const auxiliaryMaterials = new Map();
+  let selectedNames = null;
+  let nextOrder = 0;
+  let enabled = false;
+  let flipped = false;
+  let theme = "dark";
+  let hatchInk = edgeColor;
+  let pose = null;
+  let viewportSize = null;
+  let cancelIdle = null;
+  let previousLocalClippingEnabled;
+  let disposed = false;
+  let disabling = false;
+  let hoveredHandle = null;
+  const handleHoverSubscribers = new Set();
+  const pendingHandlePublications = [];
+  let publishingHandleHover = false;
+
+  function reportHandleHoverError(error) {
+    try {
+      console.error("Cutaway handle hover subscriber failed", error);
+    } catch {
+      // Reporting must not let application callbacks interrupt controller work.
+    }
+  }
+
+  function drainHandleHoverPublications() {
+    while (pendingHandlePublications.length > 0) {
+      const publication = pendingHandlePublications.shift();
+      for (const record of publication.subscribers) {
+        if (!record.active) continue;
+        try {
+          record.listener(publication.handle);
+        } catch (error) {
+          reportHandleHoverError(error);
+        }
+      }
+    }
+  }
+
+  function publishHandleHover(nextHandle) {
+    const normalized = nextHandle === "translate"
+      || nextHandle === "rotate-x"
+      || nextHandle === "rotate-y"
+      ? nextHandle
+      : null;
+    if (normalized === hoveredHandle) return;
+    hoveredHandle = normalized;
+    pendingHandlePublications.push({
+      handle: normalized,
+      subscribers: [...handleHoverSubscribers],
+    });
+    if (publishingHandleHover) return;
+
+    publishingHandleHover = true;
+    try {
+      drainHandleHoverPublications();
+    } finally {
+      publishingHandleHover = false;
+    }
+  }
+
+  function onHandleHoverChange(listener) {
+    if (disposed || typeof listener !== "function") return () => {};
+    const record = { listener, active: true };
+    handleHoverSubscribers.add(record);
+    try {
+      listener(hoveredHandle);
+    } catch (error) {
+      record.active = false;
+      handleHoverSubscribers.delete(record);
+      throw error;
+    }
+    return () => {
+      if (!record.active) return;
+      record.active = false;
+      handleHoverSubscribers.delete(record);
+    };
+  }
+
+  function clearHandleHoverSubscribers() {
+    for (const record of handleHoverSubscribers) record.active = false;
+    handleHoverSubscribers.clear();
+  }
+
+  function selected(name) {
+    return selectedNames == null || selectedNames.has(name);
+  }
+
+  function applyCapPose(renderSet) {
+    if (!pose) return;
+    renderSet.setCapPose({
+      position: pose.position,
+      quaternion: pose.quaternion,
+      size: pose.size,
+    });
+  }
+
+  function cancelIdleFade() {
+    if (!cancelIdle) return;
+    cancelIdle();
+    cancelIdle = null;
+  }
+
+  function showActive() {
+    cancelIdleFade();
+    gizmo.setActiveAppearance(true);
+    const scheduled = schedule(() => {
+      cancelIdle = null;
+      if (enabled && !disposed) gizmo.setActiveAppearance(false);
+    }, IDLE_DELAY_MS);
+    cancelIdle = typeof scheduled === "function"
+      ? scheduled
+      : () => clearTimeout(scheduled);
+  }
+
+  function setMaterialClippingPlanes(material, clippingPlanes) {
+    if (material.clippingPlanes === clippingPlanes) return;
+    material.clippingPlanes = clippingPlanes;
+    material.needsUpdate = true;
+  }
+
+  function syncAuxiliaryMaterial(material, entry) {
+    if (enabled) {
+      if (
+        !Array.isArray(material.clippingPlanes)
+        || material.clippingPlanes.length !== 1
+        || material.clippingPlanes[0] !== plane
+      ) {
+        setMaterialClippingPlanes(material, [plane]);
+      }
+    } else {
+      setMaterialClippingPlanes(material, entry.originalClippingPlanes);
+    }
+  }
+
+  function syncAuxiliaryMaterials() {
+    for (const [material, entry] of auxiliaryMaterials) {
+      syncAuxiliaryMaterial(material, entry);
+    }
+  }
+
+  function applyPose(nextPose, { resetFlip = false, activeAppearance = false } = {}) {
+    pose = {
+      position: nextPose.position.clone(),
+      quaternion: nextPose.quaternion.clone(),
+      size: nextPose.size,
+    };
+    if (resetFlip) flipped = false;
+    planeFromPose(plane, planeNormal, pose.position, pose.quaternion, flipped);
+    for (const { renderSet } of renderSets.values()) applyCapPose(renderSet);
+    gizmo.setFlipped(flipped);
+    gizmo.setPose(pose);
+    if (activeAppearance) showActive();
+  }
+
+  function onPoseChange(nextPose) {
+    if (!enabled || disposed) return;
+    applyPose(nextPose, { activeAppearance: true });
+  }
+
+  const gizmo = createCutawayGizmo({
+    scene,
+    overlayScene,
+    camera,
+    domElement,
+    orbitControls,
+    onPoseChange,
+    onActivity: showActive,
+    onHandleHoverChange: publishHandleHover,
+  });
+  gizmo.setVisible(false);
+  gizmo.setTheme(theme);
+
+  function setSubpart(name, mesh, edgeLines) {
+    if (disposed) return false;
+    const previous = renderSets.get(name);
+    const order = previous?.order ?? nextOrder++;
+    previous?.renderSet.dispose();
+
+    const renderSet = createSectionRenderSet({
+      scene,
+      mesh,
+      edgeLines,
+      plane,
+      capGeometry,
+      order,
+      inkColor: hatchInk,
+    });
+    renderSets.set(name, { renderSet, mesh, edgeLines, order });
+    if (viewportSize) {
+      renderSet.setViewportSize(
+        viewportSize.width,
+        viewportSize.height,
+        viewportSize.pixelRatio,
+      );
+    }
+    applyCapPose(renderSet);
+    renderSet.setVisible(enabled && selected(name));
+    renderSet.setEnabled(enabled);
+    return true;
+  }
+
+  function updateGeometry(name, geometry) {
+    const entry = renderSets.get(name);
+    if (!entry || disposed) return false;
+    entry.renderSet.setGeometry(geometry);
+    return true;
+  }
+
+  function setVisible(names) {
+    if (disposed) return false;
+    selectedNames = new Set(typeof names === "string" ? [names] : names ?? []);
+    for (const [name, { renderSet }] of renderSets) {
+      renderSet.setVisible(enabled && selected(name));
+    }
+    return true;
+  }
+
+  function disable() {
+    if (disabling) return true;
+    disabling = true;
+    let firstError = null;
+    const attempt = (callback) => {
+      try {
+        callback();
+      } catch (error) {
+        firstError ??= error;
+      }
+    };
+    const wasEnabled = enabled;
+    enabled = false;
+    try {
+      attempt(cancelIdleFade);
+      attempt(() => gizmo.setVisible(false));
+      publishHandleHover(null);
+      if (wasEnabled) {
+        for (const { renderSet } of renderSets.values()) {
+          attempt(() => renderSet.setVisible(false));
+          attempt(() => renderSet.setEnabled(false));
+        }
+        for (const [material, entry] of auxiliaryMaterials) {
+          attempt(() => syncAuxiliaryMaterial(material, entry));
+        }
+        attempt(() => {
+          renderer.localClippingEnabled = previousLocalClippingEnabled;
+        });
+        previousLocalClippingEnabled = undefined;
+      }
+    } finally {
+      disabling = false;
+    }
+    if (firstError) throw firstError;
+    return true;
+  }
+
+  function setEnabled(on) {
+    if (disposed || disabling) return false;
+    if (!on) return disable();
+    if (enabled) return true;
+    if (!supported) return false;
+    const bounds = validBounds(getBounds);
+    if (!bounds) return false;
+
+    const initialPose = initialCutawayPose(bounds, camera);
+    previousLocalClippingEnabled = renderer.localClippingEnabled;
+    enabled = true;
+    flipped = false;
+    applyPose(initialPose);
+    renderer.localClippingEnabled = true;
+    for (const [name, { renderSet }] of renderSets) {
+      renderSet.setVisible(selected(name));
+      renderSet.setEnabled(true);
+    }
+    syncAuxiliaryMaterials();
+    gizmo.setVisible(true);
+    gizmo.updateForCamera();
+    showActive();
+    return true;
+  }
+
+  function reset() {
+    if (!enabled || disposed) return false;
+    const bounds = validBounds(getBounds);
+    if (!bounds) return false;
+    applyPose(initialCutawayPose(bounds, camera), {
+      resetFlip: true,
+      activeAppearance: true,
+    });
+    return true;
+  }
+
+  function flip() {
+    if (!enabled || disposed || !pose) return false;
+    flipped = !flipped;
+    planeFromPose(plane, planeNormal, pose.position, pose.quaternion, flipped);
+    gizmo.setFlipped(flipped);
+    showActive();
+    return true;
+  }
+
+  function setTheme(mode, edgeColor) {
+    if (disposed) return false;
+    theme = mode;
+    if (edgeColor != null) hatchInk = edgeColor;
+    gizmo.setTheme(mode);
+    for (const { renderSet } of renderSets.values()) {
+      renderSet.refreshSourceMaterial();
+      renderSet.setHatchInk(hatchInk);
+    }
+    return true;
+  }
+
+  function setViewportSize(width, height, pixelRatio = 1) {
+    if (disposed) return false;
+    viewportSize = { width, height, pixelRatio };
+    for (const { renderSet } of renderSets.values()) {
+      renderSet.setViewportSize(width, height, pixelRatio);
+    }
+    return true;
+  }
+
+  function isPointVisible(point) {
+    return !enabled || pointSurvivesPlane(plane, point);
+  }
+
+  function registerClippableMaterial(material) {
+    if (disposed || !material) return () => {};
+    let entry = auxiliaryMaterials.get(material);
+    if (entry) {
+      entry.count += 1;
+    } else {
+      entry = {
+        count: 1,
+        originalClippingPlanes: material.clippingPlanes,
+      };
+      auxiliaryMaterials.set(material, entry);
+    }
+    syncAuxiliaryMaterial(material, entry);
+    let registered = true;
+    return () => {
+      if (!registered) return;
+      registered = false;
+      const current = auxiliaryMaterials.get(material);
+      if (!current) return;
+      current.count -= 1;
+      if (current.count > 0) {
+        return;
+      }
+      auxiliaryMaterials.delete(material);
+      setMaterialClippingPlanes(material, current.originalClippingPlanes);
+    };
+  }
+
+  function updateForCamera() {
+    if (enabled && !disposed) gizmo.updateForCamera();
+  }
+
+  function renderOverlay(targetRenderer, targetCamera) {
+    if (!enabled || disposed) return false;
+    const previousAutoClear = targetRenderer.autoClear;
+    try {
+      targetRenderer.autoClear = false;
+      targetRenderer.clearDepth();
+      targetRenderer.render(overlayScene, targetCamera);
+    } finally {
+      targetRenderer.autoClear = previousAutoClear;
+    }
+    return true;
+  }
+
+  function dispose() {
+    if (disposed) return;
+    disposed = true;
+    let firstError = null;
+    const attempt = (callback) => {
+      try {
+        callback();
+      } catch (error) {
+        firstError ??= error;
+      }
+    };
+    attempt(disable);
+    for (const { renderSet } of renderSets.values()) {
+      attempt(() => renderSet.dispose());
+    }
+    renderSets.clear();
+    for (const [material, entry] of auxiliaryMaterials) {
+      attempt(() => setMaterialClippingPlanes(material, entry.originalClippingPlanes));
+    }
+    auxiliaryMaterials.clear();
+    attempt(() => gizmo.dispose());
+    publishHandleHover(null);
+    drainHandleHoverPublications();
+    clearHandleHoverSubscribers();
+    attempt(() => overlayScene.clear());
+    attempt(() => capGeometry.dispose());
+    if (firstError) throw firstError;
+  }
+
+  return {
+    get isSupported() { return supported; },
+    get isEnabled() { return enabled; },
+    setSubpart,
+    updateGeometry,
+    setVisible,
+    setEnabled,
+    reset,
+    flip,
+    setTheme,
+    setViewportSize,
+    isPointVisible,
+    registerClippableMaterial,
+    updateForCamera,
+    renderOverlay,
+    onHandleHoverChange,
+    dispose,
+  };
+}

package/src/framework/fonts.js

@@ -0,0 +1,36 @@
+// Resolve a part's declared `fonts` ({ name: source }) to ArrayBuffers, before the
+// synchronous build. A source is: an ArrayBuffer/Uint8Array (bytes), a URL string
+// (fetched — a Vite `import('./x.ttf')` yields { default: url }), or a thunk
+// returning any of those (possibly async). Memoized process-wide by source so
+// repeated builds don't refetch. DOM-free (uses global fetch, present in workers).
+const cache = new Map(); // source (string|object) → Promise<ArrayBuffer>
+
+function toBuffer(v) {
+  if (v instanceof ArrayBuffer) return v;
+  // A view may not span its whole backing buffer — slice to its exact range (Node Buffer
+  // pooling makes byteOffset>0 common for small files; v.buffer alone would be garbage).
+  if (ArrayBuffer.isView(v)) return v.buffer.slice(v.byteOffset, v.byteOffset + v.byteLength);
+  return null;
+}
+
+async function resolveOne(source) {
+  if (cache.has(source)) return cache.get(source);
+  const p = (async () => {
+    let v = source;
+    if (typeof v === "function") v = await v();
+    if (v && typeof v === "object" && "default" in v && !toBuffer(v)) v = v.default; // dynamic-import module
+    const buf = toBuffer(v);
+    if (buf) return buf;
+    if (typeof v === "string") return await (await fetch(v)).arrayBuffer();
+    throw new Error("resolveFonts: a font source must be bytes, a URL string, or a thunk returning one");
+  })();
+  cache.set(source, p);
+  return p;
+}
+
+export async function resolveFonts(fontsDecl) {
+  const out = new Map();
+  if (!fontsDecl) return out;
+  await Promise.all(Object.entries(fontsDecl).map(async ([name, src]) => out.set(name, await resolveOne(src))));
+  return out;
+}

package/src/framework/geometry/curve-fill.js

@@ -0,0 +1,86 @@
+// Resolve raw glyph outlines (self-intersecting / overlapping cubic contours) into
+// simple, correctly-nested {outer,holes} curve regions under the requested font fill
+// rule. Beziers are split where needed but never flattened.
+//
+// The required recipe is:
+//   1. resolveCrossings() each contour individually;
+//   2. CompoundPath of all the simple sub-paths;
+//   3. set the font's nonzero/evenodd rule;
+//   4. unite(self) to normalize overlaps and crossings into simple paths.
+import paper from "paper/dist/paper-core.js";
+
+// Never use paper's package-global project: another consumer in the same worker may import
+// paper too. This resolver owns and clears only this private, headless scope.
+const scope = new paper.PaperScope();
+scope.setup(new scope.Size(1, 1));
+
+function toPaperPath(contour) {
+  const path = new scope.Path({ insert: false });
+  path.moveTo(new scope.Point(contour.start[0], contour.start[1]));
+  for (const s of contour.segments) {
+    if (s.c1) path.cubicCurveTo(
+      new scope.Point(s.c1[0], s.c1[1]),
+      new scope.Point(s.c2[0], s.c2[1]),
+      new scope.Point(s.to[0], s.to[1]));
+    else path.lineTo(new scope.Point(s.to[0], s.to[1]));
+  }
+  path.closePath();
+  return path;
+}
+
+function toContour(path) {
+  const segs = path.segments;
+  const start = [segs[0].point.x, segs[0].point.y];
+  const out = { start, segments: [] };
+  for (let i = 0; i < segs.length; i++) {
+    const a = segs[i], b = segs[(i + 1) % segs.length];
+    const straight = a.handleOut.isZero() && b.handleIn.isZero();
+    const closing = i === segs.length - 1;
+    if (closing && straight) continue;                 // implicit straight close
+    const to = [b.point.x, b.point.y];
+    if (straight) out.segments.push({ to });
+    else out.segments.push({ to, c1: [a.point.x + a.handleOut.x, a.point.y + a.handleOut.y], c2: [b.point.x + b.handleIn.x, b.point.y + b.handleIn.y] });
+  }
+  return out;
+}
+
+// Group while paths are still Paper geometry. Path.area includes cubic handles and
+// interiorPoint is guaranteed to lie inside the curve; never reduce curves to endpoint rings.
+function groupPaperPaths(paths) {
+  const largest = paths.reduce((a, b) => Math.abs(b.area) > Math.abs(a.area) ? b : a);
+  const outerClockwise = largest.clockwise;
+  const outers = paths.filter((p) => p.clockwise === outerClockwise)
+    .map((path) => ({ path, holes: [] }));
+  for (const hole of paths.filter((p) => p.clockwise !== outerClockwise)) {
+    const home = outers.filter((o) => o.path.contains(hole.interiorPoint))
+      .sort((a, b) => Math.abs(a.path.area) - Math.abs(b.path.area))[0];
+    if (!home) throw new Error("curve-fill: resolved hole has no containing outer");
+    home.holes.push(hole);
+  }
+  return outers.map(({ path, holes }) => ({
+    outer: toContour(path),
+    holes: holes.map(toContour),
+  }));
+}
+
+export function resolveCurveFill(contours, { fillRule = "nonzero" } = {}) {
+  if (fillRule !== "nonzero" && fillRule !== "evenodd")
+    throw new Error('curve-fill: fillRule must be "nonzero" or "evenodd"');
+  if (!contours || contours.length === 0) return [];
+  try {
+    const simple = [];
+    for (const ct of contours) {
+      const resolved = toPaperPath(ct).resolveCrossings();
+      const kids = resolved.className === "CompoundPath" ? resolved.children : [resolved];
+      for (const k of kids) if (k.segments && k.segments.length >= 2) simple.push(k.clone({ insert: false }));
+    }
+    if (simple.length === 0) return [];
+    const compound = new scope.CompoundPath({ children: simple, fillRule });
+    const united = compound.unite(compound, { insert: false });
+    const paths = (united.className === "CompoundPath" ? united.children : [united])
+      .filter((p) => p.segments && p.segments.length >= 2 && Math.abs(p.area) > 1e-9);
+    return paths.length ? groupPaperPaths(paths) : [];
+  } finally {
+    scope.project.clear();
+  }
+}

package/src/framework/geometry/fonts/Roboto-LICENSE.txt

@@ -0,0 +1,93 @@
+Copyright 2011 The Roboto Project Authors (https://github.com/googlefonts/roboto-classic)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+https://openfontlicense.org
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.