@weasel-js/kernel3d 1.18.2 → 1.19.0

package/dist/index.d.ts

@@ -53,14 +53,16 @@ declare const DEFAULT_ORBIT_LIMITS: OrbitLimits;
  *  itself when it already holds. */
 declare function clampCamera(camera: Camera3d, limits?: Partial<OrbitLimits>): Camera3d;
 /** The camera turned about its target by the given radians, pitch held inside
- *  `limits`. Yaw is not wrapped. */
+ *  `limits`. Yaw is not wrapped. A turn that is not finite leaves it as it is. */
 declare function orbitBy(camera: Camera3d, deltaYaw: number, deltaPitch: number, limits?: Partial<OrbitLimits>): Camera3d;
-/** The camera with its distance multiplied by `factor`, held inside `limits`. */
+/** The camera with its distance multiplied by `factor`, held inside `limits`.
+ *  A `NaN` factor leaves it as it is. */
 declare function dollyBy(camera: Camera3d, factor: number, limits?: Partial<OrbitLimits>): Camera3d;
 /**
  * The camera with its target slid across the screen plane, so the point at the
  * target follows a pointer that moved `dx`, `dy` CSS pixels in a pane
- * `paneHeight` pixels tall. Neither angle nor distance changes.
+ * `paneHeight` pixels tall. Neither angle nor distance changes. A pan that
+ * carries the target past the double range leaves the camera as it is.
  */
 declare function panBy(camera: Camera3d, dx: number, dy: number, paneHeight: number): Camera3d;
 /**
@@ -219,8 +221,8 @@ type Point$1 = {
     x: number;
     y: number;
 };
-/** Where `p` draws in the viewport, or null when it is behind the near plane
- *  or projects to nothing finite. */
+/** Where `p` draws in the viewport, or null when it is behind the near plane,
+ *  the pane has no area, or it projects to nothing finite. */
 declare function projectPoint(p: Vec3, viewport: Viewport3d): Point$1 | null;
 
 /** The 3D world every dep is built from: core's scene with a `Pose3`, the
@@ -368,6 +370,8 @@ interface Footprint {
  */
 declare function createInsert(opts: {
     viewport: ViewportSource;
+    /** The view whose camera a drag is cast through, for a `<CanvasView deps>` of its own. Default the surface's. */
+    viewId?: string | null;
     up?: Vec3;
     /** Smallest footprint a click-sized drag produces. Default 0.25. */
     minExtent?: number;
@@ -439,8 +443,9 @@ interface GroundGridSourceOptions {
 /**
  * A grid on the ground plane as snap targets: for each pointer or geometry
  * probe on the ground, the grid line on either side of it along each of the
- * ground's two axes. Its reach is unlimited and it is a fallback, so it
- * holds every axis no target claims and never displaces one.
+ * ground's two axes, none along an axis where the probe lies so far out that
+ * lines a step apart are no longer two numbers. Its reach is unlimited and it
+ * is a fallback, so it holds every axis no target claims and never displaces one.
  */
 declare function groundGridSource(opts: GroundGridSourceOptions): SnapSource<Vec3>;
 

package/dist/index.js

@@ -1,6 +1,6 @@
-import { lookAt, multiply, perspective, add, scale, quatIdentity, compose, transformAabb, quatMultiply, quatConjugate, quatRotate, sub, invert, transformPoint, normalize, transformPoint4, distance, dot, len, aabbOfPoints, intersectRayPlane, pointOnRay, cross, intersectRayAabb } from '@weasel-js/geom/3d';
+import { lookAt, multiply, perspective, add, scale, quatIdentity, compose, transformAabb, quatMultiply, quatConjugate, quatRotate, sub, invert, transformPoint, normalize, cross, dot, transformPoint4, distance, len, aabbOfPoints, intersectRayPlane, pointOnRay, intersectRayAabb } from '@weasel-js/geom/3d';
 import { clamp, lengthTable, curveSpan, rectsOverlap } from '@weasel-js/geom';
-import { scenePoseFrame, createSnapOutcomeStore, assertSnapSourceIds, DEFAULT_SNAP_PX, resolveOverlays, snapSourcesFor, resolvedSnapMarks, SNAP_AXIS_STEP, gatherSnapCandidates, scenePoseAdapter, composeWorldPose } from '@weasel-js/core/engine';
+import { scenePoseFrame, createSnapOutcomeStore, assertSnapSourceIds, DEFAULT_SNAP_PX, resolveOverlays, snapSourcesFor, resolveHolding, resolvedSnapMarks, SNAP_AXIS_STEP, gatherSnapCandidates, scenePoseAdapter, composeWorldPose } from '@weasel-js/core/engine';
 import { isDev } from '@weasel-js/react';
 import { closestOnFlat, resolveSnap, createBvh, stepLine, createSettledCache } from '@weasel-js/geom/nd';
 import { overlaysOf, defineTool } from '@weasel-js/routing';
@@ -45,19 +45,23 @@ var DEFAULT_ORBIT_LIMITS = {
 };
 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 pitch = clamp(camera.pitch, clamp(l.minPitch, -MAX_PITCH, MAX_PITCH), clamp(l.maxPitch, -MAX_PITCH, MAX_PITCH));
   const distance2 = clamp(camera.distance, l.minDistance, l.maxDistance);
   if (pitch === camera.pitch && distance2 === camera.distance) return camera;
   return { ...camera, pitch, distance: distance2 };
 }
+function heldFinite(camera, moved) {
+  const { target: t, yaw, pitch, distance: distance2 } = moved;
+  return Number.isFinite(t.x + t.y + t.z + yaw + pitch + distance2) ? moved : camera;
+}
 function orbitBy(camera, deltaYaw, deltaPitch, limits) {
-  return clampCamera(
+  return heldFinite(camera, clampCamera(
     { ...camera, yaw: camera.yaw + deltaYaw, pitch: camera.pitch + deltaPitch },
     limits
-  );
+  ));
 }
 function dollyBy(camera, factor, limits) {
-  return clampCamera({ ...camera, distance: camera.distance * factor }, limits);
+  return heldFinite(camera, clampCamera({ ...camera, distance: camera.distance * factor }, limits));
 }
 function panBy(camera, dx, dy, paneHeight) {
   if (!(paneHeight > 0)) return camera;
@@ -70,7 +74,7 @@ function panBy(camera, dx, dy, paneHeight) {
     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) };
+  return heldFinite(camera, { ...camera, target: add(camera.target, shift) });
 }
 function dollyToward(camera, factor, at, pane, limits) {
   const dollied = dollyBy(camera, factor, limits);
@@ -81,14 +85,14 @@ function dollyToward(camera, factor, at, pane, limits) {
     -kept * (at.y - pane.height / 2),
     pane.height
   );
-  return { ...dollied, target: moved.target };
+  return heldFinite(camera, { ...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, scale6 = { x: 1, y: 1, z: 1 }, rotation = quatIdentity()) {
-  return { position, rotation, scale: scale6 };
+function pose3(position, scale7 = { x: 1, y: 1, z: 1 }, rotation = quatIdentity()) {
+  return { position, rotation, scale: scale7 };
 }
 function poseMatrix(pose) {
   return compose(pose.position, pose.rotation, pose.scale);
@@ -97,10 +101,14 @@ 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 overAxis = (a, s, zero) => {
+  const q = a / s;
+  return s === 0 || !Number.isFinite(q) ? zero : q;
+};
 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
+  x: overAxis(a.x, s.x, zero.x),
+  y: overAxis(a.y, s.y, zero.y),
+  z: overAxis(a.z, s.z, zero.z)
 });
 var ORIGIN = { x: 0, y: 0, z: 0 };
 var POSE3_COMPOSITION = {
@@ -129,7 +137,8 @@ function ndcToScreen(ndc, rect) {
   };
 }
 function rayThroughScreenPoint(point, rect, viewProjection) {
-  const inv = invert(viewProjection);
+  const eye = eyeOf(viewProjection) ?? ORIGIN2;
+  const inv = invert(multiply(viewProjection, compose(eye, quatIdentity(), UNIT)));
   if (!inv) return null;
   const ndc = screenToNdc(point, rect);
   const near = transformPoint(inv, { x: ndc.x, y: ndc.y, z: -1 });
@@ -137,7 +146,19 @@ function rayThroughScreenPoint(point, rect, viewProjection) {
   const direction = sub(far, near);
   const unit = normalize(direction);
   if (unit.x === 0 && unit.y === 0 && unit.z === 0) return null;
-  return { origin: near, direction };
+  return { origin: add(eye, near), direction };
+}
+var ORIGIN2 = { x: 0, y: 0, z: 0 };
+var UNIT = { x: 1, y: 1, z: 1 };
+function eyeOf(m) {
+  const row = (r) => ({ x: m[r], y: m[4 + r], z: m[8 + r] });
+  const [a, b, c] = [row(0), row(1), row(3)];
+  const bc = cross(b, c);
+  const ca = cross(c, a);
+  const ab = cross(a, b);
+  const det = dot(a, bc);
+  const eye = scale(add(add(scale(bc, m[12]), scale(ca, m[13])), scale(ab, m[15])), -1 / det);
+  return Number.isFinite(eye.x + eye.y + eye.z) ? eye : null;
 }
 var CLIP_SIDES = [
   (p) => p[2] + p[3],
@@ -153,6 +174,7 @@ function lerpClip(a, b, t) {
 }
 var EDGE_BITS = [1, 2, 4];
 function projectAabbToScreen(box, viewProjection, rect) {
+  if (!(rect.width > 0 && rect.height > 0)) return null;
   const corners = [];
   for (let i = 0; i < 8; i++) {
     const corner = {
@@ -186,7 +208,7 @@ function projectAabbToScreen(box, viewProjection, rect) {
       for (const side of CLIP_SIDES) {
         const da = side(a);
         const db = side(b);
-        if (da < 0 && db < 0) {
+        if (Number.isNaN(da) || Number.isNaN(db) || da < 0 && db < 0) {
           t0 = 1;
           t1 = 0;
           break;
@@ -200,7 +222,8 @@ function projectAabbToScreen(box, viewProjection, rect) {
     }
   }
   if (!any) return null;
-  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+  const out = { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+  return Number.isFinite(out.x + out.y + out.width + out.height) ? out : null;
 }
 function rectOf(viewport) {
   return {
@@ -217,8 +240,9 @@ function rayAt(viewport, point) {
   return rayThroughScreenPoint(point, rectOf(viewport), viewProjectionOf(viewport));
 }
 function projectPoint(p, viewport) {
+  if (!(viewport.width > 0 && viewport.height > 0)) return null;
   const [x, y, z, w] = transformPoint4(viewProjectionOf(viewport), p);
-  if (!(w > 0) || z < -w) return null;
+  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;
 }
@@ -257,8 +281,8 @@ function worldPoses(scene, reading) {
     return (id) => frame.world(id);
   }
   const adapter = scenePoseAdapter(untyped);
-  const compose2 = scene.composition.compose;
-  return (id) => composeWorldPose(adapter, id, compose2);
+  const compose3 = scene.composition.compose;
+  return (id) => composeWorldPose(adapter, id, compose3);
 }
 function boxAt(world, node, pose) {
   if (world.bounds) return world.bounds(pose === node.pose ? node : { ...node, pose });
@@ -532,16 +556,17 @@ function createSession3d(inputs) {
         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 })),
+        const at = probes.map((q) => ({ id: q.id, at: tuple(q.at), role: q.role }));
+        const res = resolveHolding(candidatesOf(inputs, sources, probes, delta0, vp, origin, up), (kept) => resolveSnap({
+          probes: at,
           input,
           delta0: tuple(delta0),
-          candidates: candidatesOf(inputs, sources, probes, delta0, vp, origin, up),
+          candidates: kept,
           toScreen: (w) => {
             const s = projectPoint(vec3Of(w), vp);
             return s ? [s.x, s.y] : [NaN, NaN];
           }
-        });
+        }), vec3Of);
         delta = vec3Of(res.delta);
         held = res.members.length > 0;
         store.set(resolvedSnapMarks(res.satisfied, delta));
@@ -724,8 +749,8 @@ function createPoseDescriptor(world, viewId) {
         const ky = src.height === 0 ? 1 : dst.height / src.height;
         const from = { x: box.x + box.width / 2, y: box.y + box.height / 2 };
         const to = {
-          x: dst.x + (from.x - src.x) * kx,
-          y: dst.y + (from.y - src.y) * ky
+          x: from.x + (dst.x - src.x) + (from.x - src.x) * (kx - 1),
+          y: from.y + (dst.y - src.y) + (from.y - src.y) * (ky - 1)
         };
         const plane = viewPlaneAt(vp.camera, pose.position);
         const before = onPlane(vp, plane, from);
@@ -829,7 +854,7 @@ function createInsert(opts) {
   const { u, v } = groundAxes(up);
   return {
     commit(bounds, extras, ends, select) {
-      const vp = opts.viewport();
+      const vp = opts.viewport(opts.viewId);
       const hits = footprintPoints(bounds, ends, (p) => groundHit(vp, p, up));
       if (hits.length === 0) return null;
       let minU = Infinity, maxU = -Infinity, minV = Infinity, maxV = -Infinity;
@@ -945,7 +970,7 @@ function aimSpace3d(viewport, viewId, opts = {}) {
     },
     unproject(px) {
       const hit = groundHit(viewport, { x: px.x + ox, y: px.y + oy }, up);
-      return hit && toAimPoint(hit, axes);
+      return hit && { ...toAimPoint(hit, axes), z: 0 };
     }
   };
 }
@@ -954,8 +979,8 @@ function cameraOfAim3d(aim) {
 }
 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] };
+var UNIT2 = { x: { x: 1, y: 0, z: 0 }, y: { x: 0, y: 1, z: 0 }, z: { x: 0, y: 0, z: 1 } };
+var ACROSS = { x: [UNIT2.y, UNIT2.z], y: [UNIT2.x, UNIT2.z], z: [UNIT2.x, UNIT2.y] };
 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])));
 }
@@ -1072,7 +1097,9 @@ 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;
+    const k = Math.round(c / opts.step);
+    if (!Number.isSafeInteger(k)) return [];
+    const near = k * opts.step;
     return [near, near + (c >= near ? opts.step : -opts.step)];
   };
   return {
@@ -1139,9 +1166,10 @@ var HEAD = { lenRatio: 8, maxShare: 0.5, aspect: 7 / 16 };
 var HEAD_OVERDRAW = 0.1;
 function headFor(shaftHalf, linePx = Number.POSITIVE_INFINITY, head = HEAD) {
   const wanted = shaftHalf * head.lenRatio;
-  const headLen = Math.max(0, Math.min(wanted, head.maxShare * linePx));
+  const cap = head.maxShare === 0 ? 0 : head.maxShare * linePx;
+  const headLen = Math.max(0, Math.min(wanted, cap));
   const headHalf = headLen * head.aspect;
-  const shrunk = wanted > 0 ? shaftHalf * headLen / wanted : shaftHalf;
+  const shrunk = wanted > 0 ? shaftHalf * (headLen / wanted) : shaftHalf;
   return { headLen, headHalf, shaftHalf: wanted > 0 ? Math.min(shrunk, headHalf) : shrunk };
 }
 function layoutLine(shaftHalf, length, pxPerUnit, head) {
@@ -1319,7 +1347,7 @@ void main() {
   if (wanted > 0.0 && density > 0.0) {
     headPx = max(0.0, min(wanted, a_shape.z * density * total));
     headHalf = headPx * a_shape.w;
-    shaft = min(shaftHalf * headPx / wanted, headHalf);
+    shaft = min(shaftHalf * (headPx / wanted), headHalf);
     shaftEnd = total - headPx / density * (1.0 - OVERDRAW);
   }
 
@@ -1479,10 +1507,11 @@ function cameraStepper(dep, zero, relative, step) {
   let reached = zero;
   let written = origin;
   let prior = origin;
+  let caughtUp = false;
   return (at) => {
     if (!dep || !origin) return;
     const now = dep.get();
-    if (now !== written && now !== prior) {
+    if (now !== written && (caughtUp || now !== prior)) {
       origin = now;
       from = reached;
     }
@@ -1490,6 +1519,7 @@ function cameraStepper(dep, zero, relative, step) {
     written = step(origin, relative(at, from), dep);
     reached = at;
     dep.set(written);
+    caughtUp = dep.get() === written;
   };
 }
 function dragCamera(ctx, kind, step) {