@weasel-js/kernel3d 1.13.0-rc.0 → 1.14.0

package/dist/index.js

@@ -1,7 +1,7 @@
-import { lookAt, multiply, perspective, add, scale, quatIdentity, compose, transformAabb, invert, transformPoint, normalize, sub, transformPoint4, distance, dot, len, intersectRayPlane, pointOnRay, cross, intersectRayAabb, aabbOfPoints } from '@weasel-js/geom/3d';
-import { createSnapOutcomeStore, assertSnapSourceIds, DEFAULT_SNAP_PX, overlaysOf, resolveOverlays, defineTool, snapSourcesFor, resolvedSnapMarks, SNAP_AXIS_STEP, gatherSnapCandidates } from '@weasel-js/core';
+import { lookAt, multiply, perspective, add, scale, quatIdentity, compose, transformAabb, quatMultiply, quatConjugate, quatRotate, sub, invert, transformPoint, normalize, transformPoint4, distance, dot, len, intersectRayPlane, pointOnRay, cross, intersectRayAabb, aabbOfPoints } from '@weasel-js/geom/3d';
+import { scenePoseFrame, createSnapOutcomeStore, assertSnapSourceIds, DEFAULT_SNAP_PX, overlaysOf, resolveOverlays, defineTool, snapSourcesFor, resolvedSnapMarks, SNAP_AXIS_STEP, gatherSnapCandidates, scenePoseAdapter, composeWorldPose } from '@weasel-js/core';
 import { isDev } from '@weasel-js/react';
-import { closestOnFlat, resolveSnap, createBvh, stepLine } from '@weasel-js/geom/nd';
+import { closestOnFlat, resolveSnap, createBvh, stepLine, createSettledCache } from '@weasel-js/geom/nd';
 import { useMemo } from 'react';
 import { pref } from '@weasel-js/prefs';
 
@@ -94,6 +94,26 @@ function poseMatrix(pose) {
 function aabbOfPose(pose, local = UNIT_CUBE) {
   return transformAabb(poseMatrix(pose), local);
 }
+var times = (a, b) => ({ x: a.x * b.x, y: a.y * b.y, z: a.z * b.z });
+var over = (a, s, zero) => ({
+  x: s.x === 0 ? zero.x : a.x / s.x,
+  y: s.y === 0 ? zero.y : a.y / s.y,
+  z: s.z === 0 ? zero.z : a.z / s.z
+});
+var ORIGIN = { x: 0, y: 0, z: 0 };
+var POSE3_COMPOSITION = {
+  compose: (parent, child) => ({
+    position: add(parent.position, quatRotate(parent.rotation, times(parent.scale, child.position))),
+    rotation: quatMultiply(parent.rotation, child.rotation),
+    scale: times(parent.scale, child.scale)
+  }),
+  decompose: (parent, world) => ({
+    position: over(quatRotate(quatConjugate(parent.rotation), sub(world.position, parent.position)), parent.scale, ORIGIN),
+    rotation: quatMultiply(quatConjugate(parent.rotation), world.rotation),
+    scale: over(world.scale, parent.scale, world.scale)
+  }),
+  closure: "rigid"
+};
 function screenToNdc(point, rect) {
   return {
     x: (point.x - rect.x) / rect.width * 2 - 1,
@@ -195,21 +215,73 @@ function projectPoint(p, viewport) {
   return Number.isFinite(screen.x) && Number.isFinite(screen.y) ? screen : null;
 }
 
-// src/world.ts
+// src/ground.ts
+function groundAxes(up) {
+  if (up.y !== 0) return { u: "x", v: "z", up: "y" };
+  if (up.x !== 0) return { u: "y", v: "z", up: "x" };
+  return { u: "x", v: "y", up: "z" };
+}
+function groundHit(viewport, point, up) {
+  const ray = rayAt(viewport, point);
+  const t = ray && intersectRayPlane(ray, up, 0);
+  return ray && t !== null ? pointOnRay(ray, t) : null;
+}
+function toAimPoint(p, axes) {
+  return { x: p[axes.u], y: p[axes.v], z: p[axes.up] };
+}
+function fromAimPoint(p, axes) {
+  const out = { x: 0, y: 0, z: 0 };
+  out[axes.u] = p.x;
+  out[axes.v] = p.y;
+  out[axes.up] = p.z ?? 0;
+  return out;
+}
 var DEFAULT_UP = { x: 0, y: 1, z: 0 };
-function boundsOfNode(world, node) {
-  return world.bounds ? world.bounds(node) : aabbOfPose(node.pose);
+function worldPoseOf(scene, id) {
+  return scene.get(id) === void 0 ? void 0 : worldPoses(scene, "shown")(id);
+}
+function worldPoses(scene, reading) {
+  const untyped = scene;
+  if (reading === "shown") {
+    const frame = scenePoseFrame(untyped);
+    return (id) => frame.world(id);
+  }
+  const adapter = scenePoseAdapter(untyped);
+  const compose2 = scene.composition.compose;
+  return (id) => composeWorldPose(adapter, id, compose2);
+}
+function boxAt(world, node, pose) {
+  if (world.bounds) return world.bounds(pose === node.pose ? node : { ...node, pose });
+  return node.kind === "group" ? null : aabbOfPose(pose);
+}
+function measuredBoxAt(world, node, pose) {
+  return boxAt(world, node, pose) ?? pointBox(pose.position);
+}
+function worldBoxes(world, reading) {
+  const poseOf = worldPoses(world.scene, reading);
+  return (node) => boxAt(world, node, poseOf(node.id));
+}
+function withDescendants(scene, ids) {
+  const out = /* @__PURE__ */ new Set();
+  const queue = [...ids];
+  while (queue.length > 0) {
+    const id = queue.pop();
+    if (out.has(id)) continue;
+    out.add(id);
+    queue.push(...scene.childrenOf(id));
+  }
+  return out;
+}
+function pointBox(p) {
+  return { min: p, max: p };
 }
 
 // src/pickIndex.ts
 function screenBoxOf(world, id, viewport) {
   const node = world.scene.get(id);
-  if (!node) return null;
-  return projectAabbToScreen(
-    boundsOfNode(world, node),
-    viewProjectionOf(viewport),
-    rectOf(viewport)
-  );
+  const pose = node && worldPoseOf(world.scene, id);
+  const box = node && pose && boxAt(world, node, pose);
+  return box ? projectAabbToScreen(box, viewProjectionOf(viewport), rectOf(viewport)) : null;
 }
 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;
@@ -238,14 +310,12 @@ function sidePlanes(vp, rect) {
   ];
 }
 var BuiltIndex = class {
-  constructor(world, order, boxes, tree, always) {
-    this.world = world;
+  constructor(order, boxes, tree, always) {
     this.order = order;
     this.boxes = boxes;
     this.tree = tree;
     this.always = always;
   }
-  world;
   order;
   boxes;
   tree;
@@ -255,8 +325,9 @@ var BuiltIndex = class {
     let best = -1;
     let bestT = Infinity;
     const consider = (i) => {
+      const box = boxes[i];
       if (excluded?.has(order[i].id)) return;
-      const t = intersectRayAabb(ray, boxes[i].min, boxes[i].max);
+      const t = intersectRayAabb(ray, box.min, box.max);
       if (t !== null && (t < bestT || t === bestT && i < best)) {
         bestT = t;
         best = i;
@@ -278,10 +349,11 @@ var BuiltIndex = class {
     });
     candidates.sort((a, b) => a - b);
     const hits = [];
+    const m = viewProjectionOf(vp);
+    const pane = rectOf(vp);
     for (const i of candidates) {
-      const id = this.order[i].id;
-      const box = screenBoxOf(this.world, id, vp);
-      if (box && overlaps(box, rect)) hits.push(id);
+      const box = projectAabbToScreen(this.boxes[i], m, pane);
+      if (box && overlaps(box, rect)) hits.push(this.order[i].id);
     }
     return hits;
   }
@@ -300,14 +372,16 @@ function padded({ min, max }) {
   return [min.x - e, min.y - e, min.z - e, max.x + e, max.y + e, max.z + e];
 }
 function build(world, order) {
-  const boxes = order.map((node) => boundsOfNode(world, node));
+  const boxOf = worldBoxes(world, "shown");
+  const boxes = order.map(boxOf);
   const entries = [];
   const always = [];
   boxes.forEach((b, i) => {
+    if (b === null) return;
     if (boxValid(b)) entries.push([i, padded(b)]);
     else always.push(i);
   });
-  return new BuiltIndex(world, order, boxes, createBvh(3, entries), always);
+  return new BuiltIndex(order, boxes, createBvh(3, entries), always);
 }
 function worldPickIndex(world) {
   const { scene } = world;
@@ -338,16 +412,20 @@ function inputFlat3d(c, held, basis, delta0, about) {
   return stepLine(tuple(c === "axis" ? ZERO : about), tuple(delta0), [tuple(u), tuple(v)], step);
 }
 function subjectOf(world, ids, up) {
+  const { scene } = world;
+  const poseOf = worldPoses(scene, "shown");
+  const nodeOf = (id) => scene.get(id);
+  const lead = ids.find((id) => nodeOf(id) !== void 0);
+  if (lead === void 0) return null;
+  const leadPose = poseOf(lead);
+  const anchor = { box: measuredBoxAt(world, nodeOf(lead), leadPose), height: dot(up, leadPose.position) };
   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;
+  for (const id of withDescendants(scene, ids)) {
+    const node = nodeOf(id);
+    const b = node && boxAt(world, node, poseOf(node.id));
+    if (b) box = box ? union(box, b) : b;
   }
-  return box && anchor ? { box, anchor } : null;
+  return { box: box ?? anchor.box, anchor };
 }
 function union(a, b) {
   return {
@@ -503,6 +581,10 @@ function onPlane(vp, plane, point) {
   const t = intersectRayPlane(ray, plane.normal, plane.offset);
   return t === null ? null : pointOnRay(ray, t);
 }
+function movedOnLevel(pose, delta, upAxis) {
+  const position = { ...add(pose.position, delta), [upAxis]: pose.position[upAxis] };
+  return { ...pose, position };
+}
 function createNodeAtPoint(world) {
   return (point, exclude) => {
     const ray = rayAt(world.viewport(), point);
@@ -546,7 +628,7 @@ function createSnap(world, opts = {}) {
 }
 function createPoseDescriptor(world) {
   const up = world.up ?? DEFAULT_UP;
-  const upAxis = up.y !== 0 ? "y" : up.x !== 0 ? "x" : "z";
+  const upAxis = groundAxes(up).up;
   const specialized = /* @__PURE__ */ new WeakMap();
   let lastCastable = null;
   function castableViewport() {
@@ -555,14 +637,14 @@ function createPoseDescriptor(world) {
     if (rayAt(vp, { x: rect.x + rect.width / 2, y: rect.y + rect.height / 2 })) lastCastable = vp;
     return lastCastable;
   }
-  function build2(worldBox) {
+  function build3(worldBox) {
     const boundsIn = (vp, pose) => projectAabbToScreen(worldBox(pose), viewProjectionOf(vp), rectOf(vp));
     const boundsOf = (pose) => boundsIn(world.viewport(), pose);
     const descriptor = {
       forNode(node) {
         let d = specialized.get(node);
         if (!d) {
-          d = build2((pose) => boundsOfNode(world, { ...node, pose }));
+          d = build3((pose) => measuredBoxAt(world, node, pose));
           specialized.set(node, d);
         }
         return d;
@@ -645,31 +727,20 @@ function createPoseDescriptor(world) {
           scale: sub(box.max, box.min)
         };
       },
-      /** Screen-space deltas resolve against the plane the node already sits on. */
-      translate(pose, dx, dy) {
+      /**
+       * Screen-space deltas resolve against the plane the node already sits on. That
+       * plane differs per node, so in a move of several each takes the lead's change
+       * whole (it kept its height already), and the group moves as one body. */
+      translate(pose, dx, dy, lead) {
+        if (lead) return { ...pose, position: add(pose.position, sub(lead.to.position, lead.from.position)) };
         const vp = castableViewport();
-        if (!vp) return pose;
-        const box = boundsIn(vp, pose);
-        if (!box) return pose;
+        const box = vp && boundsIn(vp, pose);
+        if (!vp || !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 = dot(up, pose.position);
-        const ray = rayAt(vp, to);
-        if (!ray) return pose;
-        const t = intersectRayPlane(ray, up, offset);
-        if (t === null) return pose;
-        const anchorRay = rayAt(vp, from);
-        if (!anchorRay) return pose;
-        const anchorT = intersectRayPlane(anchorRay, up, offset);
-        if (anchorT === null) return pose;
-        const delta = sub(pointOnRay(ray, t), pointOnRay(anchorRay, anchorT));
-        const position = {
-          x: pose.position.x + delta.x,
-          y: pose.position.y + delta.y,
-          z: pose.position.z + delta.z
-        };
-        position[upAxis] = pose.position[upAxis];
-        return { ...pose, position };
+        const level2 = { normal: up, offset: dot(up, pose.position) };
+        const before = onPlane(vp, level2, from);
+        const after = onPlane(vp, level2, { x: from.x + dx, y: from.y + dy });
+        return before && after ? movedOnLevel(pose, sub(after, before), upAxis) : pose;
       },
       supportsRotation() {
         return false;
@@ -677,7 +748,7 @@ function createPoseDescriptor(world) {
     };
     return descriptor;
   }
-  return build2((pose) => aabbOfPose(pose));
+  return build3((pose) => aabbOfPose(pose));
 }
 function footprintPoints(bounds, ends, cast) {
   if (ends) {
@@ -697,18 +768,12 @@ function footprintPoints(bounds, ends, cast) {
 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"];
+  const { u, v } = groundAxes(up);
   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);
+      const hits = footprintPoints(bounds, ends, (p) => groundHit(vp, p, up));
       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]);
@@ -730,7 +795,6 @@ function createInsert(opts) {
     }
   };
 }
-var GROUND_NORMAL = { x: 0, y: 0, z: 1 };
 function paneCorners(viewport) {
   const { x, y, width, height } = rectOf(viewport);
   return [
@@ -756,13 +820,24 @@ function frustumOf(viewport) {
     far: at(camera.far)
   };
 }
-function groundHit(viewport, point) {
-  const ray = rayAt(viewport, point);
-  const t = ray && intersectRayPlane(ray, GROUND_NORMAL, 0);
-  return ray && t !== null ? pointOnRay(ray, t) : null;
-}
-function toZ(p) {
-  return { x: p.x, y: p.y, z: p.z ?? 0 };
+function footprint(f, up, axes) {
+  const edges = [];
+  for (let i = 0; i < 4; i++) {
+    const j = (i + 1) % 4;
+    edges.push([f.near[i], f.near[j]], [f.far[i], f.far[j]], [f.near[i], f.far[i]]);
+  }
+  const hits = [];
+  for (const [a, b] of edges) {
+    const ha = dot(a, up), hb = dot(b, up);
+    if (ha > 0 && hb > 0 || ha < 0 && hb < 0 || ha === hb) continue;
+    const hit = toAimPoint(add(a, scale(sub(b, a), ha / (ha - hb))), axes);
+    hits.push({ x: hit.x, y: hit.y });
+  }
+  if (hits.length < 3) return null;
+  const cx = hits.reduce((s, p) => s + p.x, 0) / hits.length;
+  const cy = hits.reduce((s, p) => s + p.y, 0) / hits.length;
+  const around = hits.map((p) => ({ p, a: Math.atan2(p.y - cy, p.x - cx) })).sort((u, v) => u.a - v.a).map((u) => u.p).filter((p, i, all) => i === 0 || Math.hypot(p.x - all[i - 1].x, p.y - all[i - 1].y) > 1e-9);
+  return around.length >= 3 ? around : null;
 }
 function projectAll(space, points) {
   const out = [];
@@ -773,7 +848,9 @@ function projectAll(space, points) {
   }
   return out;
 }
-function aimOf3d(viewport, viewId) {
+function aimOf3d(viewport, viewId, opts = {}) {
+  const up = opts.up ?? DEFAULT_UP;
+  const axes = groundAxes(up);
   const extent = frustumOf(viewport);
   return {
     viewId,
@@ -781,54 +858,113 @@ function aimOf3d(viewport, viewId) {
     extent,
     viewport,
     outlineIn(space) {
-      if (space.kind === "3d") return projectAll(space, extent.far);
-      const onGround = [];
-      for (const c of paneCorners(viewport)) {
-        const hit = groundHit(viewport, c);
-        if (!hit) return null;
-        onGround.push(hit);
-      }
-      return projectAll(space, onGround);
+      if (space.kind === "3d") return projectAll(space, extent.far.map((p) => toAimPoint(p, axes)));
+      const onGround = footprint(extent, up, axes);
+      return onGround && projectAll(space, onGround);
     },
     pannedIn(space, from, to) {
       const a = space.unproject(from);
       const b = space.unproject(to);
       if (!a || !b) return null;
       const { camera } = viewport;
-      const target = add(camera.target, sub(toZ(b), toZ(a)));
-      return aimOf3d({ ...viewport, camera: { ...camera, target } }, viewId);
+      const target = add(camera.target, sub(fromAimPoint(b, axes), fromAimPoint(a, axes)));
+      return aimOf3d({ ...viewport, camera: { ...camera, target } }, viewId, opts);
     }
   };
 }
-function aimSpace3d(viewport, viewId) {
+function aimSpace3d(viewport, viewId, opts = {}) {
+  const up = opts.up ?? DEFAULT_UP;
+  const axes = groundAxes(up);
   const { x: ox, y: oy } = rectOf(viewport);
   return {
     viewId,
     kind: "3d",
     size: { width: viewport.width, height: viewport.height },
     project(p) {
-      const s = projectPoint(toZ(p), viewport);
+      const s = projectPoint(fromAimPoint(p, axes), viewport);
       return s && { x: s.x - ox, y: s.y - oy };
     },
     unproject(px) {
-      return groundHit(viewport, { x: px.x + ox, y: px.y + oy });
+      const hit = groundHit(viewport, { x: px.x + ox, y: px.y + oy }, up);
+      return hit && toAimPoint(hit, axes);
     }
   };
 }
 function cameraOfAim3d(aim) {
   return aim.viewport.camera;
 }
+var CACHE2 = /* @__PURE__ */ new WeakMap();
+function nodesOf(world) {
+  return world.scene.renderOrderNodes();
+}
+function boxValid2({ min, max }) {
+  return Number.isFinite(min.x) && Number.isFinite(min.y) && Number.isFinite(min.z) && Number.isFinite(max.x) && Number.isFinite(max.y) && Number.isFinite(max.z) && min.x <= max.x && min.y <= max.y && min.z <= max.z;
+}
+function build2(world) {
+  const nodes = nodesOf(world);
+  const boxes = nodes.map(worldBoxes(world, "document"));
+  const entries = [];
+  const always = [];
+  boxes.forEach((box, i) => {
+    if (box === null) return;
+    const { min, max } = box;
+    if (boxValid2(box)) entries.push([i, [min.x, min.y, min.z, max.x, max.y, max.z]]);
+    else always.push(i);
+  });
+  return { ids: nodes.map((n) => n.id), boxes, tree: createBvh(3, entries), always };
+}
+function current(world) {
+  let cache = CACHE2.get(world);
+  if (cache === void 0) CACHE2.set(world, cache = createSettledCache());
+  return cache.read([world.scene.getVersion(), world.bounds], () => build2(world));
+}
+function padQuery(box) {
+  let m = 0;
+  for (const v of box) if (Number.isFinite(v)) m = Math.max(m, Math.abs(v));
+  const e = 1e-9 * (1 + m);
+  return [box[0] - e, box[1] - e, box[2] - e, box[3] + e, box[4] + e, box[5] + e];
+}
+function snapBoxes(world, exclude, near) {
+  const excluded = withDescendants(world.scene, exclude);
+  const index = near.every((b) => Array.prototype.every.call(b, (v) => !Number.isNaN(v))) ? current(world) : null;
+  if (index === null) {
+    const boxOf = worldBoxes(world, "document");
+    const out2 = [];
+    for (const node of nodesOf(world)) {
+      const box = excluded.has(node.id) ? null : boxOf(node);
+      if (box) out2.push(box);
+    }
+    return out2;
+  }
+  const found = new Set(index.always);
+  for (const box of near) index.tree.queryBox(box, (i) => {
+    found.add(i);
+  });
+  const out = [];
+  for (const i of [...found].sort((a, b) => a - b)) {
+    if (!excluded.has(index.ids[i])) out.push(index.boxes[i]);
+  }
+  return out;
+}
+
+// src/snap/sources.ts
 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 boxesNear(world, q, r) {
+  return snapBoxes(world, q.exclude, q.probes.map(({ at: p }) => padQuery([p.x - r, p.y - r, p.z - r, p.x + r, p.y + r, p.z + r])));
+}
+function boxesInSlabs(world, q, r) {
+  const slabs = q.probes.flatMap(({ at: p }) => AXES.map((axis) => {
+    const lo = [-Infinity, -Infinity, -Infinity];
+    const hi = [Infinity, Infinity, Infinity];
+    const k = AXES.indexOf(axis);
+    lo[k] = p[axis] - r;
+    hi[k] = p[axis] + r;
+    return padQuery([...lo, ...hi]);
+  }));
+  return snapBoxes(world, q.exclude, slabs);
 }
 function distanceToBox(p, box) {
   const d = (a) => Math.max(box.min[a] - p[a], 0, p[a] - box.max[a]);
@@ -842,7 +978,7 @@ function boxSnapSource(world) {
     roles: ["geometry", "pointer"],
     *collect(q) {
       const r = q.reachWorld(q.reachPx);
-      for (const box of boxesOf(world, q)) {
+      for (const box of boxesNear(world, q, r)) {
         for (const p of q.probes) {
           if (distanceToBox(p.at, box) <= r) yield* boxLoci(p.id, p.at, box, r);
         }
@@ -894,7 +1030,7 @@ function alignPlaneSource(world) {
     roles: ["box", "pointer"],
     *collect(q) {
       const r = q.reachWorld(q.reachPx);
-      for (const [axis, planes] of planesOf(boxesOf(world, q))) {
+      for (const [axis, planes] of planesOf(boxesInSlabs(world, q, r))) {
         for (const [value, ends] of planes) {
           for (const p of q.probes) {
             if (Math.abs(p.at[axis] - value) > r) continue;
@@ -1127,6 +1263,6 @@ var kernel3dKitSettingsSchema = pref.group("3D camera", {
   })
 });
 
-export { DEFAULT_ORBIT_LIMITS, MAX_PITCH, UNIT_CUBE, aabbOfPose, aimOf3d, aimSpace3d, alignPlaneSource, boxSnapSource, cameraEye, cameraOfAim3d, 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 };
+export { DEFAULT_ORBIT_LIMITS, MAX_PITCH, POSE3_COMPOSITION, UNIT_CUBE, aabbOfPose, aimOf3d, aimSpace3d, alignPlaneSource, boxSnapSource, cameraEye, cameraOfAim3d, 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, worldPoseOf };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map