@weasel-js/kernel3d 1.10.0 → 1.11.0

package/dist/index.js

@@ -1,11 +1,11 @@
-import { lookAt, multiply, perspective, quatIdentity, compose, transformAabb, invert, transformPoint, normalize, sub, transformPoint4, intersectRayAabb, intersectRayPlane, len, add, scale, dot } from '@weasel-js/geom/3d';
-import { resolveOverlays, defineTool } from '@weasel-js/core';
+import { lookAt, multiply, perspective, add, scale, quatIdentity, compose, transformAabb, invert, transformPoint, normalize, sub, transformPoint4, intersectRayAabb, distance, dot, len, cross, intersectRayPlane, pointOnRay, aabbOfPoints } from '@weasel-js/geom/3d';
+import { createSnapOutcomeStore, DEFAULT_SNAP_PX, overlaysOf, resolveOverlays, defineTool, snapSourcesFor, resolvedSnapMarks, SNAP_AXIS_STEP, gatherSnapCandidates } from '@weasel-js/core';
+import { closestOnFlat, resolveSnap, stepLine } from '@weasel-js/geom/nd';
 import { useMemo } from 'react';
+import { pref } from '@weasel-js/prefs';
 
 // src/camera.ts
 var MAX_PITCH = Math.PI / 2 - 0.01;
-var MIN_DISTANCE = 0.5;
-var MAX_DISTANCE = 500;
 var UP = { x: 0, y: 1, z: 0 };
 function createCamera(init) {
   return {
@@ -19,11 +19,11 @@ function createCamera(init) {
   };
 }
 function cameraEye(camera) {
-  const { target, yaw, pitch, distance } = camera;
-  const horizontal = Math.cos(pitch) * distance;
+  const { target, yaw, pitch, distance: distance2 } = camera;
+  const horizontal = Math.cos(pitch) * distance2;
   return {
     x: target.x + horizontal * Math.sin(yaw),
-    y: target.y + Math.sin(pitch) * distance,
+    y: target.y + Math.sin(pitch) * distance2,
     z: target.z + horizontal * Math.cos(yaw)
   };
 }
@@ -33,25 +33,59 @@ function cameraView(camera) {
 function cameraViewProjection(camera, aspect) {
   return multiply(perspective(camera.fov, aspect, camera.near, camera.far), cameraView(camera));
 }
-function orbitBy(camera, deltaYaw, deltaPitch) {
-  return {
-    ...camera,
-    yaw: camera.yaw + deltaYaw,
-    pitch: Math.max(-MAX_PITCH, Math.min(MAX_PITCH, camera.pitch + deltaPitch))
-  };
+var DEFAULT_ORBIT_LIMITS = {
+  minDistance: 0.5,
+  maxDistance: 500,
+  minPitch: -MAX_PITCH,
+  maxPitch: MAX_PITCH
+};
+var clamp = (v, lo, hi) => Math.max(lo, Math.min(hi, v));
+function clampCamera(camera, limits = {}) {
+  const l = { ...DEFAULT_ORBIT_LIMITS, ...limits };
+  const pitch = clamp(camera.pitch, Math.max(-MAX_PITCH, l.minPitch), Math.min(MAX_PITCH, l.maxPitch));
+  const distance2 = clamp(camera.distance, l.minDistance, l.maxDistance);
+  if (pitch === camera.pitch && distance2 === camera.distance) return camera;
+  return { ...camera, pitch, distance: distance2 };
+}
+function orbitBy(camera, deltaYaw, deltaPitch, limits) {
+  return clampCamera(
+    { ...camera, yaw: camera.yaw + deltaYaw, pitch: camera.pitch + deltaPitch },
+    limits
+  );
 }
-function dollyBy(camera, factor) {
-  return {
-    ...camera,
-    distance: Math.max(MIN_DISTANCE, Math.min(MAX_DISTANCE, camera.distance * factor))
+function dollyBy(camera, factor, limits) {
+  return clampCamera({ ...camera, distance: camera.distance * factor }, limits);
+}
+function panBy(camera, dx, dy, paneHeight) {
+  if (!(paneHeight > 0)) return camera;
+  const perPixel = 2 * camera.distance * Math.tan(camera.fov / 2) / paneHeight;
+  const { yaw, pitch } = camera;
+  const right = { x: Math.cos(yaw), y: 0, z: -Math.sin(yaw) };
+  const up = {
+    x: -Math.sin(yaw) * Math.sin(pitch),
+    y: Math.cos(pitch),
+    z: -Math.cos(yaw) * Math.sin(pitch)
   };
+  const shift = add(scale(right, -dx * perPixel), scale(up, dy * perPixel));
+  return { ...camera, target: add(camera.target, shift) };
+}
+function dollyToward(camera, factor, at, pane, limits) {
+  const dollied = dollyBy(camera, factor, limits);
+  const kept = 1 - dollied.distance / camera.distance;
+  const moved = panBy(
+    camera,
+    -kept * (at.x - pane.width / 2),
+    -kept * (at.y - pane.height / 2),
+    pane.height
+  );
+  return { ...dollied, target: moved.target };
 }
 var UNIT_CUBE = {
   min: { x: -0.5, y: -0.5, z: -0.5 },
   max: { x: 0.5, y: 0.5, z: 0.5 }
 };
-function pose3(position, scale = { x: 1, y: 1, z: 1 }, rotation = quatIdentity()) {
-  return { position, rotation, scale };
+function pose3(position, scale5 = { x: 1, y: 1, z: 1 }, rotation = quatIdentity()) {
+  return { position, rotation, scale: scale5 };
 }
 function poseMatrix(pose) {
   return compose(pose.position, pose.rotation, pose.scale);
@@ -134,10 +168,6 @@ function projectAabbToScreen(box, viewProjection, rect) {
   if (!any) return null;
   return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
 }
-var DEFAULT_UP = { x: 0, y: 1, z: 0 };
-function boundsOfNode(world, node) {
-  return world.bounds ? world.bounds(node) : aabbOfPose(node.pose);
-}
 function rectOf(viewport) {
   return {
     x: viewport.originX ?? 0,
@@ -157,6 +187,187 @@ function rayAt(viewport, point) {
     cameraEye(viewport.camera)
   );
 }
+function projectPoint(p, viewport) {
+  const [x, y, z, w] = transformPoint4(viewProjectionOf(viewport), p);
+  if (!(w > 0) || z < -w) return null;
+  const screen = ndcToScreen({ x: x / w, y: y / w }, rectOf(viewport));
+  return Number.isFinite(screen.x) && Number.isFinite(screen.y) ? screen : null;
+}
+
+// src/world.ts
+var DEFAULT_UP = { x: 0, y: 1, z: 0 };
+function boundsOfNode(world, node) {
+  return world.bounds ? world.bounds(node) : aabbOfPose(node.pose);
+}
+var ZERO = { x: 0, y: 0, z: 0 };
+var tuple = (p) => [p.x, p.y, p.z];
+var vec3Of = (t) => ({ x: t[0], y: t[1], z: t[2] });
+function planeBasis(up) {
+  const n = normalize(up);
+  const e = Math.abs(n.x) < 0.9 ? { x: 1, y: 0, z: 0 } : { x: 0, y: 0, z: 1 };
+  const u = normalize(sub(e, scale(n, dot(n, e))));
+  return [u, cross(u, n)];
+}
+function inputFlat3d(c, held, basis, delta0, about) {
+  const [u, v] = basis;
+  if (!held || c === void 0 || c === "aspect") return { at: [0, 0, 0], dirs: [tuple(u), tuple(v)] };
+  const step = c === "axis" ? SNAP_AXIS_STEP : c.step;
+  return stepLine(tuple(c === "axis" ? ZERO : about), tuple(delta0), [tuple(u), tuple(v)], step);
+}
+function subjectOf(world, ids, up) {
+  let box = null;
+  let anchor = null;
+  for (const id of ids) {
+    const node = world.scene.get(id);
+    if (!node) continue;
+    const b = boundsOfNode(world, node);
+    anchor ??= { box: b, height: dot(up, node.pose.position) };
+    box = box ? union(box, b) : b;
+  }
+  return box && anchor ? { box, anchor } : null;
+}
+function union(a, b) {
+  return {
+    min: { x: Math.min(a.min.x, b.min.x), y: Math.min(a.min.y, b.min.y), z: Math.min(a.min.z, b.min.z) },
+    max: { x: Math.max(a.max.x, b.max.x), y: Math.max(a.max.y, b.max.y), z: Math.max(a.max.z, b.max.z) }
+  };
+}
+function boxCorner(box, i) {
+  return {
+    x: i & 1 ? box.max.x : box.min.x,
+    y: i & 2 ? box.max.y : box.min.y,
+    z: i & 4 ? box.max.z : box.min.z
+  };
+}
+function boxProbes(box) {
+  const center = scale(add(box.min, box.max), 0.5);
+  const out = [];
+  for (let i = 0; i < 8; i++) {
+    out.push({ id: `corner:${i}`, at: boxCorner(box, i), role: "geometry" });
+  }
+  out.push(
+    { id: "center", at: center, role: "geometry" },
+    { id: "box.min", at: box.min, role: "box" },
+    { id: "box.center", at: center, role: "box" },
+    { id: "box.max", at: box.max, role: "box" }
+  );
+  return out;
+}
+
+// src/snap/session3d.ts
+var ZERO2 = { x: 0, y: 0, z: 0 };
+function createSession3d(inputs) {
+  const { req, world, store } = inputs;
+  const up = normalize(world.up ?? DEFAULT_UP);
+  const basis = planeBasis(up);
+  const frame = frameOf(req, world, up);
+  const sources = snapSourcesFor(inputs.sources, req.gesture);
+  const unsnapped = (p) => {
+    store.set([]);
+    return { point: p, held: false, marks: [] };
+  };
+  return {
+    at(p, mods) {
+      if (!frame) return unsnapped(p);
+      const vp = world.viewport();
+      const screen = frame.anchor(vp);
+      const anchor = screen && castOnto(vp, screen, up, frame.offset);
+      const hit = screen && castOnto(vp, { x: screen.x + p.x - req.press.x, y: screen.y + p.y - req.press.y }, up, frame.offset);
+      if (!screen || !anchor || !hit) return unsnapped(p);
+      const delta0 = sub(hit, anchor);
+      const origin = req.origin ? castOnto(vp, req.origin, up, frame.offset) : null;
+      const input = inputFlat3d(req.constrain, mods.constrain, basis, delta0, origin ? sub(origin, anchor) : ZERO2);
+      let delta;
+      let held = false;
+      if (mods.suspend) {
+        delta = vec3Of(closestOnFlat(input, tuple(delta0)));
+        store.set([]);
+      } else {
+        const probes = frame.probes(anchor);
+        const res = resolveSnap({
+          probes: probes.map((q) => ({ id: q.id, at: tuple(q.at), role: q.role })),
+          input,
+          delta0: tuple(delta0),
+          candidates: candidatesOf(inputs, sources, probes, delta0, vp, origin, up),
+          toScreen: (w) => {
+            const s = projectPoint(vec3Of(w), vp);
+            return s ? [s.x, s.y] : [NaN, NaN];
+          }
+        });
+        delta = vec3Of(res.delta);
+        held = res.members.length > 0;
+        store.set(resolvedSnapMarks(res.satisfied, delta));
+      }
+      const landed = projectPoint(add(anchor, delta), vp);
+      if (!landed) return unsnapped(p);
+      return {
+        point: { x: req.press.x + landed.x - screen.x, y: req.press.y + landed.y - screen.y },
+        held,
+        marks: store.get()
+      };
+    },
+    angle: (theta) => ({ theta, marks: [] }),
+    end() {
+      store.set([]);
+    }
+  };
+}
+function frameOf(req, world, up) {
+  if (req.gesture === "point") {
+    return {
+      offset: 0,
+      anchor: () => req.press,
+      probes: (at) => [{ id: "pointer", at, role: "pointer" }]
+    };
+  }
+  if (req.gesture !== "move") return null;
+  const subject = subjectOf(world, req.ids ?? [], up);
+  if (!subject) return null;
+  const probes = boxProbes(subject.box);
+  return {
+    offset: subject.anchor.height,
+    anchor(vp) {
+      const box = projectAabbToScreen(subject.anchor.box, viewProjectionOf(vp), rectOf(vp));
+      return box ? { x: box.x + box.width / 2, y: box.y + box.height / 2 } : null;
+    },
+    probes: () => probes
+  };
+}
+function castOnto(vp, s, up, offset) {
+  const ray = rayAt(vp, s);
+  const t = ray && intersectRayPlane(ray, up, offset);
+  return ray && t !== null ? pointOnRay(ray, t) : null;
+}
+function candidatesOf(inputs, sources, probes, delta0, vp, origin, up) {
+  const { req } = inputs;
+  const shifted = probes.map((q) => ({ ...q, at: add(q.at, delta0) }));
+  const perPx = worldPerPx(vp, shifted);
+  const found = gatherSnapCandidates(sources, shifted, (_source, offered, reachPx) => ({
+    gesture: req.gesture,
+    probes: offered,
+    delta0,
+    exclude: req.ids ?? [],
+    ...origin ? { origin } : {},
+    reachWorld: (px) => px * perPx,
+    reachPx
+  }), { toVec: tuple, reachPx: inputs.reachPx, ...origin ? { origin } : {} });
+  return found.filter((c) => !level(c.locus, up));
+}
+function level(locus, up) {
+  if (locus.dirs.length !== 2) return false;
+  const n = cross(vec3Of(locus.dirs[0]), vec3Of(locus.dirs[1]));
+  return Math.abs(dot(n, up)) >= (1 - 1e-9) * len(n);
+}
+function worldPerPx(vp, probes) {
+  const eye = cameraEye(vp.camera);
+  const forward = normalize(sub(vp.camera.target, eye));
+  const k = 2 * Math.tan(vp.camera.fov / 2) / Math.max(1, vp.height);
+  let depth = 0;
+  for (const q of probes) depth = Math.max(depth, dot(sub(q.at, eye), forward));
+  return depth * k;
+}
+
+// src/deps.ts
 function viewPlaneAt(camera, p) {
   const normal = normalize(sub(camera.target, cameraEye(camera)));
   return { normal, offset: dot(normal, p) };
@@ -167,24 +378,6 @@ function onPlane(vp, plane, point) {
   const t = intersectRayPlane(ray, plane.normal, plane.offset);
   return t === null ? null : pointOnRay(ray, t);
 }
-function aabbOfPoints(points) {
-  const min = { x: Infinity, y: Infinity, z: Infinity };
-  const max = { x: -Infinity, y: -Infinity, z: -Infinity };
-  for (const p of points) {
-    for (const axis of ["x", "y", "z"]) {
-      if (p[axis] < min[axis]) min[axis] = p[axis];
-      if (p[axis] > max[axis]) max[axis] = p[axis];
-    }
-  }
-  return { min, max };
-}
-function pointOnRay(ray, t) {
-  return {
-    x: ray.origin.x + ray.direction.x * t,
-    y: ray.origin.y + ray.direction.y * t,
-    z: ray.origin.z + ray.direction.z * t
-  };
-}
 function overlaps(a, b) {
   return a.x < b.x + b.width && a.x + a.width > b.x && a.y < b.y + b.height && a.y + a.height > b.y;
 }
@@ -232,50 +425,12 @@ function createAreaSelect(world, selection) {
     setSelection: (ids) => selection.set([...ids])
   };
 }
-function createSnap() {
-  return { point: (p) => p };
-}
-function createInsert(opts) {
-  const up = opts.up ?? DEFAULT_UP;
-  const minExtent = opts.minExtent ?? 0.25;
-  const axes = up.y !== 0 ? ["x", "z"] : up.x !== 0 ? ["y", "z"] : ["x", "y"];
+function createSnap(world, opts = {}) {
+  const store = opts.store ?? createSnapOutcomeStore();
+  const sources = opts.sources ?? [];
+  const reachPx = opts.reachPx ?? DEFAULT_SNAP_PX;
   return {
-    commit(bounds, extras) {
-      const vp = opts.viewport();
-      const corners = [
-        { x: bounds.x, y: bounds.y },
-        { x: bounds.x + bounds.width, y: bounds.y },
-        { x: bounds.x, y: bounds.y + bounds.height },
-        { x: bounds.x + bounds.width, y: bounds.y + bounds.height }
-      ];
-      const hits = [];
-      for (const corner of corners) {
-        const ray = rayAt(vp, corner);
-        if (!ray) continue;
-        const t = intersectRayPlane(ray, up, 0);
-        if (t !== null) hits.push(pointOnRay(ray, t));
-      }
-      if (hits.length === 0) return null;
-      const [u, v] = axes;
-      let minU = Infinity, maxU = -Infinity, minV = Infinity, maxV = -Infinity;
-      for (const h of hits) {
-        minU = Math.min(minU, h[u]);
-        maxU = Math.max(maxU, h[u]);
-        minV = Math.min(minV, h[v]);
-        maxV = Math.max(maxV, h[v]);
-      }
-      const center = { x: 0, y: 0, z: 0 };
-      center[u] = (minU + maxU) / 2;
-      center[v] = (minV + maxV) / 2;
-      return opts.mint(
-        {
-          center,
-          width: Math.max(minExtent, maxU - minU),
-          depth: Math.max(minExtent, maxV - minV)
-        },
-        extras
-      );
-    }
+    begin: (req) => createSession3d({ req, world, sources, reachPx, store })
   };
 }
 function createPoseDescriptor(world) {
@@ -387,7 +542,7 @@ function createPoseDescriptor(world) {
         if (!box) return pose;
         const from = { x: box.x + box.width / 2, y: box.y + box.height / 2 };
         const to = { x: from.x + dx, y: from.y + dy };
-        const offset = pose.position[upAxis];
+        const offset = dot(up, pose.position);
         const ray = rayAt(vp, to);
         if (!ray) return pose;
         const t = intersectRayPlane(ray, up, offset);
@@ -413,12 +568,223 @@ function createPoseDescriptor(world) {
   }
   return build((pose) => aabbOfPose(pose));
 }
+function footprintPoints(bounds, ends, cast) {
+  if (ends) {
+    const start = cast(ends.start);
+    const end = cast(ends.end);
+    if (!start || !end) return [];
+    return ends.fromCenter ? [end, sub(scale(start, 2), end)] : [start, end];
+  }
+  const corners = [
+    { x: bounds.x, y: bounds.y },
+    { x: bounds.x + bounds.width, y: bounds.y },
+    { x: bounds.x, y: bounds.y + bounds.height },
+    { x: bounds.x + bounds.width, y: bounds.y + bounds.height }
+  ];
+  return corners.map(cast).filter((h) => h !== null);
+}
+function createInsert(opts) {
+  const up = opts.up ?? DEFAULT_UP;
+  const minExtent = opts.minExtent ?? 0.25;
+  const axes = up.y !== 0 ? ["x", "z"] : up.x !== 0 ? ["y", "z"] : ["x", "y"];
+  return {
+    commit(bounds, extras, ends) {
+      const vp = opts.viewport();
+      const cast = (p) => {
+        const ray = rayAt(vp, p);
+        const t = ray && intersectRayPlane(ray, up, 0);
+        return ray && t !== null ? pointOnRay(ray, t) : null;
+      };
+      const hits = footprintPoints(bounds, ends, cast);
+      if (hits.length === 0) return null;
+      const [u, v] = axes;
+      let minU = Infinity, maxU = -Infinity, minV = Infinity, maxV = -Infinity;
+      for (const h of hits) {
+        minU = Math.min(minU, h[u]);
+        maxU = Math.max(maxU, h[u]);
+        minV = Math.min(minV, h[v]);
+        maxV = Math.max(maxV, h[v]);
+      }
+      const center = { x: 0, y: 0, z: 0 };
+      center[u] = (minU + maxU) / 2;
+      center[v] = (minV + maxV) / 2;
+      return opts.mint(
+        {
+          center,
+          width: Math.max(minExtent, maxU - minU),
+          depth: Math.max(minExtent, maxV - minV)
+        },
+        extras
+      );
+    }
+  };
+}
+var AXES = ["x", "y", "z"];
+var BITS = [1, 2, 4];
+var UNIT = { x: { x: 1, y: 0, z: 0 }, y: { x: 0, y: 1, z: 0 }, z: { x: 0, y: 0, z: 1 } };
+var ACROSS = { x: [UNIT.y, UNIT.z], y: [UNIT.x, UNIT.z], z: [UNIT.x, UNIT.y] };
+function boxesOf(world, q) {
+  const excluded = new Set(q.exclude);
+  const out = [];
+  for (const node of world.scene.renderOrderNodes()) {
+    if (!excluded.has(node.id)) out.push(boundsOfNode(world, node));
+  }
+  return out;
+}
+function distanceToBox(p, box) {
+  const d = (a) => Math.max(box.min[a] - p[a], 0, p[a] - box.max[a]);
+  return Math.hypot(d("x"), d("y"), d("z"));
+}
+var centerOf = (box) => scale(add(box.min, box.max), 0.5);
+var isZero = (v) => v.x === 0 && v.y === 0 && v.z === 0;
+function boxSnapSource(world) {
+  return {
+    id: "box",
+    roles: ["geometry", "pointer"],
+    *collect(q) {
+      const r = q.reachWorld(q.reachPx);
+      for (const box of boxesOf(world, q)) {
+        for (const p of q.probes) {
+          if (distanceToBox(p.at, box) <= r) yield* boxLoci(p.id, p.at, box, r);
+        }
+      }
+    }
+  };
+}
+function* boxLoci(probe, at, box, r) {
+  for (let i = 0; i < 8; i++) {
+    const c = boxCorner(box, i);
+    if (distance(at, c) <= r) yield { probe, locus: { at: c, dirs: [] }, mark: { kind: "point", at: c, glyph: "corner" } };
+  }
+  const center = centerOf(box);
+  if (distance(at, center) <= r) {
+    yield { probe, locus: { at: center, dirs: [] }, mark: { kind: "point", at: center, glyph: "center" } };
+  }
+  for (let i = 0; i < 8; i++) {
+    for (const bit of BITS) {
+      if (i & bit) continue;
+      const a = boxCorner(box, i);
+      const b = boxCorner(box, i | bit);
+      const dir = sub(b, a);
+      if (isZero(dir) || distanceToBox(at, { min: a, max: b }) > r) continue;
+      yield { probe, locus: { at: a, dirs: [dir], span: [[0, 1]] }, mark: { kind: "line", from: a, to: b } };
+    }
+  }
+  for (const bit of BITS) {
+    const [b1, b2] = BITS.filter((b) => b !== bit);
+    for (const base of [0, bit]) {
+      const o = boxCorner(box, base);
+      const far = boxCorner(box, base | b1 | b2);
+      const d1 = sub(boxCorner(box, base | b1), o);
+      const d2 = sub(boxCorner(box, base | b2), o);
+      if (isZero(d1) || isZero(d2) || distanceToBox(at, { min: o, max: far }) > r) continue;
+      yield {
+        probe,
+        locus: { at: o, dirs: [d1, d2], span: [[0, 1], [0, 1]] },
+        mark: () => outline([o, boxCorner(box, base | b1), far, boxCorner(box, base | b2)])
+      };
+    }
+  }
+}
+function outline(ring) {
+  return ring.map((from, i) => ({ kind: "line", from, to: ring[(i + 1) % ring.length] }));
+}
+function alignPlaneSource(world) {
+  return {
+    id: "align-plane",
+    roles: ["box", "pointer"],
+    *collect(q) {
+      const r = q.reachWorld(q.reachPx);
+      for (const [axis, planes] of planesOf(boxesOf(world, q))) {
+        for (const [value, ends] of planes) {
+          for (const p of q.probes) {
+            if (Math.abs(p.at[axis] - value) > r) continue;
+            yield {
+              probe: p.id,
+              locus: { at: ends[0], dirs: ACROSS[axis] },
+              mark: (delta) => {
+                const from = add(sub(p.at, q.delta0), delta);
+                return ends.map((to) => ({ kind: "line", from, to }));
+              }
+            };
+          }
+        }
+      }
+    }
+  };
+}
+function planesOf(boxes) {
+  const out = new Map(AXES.map((a) => [a, /* @__PURE__ */ new Map()]));
+  for (const box of boxes) {
+    const center = centerOf(box);
+    for (const axis of AXES) {
+      const planes = out.get(axis);
+      for (const value of /* @__PURE__ */ new Set([box.min[axis], center[axis], box.max[axis]])) {
+        const on = { ...center, [axis]: value };
+        const ends = planes.get(value);
+        if (ends) ends.push(on);
+        else planes.set(value, [on]);
+      }
+    }
+  }
+  return out;
+}
+function groundGridSource(opts) {
+  const up = normalize(opts.up ?? DEFAULT_UP);
+  const [u, v] = planeBasis(up);
+  const lines = (c) => {
+    const near = Math.round(c / opts.step) * opts.step;
+    return [near, near + (c >= near ? opts.step : -opts.step)];
+  };
+  return {
+    id: "ground-grid",
+    tier: "fallback",
+    reachPx: Infinity,
+    roles: ["pointer", "geometry"],
+    *collect(q) {
+      for (const p of q.probes) {
+        if (Math.abs(dot(p.at, up)) > 1e-6 * Math.max(1, len(p.at))) continue;
+        const a = dot(p.at, u);
+        const b = dot(p.at, v);
+        for (const at of lines(a)) yield { probe: p.id, locus: { at: add(scale(u, at), scale(v, b)), dirs: [v] } };
+        for (const at of lines(b)) yield { probe: p.id, locus: { at: add(scale(u, a), scale(v, at)), dirs: [u] } };
+      }
+    }
+  };
+}
+
+// src/snap/marks.ts
+function projectSnapMarks(marks, viewport) {
+  const lines = [];
+  const points = [];
+  for (const m of marks) {
+    if (m.kind === "point") {
+      const at = projectPoint(m.at, viewport);
+      if (at) {
+        points.push({
+          at,
+          glyph: m.glyph,
+          ...m.label !== void 0 ? { label: m.label } : {},
+          ...m.color ? { color: m.color } : {}
+        });
+      }
+      continue;
+    }
+    const from = projectPoint(m.from, viewport);
+    const to = projectPoint(m.to, viewport);
+    if (!from || !to) continue;
+    lines.push({
+      from,
+      to,
+      ..."value" in m ? { value: m.value } : {},
+      ...m.color ? { color: m.color } : {}
+    });
+  }
+  return { lines, points };
+}
 function collectOverlayBoxes(handles, origin) {
   const overlays = [];
-  for (const handle of handles) {
-    const ov = handle.overlay?.();
-    if (ov) overlays.push(ov);
-  }
+  for (const handle of handles) overlays.push(...overlaysOf(handle));
   const boxes = [];
   for (const resolved of resolveOverlays(overlays)) {
     if (resolved.kind !== "marquee" && resolved.kind !== "insertPreview") continue;
@@ -429,41 +795,117 @@ function collectOverlayBoxes(handles, origin) {
 }
 var ORBIT_RATE = 6e-3;
 var DOLLY_RATE = 15e-4;
+function screenDelta(move) {
+  return move.drag?.screenDelta ?? move.drag?.delta;
+}
+function dragCamera(ctx, kind, step) {
+  const dep = ctx.deps.camera3d;
+  const origin = dep?.get();
+  return {
+    kind,
+    onMove(move) {
+      const delta = screenDelta(move);
+      if (!dep || !origin || !delta) return;
+      dep.set(step(origin, delta, dep));
+    }
+  };
+}
 var orbitAction = {
   id: "camera.orbit",
   label: "Orbit",
+  group: "viewport",
+  cursor: "grab",
+  activeCursor: "grabbing",
+  requires: ["camera3d", "kitSettings"],
+  invoker: {
+    timing: "ongoing",
+    start(ctx) {
+      const rate = ctx.deps.kitSettings?.get("orbit3d.orbitRate") ?? ORBIT_RATE;
+      return dragCamera(ctx, "orbit", (origin, d, dep) => orbitBy(origin, -d.x * rate, d.y * rate, dep.limits?.()));
+    }
+  }
+};
+var panAction = {
+  id: "camera.pan",
+  label: "Pan",
+  group: "viewport",
+  cursor: "move",
+  requires: ["camera3d"],
+  invoker: {
+    timing: "ongoing",
+    start(ctx) {
+      return dragCamera(ctx, "pan", (origin, d, dep) => panBy(origin, d.x, d.y, dep.size().height));
+    }
+  }
+};
+function anchorOf(params, pane) {
+  const x = params?.clientX;
+  const y = params?.clientY;
+  return typeof x === "number" && typeof y === "number" ? { x, y } : { x: pane.width / 2, y: pane.height / 2 };
+}
+var dollyAction = {
+  id: "camera.dolly",
+  label: "Dolly",
+  group: "viewport",
+  defaultBinding: [
+    { spec: { kind: "wheel" }, opts: {} },
+    // Unbound, a trackpad pinch zooms the page instead.
+    { spec: { kind: "wheel", mods: { ctrl: true } }, opts: {} },
+    { spec: { kind: "pinch" }, opts: {} }
+  ],
+  requires: ["camera3d", "kitSettings"],
+  invoker: {
+    timing: "immediate",
+    run(deps, params) {
+      const dep = deps.camera3d;
+      if (!dep) return;
+      const factor = typeof params?.scale === "number" ? 1 / params.scale : Math.exp(
+        (typeof params?.deltaY === "number" ? params.deltaY : 0) * (deps.kitSettings?.get("orbit3d.dollyRate") ?? DOLLY_RATE)
+      );
+      if (!(factor > 0) || !Number.isFinite(factor)) return;
+      const pane = dep.size();
+      dep.set(dollyToward(dep.get(), factor, anchorOf(params, pane), pane, dep.limits?.()));
+    }
+  }
+};
+var pinchDollyAction = {
+  id: "camera.pinchDolly",
+  label: "Pinch Dolly",
+  group: "viewport",
+  defaultBinding: { kind: "multiTouch", fingers: 2 },
   requires: ["camera3d"],
   invoker: {
     timing: "ongoing",
     start(ctx) {
       const dep = ctx.deps.camera3d;
       const origin = dep?.get();
+      const startSpread = ctx.multiTouch?.spread ?? 0;
+      const at = ctx.multiTouch?.centroid;
       return {
-        kind: "orbit",
+        kind: "pinch",
         onMove(move) {
-          if (!dep || !origin) return;
-          const delta = move.drag?.screenDelta ?? move.drag?.delta;
-          if (!delta) return;
-          dep.set(orbitBy(origin, -delta.x * ORBIT_RATE, delta.y * ORBIT_RATE));
+          const spread = move.multiTouch?.pinch?.currentSpread ?? 0;
+          if (!dep || !origin || !(startSpread > 0) || !(spread > 0)) return;
+          const pane = dep.size();
+          const anchor = at ?? { x: pane.width / 2, y: pane.height / 2 };
+          dep.set(dollyToward(origin, startSpread / spread, anchor, pane, dep.limits?.()));
         }
       };
     }
   }
 };
-var dollyAction = {
-  id: "camera.dolly",
-  label: "Dolly",
+var homeAction = {
+  id: "camera.home",
+  label: "Reset Camera",
   group: "viewport",
-  // Wheel, in any tool — the dispatcher merges the event's deltas into params.
-  defaultBinding: [{ spec: { kind: "wheel" }, opts: {} }],
+  defaultBinding: { kind: "doubleClick" },
   requires: ["camera3d"],
   invoker: {
     timing: "immediate",
-    run(deps, params) {
+    run(deps) {
       const dep = deps.camera3d;
-      if (!dep) return;
-      const amount = typeof params?.deltaY === "number" ? params.deltaY : 0;
-      dep.set(dollyBy(dep.get(), Math.exp(amount * DOLLY_RATE)));
+      const home = dep?.home?.();
+      if (dep && home) dep.set(home);
     }
   }
 };
@@ -473,10 +915,19 @@ function useOrbitTool() {
     hookName: "useOrbitTool",
     cursor: "grab",
     presentation: { label: "Orbit", group: "viewport" },
-    bindings: [{ spec: { kind: "drag" }, actionId: "camera.orbit" }]
+    bindings: [
+      { spec: { kind: "drag" }, actionId: "camera.orbit" },
+      { spec: { kind: "drag", mods: { shift: true } }, actionId: "camera.pan" }
+    ]
   }), []);
 }
+var kernel3dKitSettingsSchema = pref.group("3D camera", {
+  orbit3d: pref.group("Orbit", {
+    orbitRate: pref.number("Orbit speed", ORBIT_RATE, { min: 1e-3, max: 0.03, step: 1e-3 }),
+    dollyRate: pref.number("Dolly speed", DOLLY_RATE, { min: 2e-4, max: 0.01, step: 1e-4 })
+  })
+});
 
-export { MAX_PITCH, UNIT_CUBE, aabbOfPose, cameraEye, cameraView, cameraViewProjection, collectOverlayBoxes, createAreaSelect, createCamera, createInsert, createNodeAtPoint, createPoseDescriptor, createSnap, dollyAction, dollyBy, ndcToScreen, orbitAction, orbitBy, pose3, poseMatrix, projectAabbToScreen, rayThroughScreenPoint, screenBoxOf, screenToNdc, useOrbitTool };
+export { DEFAULT_ORBIT_LIMITS, MAX_PITCH, UNIT_CUBE, aabbOfPose, alignPlaneSource, boxSnapSource, cameraEye, cameraView, cameraViewProjection, clampCamera, collectOverlayBoxes, createAreaSelect, createCamera, createInsert, createNodeAtPoint, createPoseDescriptor, createSnap, dollyAction, dollyBy, dollyToward, groundGridSource, homeAction, kernel3dKitSettingsSchema, ndcToScreen, orbitAction, orbitBy, panAction, panBy, pinchDollyAction, pose3, poseMatrix, projectAabbToScreen, projectPoint, projectSnapMarks, rayThroughScreenPoint, screenBoxOf, screenToNdc, useOrbitTool };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map