@toolpath/viewer 1.2.0 → 1.3.0

package/README.md

@@ -594,6 +594,13 @@ convert, so pass `format` to show anything else:
 <MeasureTool format={(mm) => `${(mm / MM_PER_INCH).toFixed(3)} in`} />
 ```
 
+**Measuring a cut part.** Mount the measure tool with a section cut in place, or beside
+`<SectionTool>`, and it measures what is on screen: the half a cut has removed is not there to snap
+to, the part's edges stop at the plane, the outline where the plane passes through solid material
+is an edge with corners of its own, and the capped face is a surface a point can land on. The
+sample follows the cut — drag the handle or set a depth and the next pointer move sees the new cut.
+It reads the plane off the part's own material, so a controlled `section` prop works the same way.
+
 Hold Shift to hold the next point to the X, Y or Z line through the last one — whichever axis the
 pointer is furthest along — so a length along an edge is measured square rather than slightly across
 it. The line wears that axis's colour while it is held, and the finished distance has no legs to

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { P as PartModel, V as Vec3, d as ViewerTheme, S as SectionOptions, e as SectionState, f as PartModelRegion, T as TriangleRange, F as FeatureTag, R as RegionIndex, g as PartModelFeature, h as FeatureType } from './normalize-DHOSNiuO.js';
 export { A as AXES_PLANE_OFFSET, i as AXES_PLANE_SCALE, j as AxesPlane, B as BuildPickInput, C as CANDIDATE_WEIGHT, k as CAP_HATCH, D as DEFAULT_SECTION_NORMAL, l as DEFAULT_THEME, m as DIRECTION_COLORS, o as DISABLED_SECTION, E as EnginePart, p as FeatureHighlight, H as HANDLE_PIXELS, q as HIGHLIGHT_COLORS, r as HIGHLIGHT_WEIGHT, t as HOVER_WEIGHT, u as HighlightLayers, K as KnownFeatureType, v as KnownShapeKind, N as NO_MODIFIERS, O as OUTLINE_SCALE, w as PICKED_SURFACE_LABEL, x as PREVIEW_SCALE, y as PartMesh, z as PartMeshProps, a as PartMeshRefs, G as PartObject, I as PartPick, J as PickModifiers, L as REGION_ATTRIBUTE, Q as RegionHighlight, U as RegionPaint, W as SECTION_RENDER_ORDER, X as SectionAnchor, Y as SectionBounds, Z as SectionPlacement, _ as ShapeKind, $ as SurfaceHit, a0 as applyHighlightLayers, a1 as axesPlanes, a2 as buildPick, a3 as buildRegionAttribute, a4 as buildRegionTexels, a5 as createPart, a6 as directionColor, a7 as dragPlane, a8 as focusForPick, a9 as hitUnderRay, n as normalizePartReport, aa as pickedStartDepth, ab as resolveTheme, ac as sectionAnchor, ad as sectionBounds, ae as sectionConstant, af as sectionDepth, ag as sectionDepthConstant, ah as sectionDepthRange, ai as sectionFromPick, aj as sectionOffset, ak as sectionOptionsFromState, al as sectionPlane, s as smoothRegionNormals, am as surfaceUnderRay, an as themesEqual, ao as viewDirection } from './normalize-DHOSNiuO.js';
-import { BufferGeometry, CanvasTexture, Box3, Plane, Vector3, OrthographicCamera, PerspectiveCamera, Object3D, Matrix4, Vector2, ShaderMaterial, Texture, Color, MeshBasicMaterial, WebGLRenderTarget } from 'three';
+import { BufferGeometry, CanvasTexture, Box3, Plane, Vector3, OrthographicCamera, PerspectiveCamera, Object3D, Matrix4, Vector2, Ray, ShaderMaterial, Texture, Color, MeshBasicMaterial, WebGLRenderTarget } from 'three';
 import * as react from 'react';
 import { RefObject, ReactNode, CSSProperties } from 'react';
 import CameraControls from 'camera-controls';
@@ -738,6 +738,71 @@ interface SectionStore {
 }
 declare function createSectionStore(): SectionStore;
 
+/**
+ * A cut part, re-sampled for measuring.
+ *
+ * A clipping plane hides half of a part without changing a triangle, so the
+ * mesh and its edges still describe the whole thing — and a tool that snaps
+ * to them would offer corners nobody can see, and nothing at all on the cut.
+ * This is what the measure tool works against instead: the part's edges
+ * trimmed to the half that is left, the outline where the plane passes
+ * through solid material, and a test for whether a point on the plane is on
+ * the capped face. It is rebuilt whenever the plane moves; see
+ * `measure-tool.tsx`.
+ *
+ * Everything here is in one space — the mesh's own — and the plane is
+ * expected in it too. Six floats per segment throughout, the layout
+ * `regionEdgesGeometry` uses.
+ */
+interface SectionSample {
+    /** The edges of the part on the kept side, plus the cut's outline. */
+    readonly edges: Float32Array;
+    /** The cut's outline alone: where the plane crosses solid material. */
+    readonly contour: Float32Array;
+}
+/**
+ * Trims segments to the half-space a plane keeps.
+ *
+ * A segment wholly on the removed side goes; one that crosses is cut at the
+ * plane and its kept part stays. `Plane` keeps the side its normal points
+ * into — where the signed distance is positive — as the part's own clipping
+ * does.
+ */
+declare function clipSegments(positions: ArrayLike<number>, plane: Plane): Float32Array;
+/**
+ * Where a plane passes through a mesh: one segment per triangle it crosses,
+ * then straight runs inside one region stitched into one segment each.
+ *
+ * The stitching is what makes the outline snappable. A flat face is two
+ * triangles or two hundred, and the plane crosses each of them separately,
+ * so before stitching every triangle boundary on the face was a corner the
+ * pointer would snap to. After it, a corner is where the outline turns —
+ * where the plane leaves one surface for the next — and on a curved surface
+ * the facets stay, as they do in the part's own edges.
+ *
+ * `regionOf` says which surface each triangle belongs to, indexed by
+ * triangle; without it every triangle is one surface, which stitches a
+ * straight run across a fold only if the fold is perfectly flat, which it is
+ * not.
+ */
+declare function sectionContour(positions: ArrayLike<number>, regionOf: ArrayLike<number> | null, plane: Plane): Float32Array;
+/**
+ * Whether a point on the plane lies inside the cut's outline — on the capped
+ * face rather than in the air beside it.
+ *
+ * Even-odd against every outline segment, in the plane's own two axes, so a
+ * part cut through a bore is inside the outer loop and outside the hole's.
+ */
+declare function pointInContour(point: Vector3, plane: Plane, contour: ArrayLike<number>): boolean;
+/**
+ * Where a ray meets the capped face, or `null` when it misses the cap — a
+ * ray through the open half that lands beside the part, or one that reaches
+ * the plane from behind.
+ */
+declare function capHit(ray: Ray, plane: Plane, contour: ArrayLike<number>): Vector3 | null;
+/** The edges and outline of a part cut by `plane`, everything in the mesh's own space. */
+declare function sampleSection(meshPositions: ArrayLike<number>, regionOf: ArrayLike<number> | null, edgePositions: ArrayLike<number> | null, plane: Plane): SectionSample;
+
 type CapUniforms = {
     uMask: {
         value: Texture | null;
@@ -1510,4 +1575,4 @@ declare const ORBIT_TARGET_FADE_MS = 1000;
  */
 declare function orbitTargetOpacity(sinceHold: number, fade?: number): number;
 
-export { ANGLE_ARC_FRACTION, ANGLE_ARC_SEGMENTS, AXIS_COLORS, type AngleMeasurement, type ArrowPlacement, Axes, type AxesProps, type Axis, type AxisLock, CAD_CAMERA_UP, CHAMFER, CadCameraControls, type CadCameraControlsProps, type CameraLimits, type CapMaterial, type CapUniforms, type ControlScheme, type CubeZone, DEFAULT_FIT_MARGIN, DELTA_DASH_PIXELS, DOUBLE_TAP_MS, type DeltaLeg, DirectionArrows, type DirectionArrowsProps, type DirectionGroup, type DistanceMeasurement, type DoubleTapPoint, type DoubleTapTracker, EXCLUDE_FROM_FRAME, ExtendedCameraControls, type ExtendedCameraControlsOptions, FEATURE_TYPE_RANKS, FeatureTag, FeatureType, Grid, type GridProps, type GridSpec, MAX_FRAME_RATIO, MEASURE_LABEL_CLASS, MEASURE_LINE_PIXELS, MEASURE_MARKER_PIXELS, MEASURE_RENDER_ORDER, MIN_FRAME_RATIO, type MeasureLabelKind, type MeasureMode, MeasureTool, type MeasureToolProps, type Measurement, type NamedDirection, ORBIT_TARGET_COLOR, ORBIT_TARGET_FADE_MS, ORBIT_TARGET_FLASH_MS, ORBIT_TARGET_PIXELS, ORBIT_TARGET_RING_COLOR, ORBIT_TARGET_RING_OPACITY, ORBIT_TARGET_RING_PIXELS, ORBIT_TARGET_RING_WIDTH, PERSPECTIVE_FOV, POINTS_PER_MEASUREMENT, PartModel, PartModelFeature, PartModelRegion, PartReportFormatError, type Projection, type RankingContext, RegionIndex, type Retarget, type RetargetPose, SNAP_MARKER_PIXELS, SNAP_PIXELS, type SceneBounds, SectionOptions, SectionState, type SectionStore, SectionTool, type SectionToolProps, SectionView, type Snap, type SnapEdges, type SnapHit, type SnapKind, type SurfaceOf, TAP_SLOP, type TapPoint, type TapTracker, TriangleRange, UnsupportedKernelVersionError, VIEW_NAMES, VIEW_SIGNS, Vec3, ViewCube, type ViewCubeProps, type ViewKind, type ViewName, Viewer, type ViewerCamera, type ViewerControls, type ViewerHandle, type ViewerProps, ViewerTheme, type ViewerView, type ViewportSize, adaptedUp, angleArc, angleArcRadius, angleAt, applyCapTheme, applyProjection, arrowPlacement, aspectRatio, bestOwner, boundsFromBox, buildRegionIndex, cadViewDirections, cameraLimits, contentBounds, createCapMaterial, createMaskMaterial, createMaskTarget, createSectionStore, createStencilMaterials, cubeOutlineGeometry, cubeZones, currentViewDirection, cycleOwner, defaultBounds, deltaBetween, deltaLegs, directionIndexOf, directionLabel, distanceBetween, excludedFromFrame, featureTypeRank, fitDistance, formatDegrees, formatMillimetres, gridGeometry, gridSpec, groupByDirection, labelGeometry, labelTexture, lockToAxis, measurementFromPoints, measurementLabel, measurementLabelAnchor, midpoint, movedFar, nextMeasurementId, orbitTargetOpacity, orthographicHalfHeight, panelGeometry, perspectiveFitDistance, rankOwners, regionAdjacency, regionEdgesGeometry, regionNormals, resolveSectionPlane, retargetPose, sameDirection, screenLength, screenPoint, snapAt, squaredUp, startPosition, targetBoundary, trackDoubleTaps, trackTaps, useContentBox, useRetarget, useSectionStore, useTapGuard, useViewerControls, viewKind, viewUp, viewVector, visualSurfaces };
+export { ANGLE_ARC_FRACTION, ANGLE_ARC_SEGMENTS, AXIS_COLORS, type AngleMeasurement, type ArrowPlacement, Axes, type AxesProps, type Axis, type AxisLock, CAD_CAMERA_UP, CHAMFER, CadCameraControls, type CadCameraControlsProps, type CameraLimits, type CapMaterial, type CapUniforms, type ControlScheme, type CubeZone, DEFAULT_FIT_MARGIN, DELTA_DASH_PIXELS, DOUBLE_TAP_MS, type DeltaLeg, DirectionArrows, type DirectionArrowsProps, type DirectionGroup, type DistanceMeasurement, type DoubleTapPoint, type DoubleTapTracker, EXCLUDE_FROM_FRAME, ExtendedCameraControls, type ExtendedCameraControlsOptions, FEATURE_TYPE_RANKS, FeatureTag, FeatureType, Grid, type GridProps, type GridSpec, MAX_FRAME_RATIO, MEASURE_LABEL_CLASS, MEASURE_LINE_PIXELS, MEASURE_MARKER_PIXELS, MEASURE_RENDER_ORDER, MIN_FRAME_RATIO, type MeasureLabelKind, type MeasureMode, MeasureTool, type MeasureToolProps, type Measurement, type NamedDirection, ORBIT_TARGET_COLOR, ORBIT_TARGET_FADE_MS, ORBIT_TARGET_FLASH_MS, ORBIT_TARGET_PIXELS, ORBIT_TARGET_RING_COLOR, ORBIT_TARGET_RING_OPACITY, ORBIT_TARGET_RING_PIXELS, ORBIT_TARGET_RING_WIDTH, PERSPECTIVE_FOV, POINTS_PER_MEASUREMENT, PartModel, PartModelFeature, PartModelRegion, PartReportFormatError, type Projection, type RankingContext, RegionIndex, type Retarget, type RetargetPose, SNAP_MARKER_PIXELS, SNAP_PIXELS, type SceneBounds, SectionOptions, type SectionSample, SectionState, type SectionStore, SectionTool, type SectionToolProps, SectionView, type Snap, type SnapEdges, type SnapHit, type SnapKind, type SurfaceOf, TAP_SLOP, type TapPoint, type TapTracker, TriangleRange, UnsupportedKernelVersionError, VIEW_NAMES, VIEW_SIGNS, Vec3, ViewCube, type ViewCubeProps, type ViewKind, type ViewName, Viewer, type ViewerCamera, type ViewerControls, type ViewerHandle, type ViewerProps, ViewerTheme, type ViewerView, type ViewportSize, adaptedUp, angleArc, angleArcRadius, angleAt, applyCapTheme, applyProjection, arrowPlacement, aspectRatio, bestOwner, boundsFromBox, buildRegionIndex, cadViewDirections, cameraLimits, capHit, clipSegments, contentBounds, createCapMaterial, createMaskMaterial, createMaskTarget, createSectionStore, createStencilMaterials, cubeOutlineGeometry, cubeZones, currentViewDirection, cycleOwner, defaultBounds, deltaBetween, deltaLegs, directionIndexOf, directionLabel, distanceBetween, excludedFromFrame, featureTypeRank, fitDistance, formatDegrees, formatMillimetres, gridGeometry, gridSpec, groupByDirection, labelGeometry, labelTexture, lockToAxis, measurementFromPoints, measurementLabel, measurementLabelAnchor, midpoint, movedFar, nextMeasurementId, orbitTargetOpacity, orthographicHalfHeight, panelGeometry, perspectiveFitDistance, pointInContour, rankOwners, regionAdjacency, regionEdgesGeometry, regionNormals, resolveSectionPlane, retargetPose, sameDirection, sampleSection, screenLength, screenPoint, sectionContour, snapAt, squaredUp, startPosition, targetBoundary, trackDoubleTaps, trackTaps, useContentBox, useRetarget, useSectionStore, useTapGuard, useViewerControls, viewKind, viewUp, viewVector, visualSurfaces };

package/dist/index.js

@@ -842,11 +842,185 @@ import { Html, Line } from "@react-three/drei";
 import { useFrame as useFrame2, useThree as useThree4 } from "@react-three/fiber";
 import { useEffect as useEffect3, useLayoutEffect, useMemo as useMemo4, useRef as useRef3, useState as useState3 } from "react";
 import {
+  Matrix4,
   Raycaster as Raycaster2,
   SphereGeometry,
   Vector2 as Vector23,
-  Vector3 as Vector35
+  Vector3 as Vector36
 } from "three";
+
+// src/render/resample.ts
+import { Vector3 as Vector35 } from "three";
+var ON_PLANE = 1e-7;
+var STITCH = 1e-5;
+var COLLINEAR = 1e-6;
+function clipSegments(positions, plane) {
+  const out = [];
+  const a = new Vector35();
+  const b = new Vector35();
+  const count = Math.floor(positions.length / 6);
+  for (let i = 0; i < count; i += 1) {
+    a.set(positions[i * 6], positions[i * 6 + 1], positions[i * 6 + 2]);
+    b.set(positions[i * 6 + 3], positions[i * 6 + 4], positions[i * 6 + 5]);
+    const da = plane.distanceToPoint(a);
+    const db = plane.distanceToPoint(b);
+    if (da < -ON_PLANE && db < -ON_PLANE) continue;
+    if (da < -ON_PLANE) a.lerp(b, da / (da - db));
+    else if (db < -ON_PLANE) b.lerp(a, db / (db - da));
+    out.push(a.x, a.y, a.z, b.x, b.y, b.z);
+  }
+  return Float32Array.from(out);
+}
+function sectionContour(positions, regionOf, plane) {
+  const a = new Vector35();
+  const b = new Vector35();
+  const c = new Vector35();
+  const p = new Vector35();
+  const q = new Vector35();
+  const byRegion = /* @__PURE__ */ new Map();
+  const triangleCount = Math.floor(positions.length / 9);
+  for (let t = 0; t < triangleCount; t += 1) {
+    a.set(positions[t * 9], positions[t * 9 + 1], positions[t * 9 + 2]);
+    b.set(positions[t * 9 + 3], positions[t * 9 + 4], positions[t * 9 + 5]);
+    c.set(positions[t * 9 + 6], positions[t * 9 + 7], positions[t * 9 + 8]);
+    const crossings = triangleCrossings(a, b, c, plane, p, q);
+    if (!crossings) continue;
+    const region = regionOf ? regionOf[t] ?? 0 : 0;
+    const list = byRegion.get(region);
+    const entry = [p.x, p.y, p.z, q.x, q.y, q.z];
+    if (list) list.push(...entry);
+    else byRegion.set(region, entry);
+  }
+  const out = [];
+  for (const segments of byRegion.values()) stitch(segments, out);
+  return Float32Array.from(out);
+}
+function triangleCrossings(a, b, c, plane, p, q) {
+  const da = plane.distanceToPoint(a);
+  const db = plane.distanceToPoint(b);
+  const dc = plane.distanceToPoint(c);
+  const sa = da < -ON_PLANE;
+  const sb = db < -ON_PLANE;
+  const sc = dc < -ON_PLANE;
+  if (sa === sb && sb === sc) return false;
+  const found = [];
+  const edge = (u, v, du, dv, su, sv) => {
+    if (su === sv) return;
+    found.push(u.clone().lerp(v, du / (du - dv)));
+  };
+  edge(a, b, da, db, sa, sb);
+  edge(b, c, db, dc, sb, sc);
+  edge(c, a, dc, da, sc, sa);
+  if (found.length < 2) return false;
+  p.copy(found[0]);
+  q.copy(found[1]);
+  return p.distanceToSquared(q) > ON_PLANE * ON_PLANE;
+}
+function stitch(segments, out) {
+  const count = segments.length / 6;
+  const key = (x, y, z) => `${Math.round(x / STITCH)},${Math.round(y / STITCH)},${Math.round(z / STITCH)}`;
+  const ends = /* @__PURE__ */ new Map();
+  for (let i = 0; i < count; i += 1) {
+    for (const end of [0, 1]) {
+      const o = i * 6 + end * 3;
+      const k = key(segments[o], segments[o + 1], segments[o + 2]);
+      const list = ends.get(k);
+      if (list) list.push(i * 2 + end);
+      else ends.set(k, [i * 2 + end]);
+    }
+  }
+  const point = (i, end, into) => {
+    const o = i * 6 + end * 3;
+    return into.set(segments[o], segments[o + 1], segments[o + 2]);
+  };
+  const direction = (i, into) => {
+    const s = new Vector35();
+    const e = new Vector35();
+    point(i, 0, s);
+    point(i, 1, e);
+    return into.subVectors(e, s).normalize();
+  };
+  const consumed = new Uint8Array(count);
+  const d = new Vector35();
+  const n = new Vector35();
+  const next = (i, end) => {
+    const at = point(i, end, new Vector35());
+    const list = ends.get(key(at.x, at.y, at.z)) ?? [];
+    if (list.length !== 2) return null;
+    const other = list.find((entry) => entry >> 1 !== i);
+    if (other === void 0) return null;
+    const j = other >> 1;
+    if (consumed[j]) return null;
+    direction(i, d);
+    direction(j, n);
+    if (Math.abs(Math.abs(d.dot(n)) - 1) > COLLINEAR) return null;
+    return { index: j, end: other & 1 };
+  };
+  for (let i = 0; i < count; i += 1) {
+    if (consumed[i]) continue;
+    consumed[i] = 1;
+    const walk = (end) => {
+      let at = { index: i, end };
+      let steps = 0;
+      for (; ; ) {
+        const step = next(at.index, at.end);
+        if (!step || steps > count) break;
+        consumed[step.index] = 1;
+        at = { index: step.index, end: 1 - step.end };
+        steps += 1;
+      }
+      return at;
+    };
+    const back = walk(0);
+    const forward = walk(1);
+    const s = point(back.index, back.end, new Vector35());
+    const e = point(forward.index, forward.end, new Vector35());
+    out.push(s.x, s.y, s.z, e.x, e.y, e.z);
+  }
+}
+function pointInContour(point, plane, contour) {
+  const [u, v] = planeAxes(plane);
+  const px = point.dot(u);
+  const py = point.dot(v);
+  const a = new Vector35();
+  const b = new Vector35();
+  let inside = false;
+  const count = Math.floor(contour.length / 6);
+  for (let i = 0; i < count; i += 1) {
+    a.set(contour[i * 6], contour[i * 6 + 1], contour[i * 6 + 2]);
+    b.set(contour[i * 6 + 3], contour[i * 6 + 4], contour[i * 6 + 5]);
+    const ax = a.dot(u);
+    const ay = a.dot(v);
+    const bx = b.dot(u);
+    const by = b.dot(v);
+    if (ay > py === by > py) continue;
+    const x = ax + (py - ay) / (by - ay) * (bx - ax);
+    if (px < x) inside = !inside;
+  }
+  return inside;
+}
+function capHit(ray, plane, contour) {
+  const point = ray.intersectPlane(plane, new Vector35());
+  if (!point) return null;
+  return pointInContour(point, plane, contour) ? point : null;
+}
+function planeAxes(plane) {
+  const n = plane.normal;
+  const seed = Math.abs(n.x) < 0.9 ? new Vector35(1, 0, 0) : new Vector35(0, 1, 0);
+  const u = new Vector35().crossVectors(n, seed).normalize();
+  const v = new Vector35().crossVectors(n, u).normalize();
+  return [u, v];
+}
+function sampleSection(meshPositions, regionOf, edgePositions, plane) {
+  const contour = sectionContour(meshPositions, regionOf, plane);
+  const kept = edgePositions ? clipSegments(edgePositions, plane) : new Float32Array();
+  const edges = new Float32Array(kept.length + contour.length);
+  edges.set(kept, 0);
+  edges.set(contour, kept.length);
+  return { edges, contour };
+}
+
+// src/measure-tool.tsx
 import { Fragment as Fragment2, jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
 var FURNITURE4 = { [EXCLUDE_FROM_FRAME]: true };
 var MEASURE_LABEL_CLASS = "toolpath-measure-label";
@@ -943,7 +1117,7 @@ var MeasureTool = ({
   ] });
 };
 var NO_POINTER = { pointerEvents: "none" };
-var NOWHERE = [new Vector35(), new Vector35()];
+var NOWHERE = [new Vector36(), new Vector36()];
 var Snapper = ({ mode, draft, onPlace, theme, format, label }) => {
   const camera = useThree4((state) => state.camera);
   const scene = useThree4((state) => state.scene);
@@ -967,6 +1141,7 @@ var Snapper = ({ mode, draft, onPlace, theme, format, label }) => {
   useEffect3(() => {
     const raycaster = new Raycaster2();
     const pointer = new Vector23();
+    const samples = new SampleCache();
     const hide = () => {
       if (!snap.current) return;
       snap.current = null;
@@ -986,22 +1161,16 @@ var Snapper = ({ mode, draft, onPlace, theme, format, label }) => {
         -((clientY - rect.top) / rect.height) * 2 + 1
       );
       raycaster.setFromCamera(pointer, camera);
-      const hit = hitUnderRay(raycaster, scene);
-      if (!hit?.face) {
+      const target = targetUnderRay(raycaster, scene, samples);
+      if (!target) {
         hide();
         return;
       }
-      const normal = hit.face.normal.clone().transformDirection(hit.object.matrixWorld);
       const { size: viewport, draft: placed, mode: kind, format: write } = current.current;
-      const snapped = snapAt(
-        { point: hit.point, normal },
-        edgesBeside(hit.object),
-        camera,
-        viewport
-      );
+      const snapped = snapAt(target, target.edges, camera, viewport);
       const from = placed[placed.length - 1];
       const lock = shift && from ? lockToAxis(from, snapped.point) : null;
-      const found = lock ? { ...snapped, point: new Vector35(lock.point.x, lock.point.y, lock.point.z), edge: null } : snapped;
+      const found = lock ? { ...snapped, point: new Vector36(lock.point.x, lock.point.y, lock.point.z), edge: null } : snapped;
       snap.current = found;
       const node = marker.current;
       if (node) {
@@ -1144,17 +1313,124 @@ function liveLabel(mode, placed, at, format) {
   }
   return null;
 }
+function targetUnderRay(raycaster, scene, samples) {
+  let best = null;
+  const hit = hitUnderRay(raycaster, scene);
+  if (hit?.face) {
+    best = {
+      point: hit.point,
+      normal: hit.face.normal.clone().transformDirection(hit.object.matrixWorld),
+      distance: hit.distance,
+      edges: samples.edgesFor(hit.object)
+    };
+  }
+  const local = new Matrix4();
+  for (const mesh of cutMeshes(scene)) {
+    const planes = clippingPlanesOf(mesh);
+    const sample = samples.for(mesh, planes);
+    local.copy(mesh.matrixWorld).invert();
+    const ray = raycaster.ray.clone().applyMatrix4(local);
+    for (const [index, plane] of planes.entries()) {
+      const contour = sample.contours[index];
+      if (!contour) continue;
+      const point = capHit(ray, plane.clone().applyMatrix4(local), contour);
+      if (!point) continue;
+      const world = point.applyMatrix4(mesh.matrixWorld);
+      if (planes.some((other, i) => i !== index && other.distanceToPoint(world) < -1e-7)) continue;
+      const distance = world.distanceTo(raycaster.ray.origin);
+      if (best && distance >= best.distance) continue;
+      best = {
+        point: world,
+        // The cap faces the half that was taken away.
+        normal: plane.normal.clone().negate(),
+        distance,
+        edges: { positions: sample.edges, matrixWorld: mesh.matrixWorld }
+      };
+    }
+  }
+  return best;
+}
+function cutMeshes(scene) {
+  const found = [];
+  scene.traverse((object) => {
+    if (!("isMesh" in object) || !object.visible || excludedFromFrame(object, scene)) return;
+    if (clippingPlanesOf(object).length) found.push(object);
+  });
+  return found;
+}
+function clippingPlanesOf(mesh) {
+  const material = Array.isArray(mesh.material) ? mesh.material[0] : mesh.material;
+  return material?.clippingPlanes ?? [];
+}
 function edgesBeside(object) {
   const siblings = object.parent?.children ?? [];
   for (const sibling of siblings) {
     if (!("isLineSegments" in sibling)) continue;
-    const geometry = sibling.geometry;
-    const positions = geometry.getAttribute("position");
-    if (!positions) continue;
-    return { positions: positions.array, matrixWorld: sibling.matrixWorld };
+    const positions = sibling.geometry.getAttribute("position");
+    if (positions) return positions.array;
   }
   return null;
 }
+var SampleCache = class {
+  held = /* @__PURE__ */ new Map();
+  regions = /* @__PURE__ */ new Map();
+  /** The edges to snap to on `mesh`: its own, or the trimmed set with the cut's outline. */
+  edgesFor(mesh) {
+    const planes = clippingPlanesOf(mesh);
+    if (planes.length === 0) {
+      const positions = edgesBeside(mesh);
+      return positions ? { positions, matrixWorld: mesh.matrixWorld } : null;
+    }
+    return { positions: this.for(mesh, planes).edges, matrixWorld: mesh.matrixWorld };
+  }
+  for(mesh, planes) {
+    const key = planes.map((plane) => `${plane.normal.x},${plane.normal.y},${plane.normal.z},${plane.constant}`).join("|");
+    const cached = this.held.get(mesh);
+    if (cached && cached.key === key) return cached;
+    const local = new Matrix4().copy(mesh.matrixWorld).invert();
+    const localPlanes = planes.map((plane) => plane.clone().applyMatrix4(local));
+    const positions = mesh.geometry.getAttribute("position")?.array ?? [];
+    const regionOf = this.regionsOf(mesh.geometry);
+    const contours = localPlanes.map(
+      (plane, index) => localPlanes.reduce(
+        (outline, other, i) => i === index ? outline : clipSegments(outline, other),
+        sectionContour(positions, regionOf, plane)
+      )
+    );
+    const own = edgesBeside(mesh) ?? [];
+    const trimmed = localPlanes.reduce(
+      (kept, plane) => clipSegments(kept, plane),
+      own
+    );
+    const total = contours.reduce((sum, contour) => sum + contour.length, trimmed.length);
+    const edges = new Float32Array(total);
+    edges.set(trimmed, 0);
+    let offset = trimmed.length;
+    for (const contour of contours) {
+      edges.set(contour, offset);
+      offset += contour.length;
+    }
+    const sample = { key, contours, edges };
+    this.held.set(mesh, sample);
+    return sample;
+  }
+  /**
+   * Which surface each triangle belongs to, read off the region attribute
+   * `createPart` gives the mesh. A mesh without one is sampled as a single
+   * surface, which still stitches a flat face's outline into one run.
+   */
+  regionsOf(geometry) {
+    if (this.regions.has(geometry)) return this.regions.get(geometry) ?? null;
+    const attribute = geometry.getAttribute(REGION_ATTRIBUTE);
+    let regions = null;
+    if (attribute && !geometry.index) {
+      regions = new Int32Array(Math.floor(attribute.count / 3));
+      for (let t = 0; t < regions.length; t += 1) regions[t] = attribute.getX(t * 3);
+    }
+    this.regions.set(geometry, regions);
+    return regions;
+  }
+};
 var MeasurementView = ({
   measurement,
   theme,
@@ -1194,7 +1470,7 @@ var DeltaLegs = ({ a, b, id, format, label }) => {
   const lines = useRef3([]);
   const centre = useMemo4(() => {
     const at = midpoint(a, b);
-    return new Vector35(at.x, at.y, at.z);
+    return new Vector36(at.x, at.y, at.z);
   }, [a, b]);
   useFrame2(() => {
     const dash = screenLength(camera, centre, size, DELTA_DASH_PIXELS);
@@ -1216,8 +1492,8 @@ var DeltaLegs = ({ a, b, id, format, label }) => {
           lines.current[index] = line;
         },
         points: [
-          new Vector35(leg.from.x, leg.from.y, leg.from.z),
-          new Vector35(leg.to.x, leg.to.y, leg.to.z)
+          new Vector36(leg.from.x, leg.from.y, leg.from.z),
+          new Vector36(leg.to.x, leg.to.y, leg.to.z)
         ],
         color: AXIS_COLORS[leg.axis],
         lineWidth: MEASURE_LINE_PIXELS.leg,
@@ -1253,7 +1529,7 @@ var ScreenDot = ({ point, pixels, color }) => {
   const invalidate = useThree4((state) => state.invalidate);
   const node = useRef3(null);
   const dot = useDot();
-  const position = useMemo4(() => new Vector35(point.x, point.y, point.z), [point]);
+  const position = useMemo4(() => new Vector36(point.x, point.y, point.z), [point]);
   useFrame2(() => {
     const group = node.current;
     if (!group) return;
@@ -1268,7 +1544,7 @@ var ScreenDot = ({ point, pixels, color }) => {
 var Segment = ({ points, color }) => {
   const [a, b] = points;
   const ends = useMemo4(
-    () => [new Vector35(a.x, a.y, a.z), new Vector35(b.x, b.y, b.z)],
+    () => [new Vector36(a.x, a.y, a.z), new Vector36(b.x, b.y, b.z)],
     // Keyed on the numbers: a draft's tuple is a fresh array on every render,
     // and a rebuilt array would rebuild the line's geometry with it.
     [a.x, a.y, a.z, b.x, b.y, b.z]
@@ -1419,6 +1695,8 @@ export {
   buildRegionTexels,
   cadViewDirections,
   cameraLimits,
+  capHit,
+  clipSegments,
   contentBounds,
   createCapMaterial,
   createMaskMaterial,
@@ -1463,6 +1741,7 @@ export {
   panelGeometry,
   perspectiveFitDistance,
   pickedStartDepth,
+  pointInContour,
   rankOwners,
   regionAdjacency,
   regionEdgesGeometry,
@@ -1471,11 +1750,13 @@ export {
   resolveTheme,
   retargetPose,
   sameDirection,
+  sampleSection,
   screenLength,
   screenPoint,
   sectionAnchor,
   sectionBounds,
   sectionConstant,
+  sectionContour,
   sectionDepth,
   sectionDepthConstant,
   sectionDepthRange,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolpath/viewer",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "React Three Fiber viewer for Toolpath Engine part reports",
   "license": "MIT",
   "engines": {