@viamrobotics/motion-tools 1.32.0 → 1.33.1

package/dist/components/Entities/labelLayout/solve.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Deterministic slot assignment via priority-ordered conflict-graph local search.
+ *
+ * Warm-started from each node's previously committed slot (set by the engine
+ * before this runs), it repeatedly moves the worst-conflict node to its lowest
+ * cost slot, re-scoring only the affected neighbourhood, until no node has a
+ * conflict or the move budget is spent. A best-total snapshot is restored at the
+ * end so a re-solve can never regress below where it started.
+ */
+import type { LabelNode, SolverConfig } from './types';
+export declare const solve: (nodes: LabelNode[], config: SolverConfig, bestSnap: Int16Array) => void;

package/dist/components/Entities/labelLayout/solve.js

@@ -0,0 +1,93 @@
+import { evalConflict, placementBias, W } from './cost';
+/** Conflicts below this are treated as resolved (floating-point slack). */
+const RESOLVED = 0.5;
+/**
+ * The slot that minimizes conflict (crossings/overlaps), breaking ties by the
+ * tidiness bias. Selection and the caller's acceptance gate share the conflict
+ * objective, so a node is never locked at a placement another slot would
+ * improve. The baseCost early-out applies only once conflict is already
+ * resolved — while a node still conflicts, every slot is considered.
+ */
+const bestSlot = (node, config) => {
+    const neighbors = node.neighbors;
+    let index = node.slotIndex;
+    let conflict = evalConflict(node, node.slotIndex, neighbors, config);
+    let bias = placementBias(node, node.slotIndex);
+    for (let s = 0; s < node.slots.length; s++) {
+        if (s === node.slotIndex)
+            continue;
+        // Slots are sorted ascending by baseCost; once conflict is resolved only
+        // tidiness remains, so no farther slot can beat the incumbent's bias.
+        if (conflict <= RESOLVED && node.slots[s].baseCost - W.stick >= bias)
+            break;
+        const c = evalConflict(node, s, neighbors, config);
+        const b = placementBias(node, s);
+        if (c < conflict - 1e-6 || (c <= conflict + 1e-6 && b < bias)) {
+            index = s;
+            conflict = c;
+            bias = b;
+        }
+    }
+    return { index, conflict };
+};
+export const solve = (nodes, config, bestSnap) => {
+    const n = nodes.length;
+    if (n === 0)
+        return;
+    for (const node of nodes)
+        node.prevSlotIndex = node.slotIndex;
+    const order = nodes.toSorted((a, b) => b.w * b.h - a.w * a.h || a.slots.length - b.slots.length || a.idHash - b.idHash);
+    let total = 0;
+    for (let i = 0; i < n; i++) {
+        const node = nodes[i];
+        node.conflict = evalConflict(node, node.slotIndex, node.neighbors, config);
+        node.locked = false;
+        total += node.conflict;
+    }
+    let bestE = total;
+    for (let i = 0; i < n; i++)
+        bestSnap[i] = nodes[i].slotIndex;
+    let budget = config.polishBudget;
+    while (budget > 0) {
+        let worst;
+        let worstConflict = RESOLVED;
+        for (let i = 0; i < n; i++) {
+            const node = order[i];
+            if (!node.locked && node.conflict > worstConflict) {
+                worstConflict = node.conflict;
+                worst = node;
+            }
+        }
+        if (!worst)
+            break;
+        const result = bestSlot(worst, config);
+        if (result.index !== worst.slotIndex && result.conflict < worst.conflict - RESOLVED) {
+            total += result.conflict - worst.conflict;
+            worst.slotIndex = result.index;
+            worst.conflict = result.conflict;
+            budget--;
+            // Moving `worst` changes the pairwise cost of its neighbors only.
+            for (const m of worst.neighbors) {
+                const before = m.conflict;
+                m.conflict = evalConflict(m, m.slotIndex, m.neighbors, config);
+                total += m.conflict - before;
+                m.locked = false;
+            }
+            if (total < bestE) {
+                bestE = total;
+                for (let i = 0; i < n; i++)
+                    bestSnap[i] = nodes[i].slotIndex;
+            }
+        }
+        else {
+            worst.locked = true;
+        }
+    }
+    for (let i = 0; i < n; i++) {
+        const node = nodes[i];
+        node.slotIndex = bestSnap[i];
+        const slot = node.slots[node.slotIndex];
+        node.tx = node.ax + slot.dx;
+        node.ty = node.ay + slot.dy;
+    }
+};

package/dist/components/Entities/labelLayout/spatialHash.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Uniform grid over label anchors, used to prune the O(n^2) cost evaluation to a
+ * bounded neighborhood. The cell size is chosen so any two labels whose boxes
+ * could possibly interact share or border a cell, so scanning the 3x3 block
+ * around a node finds every candidate.
+ */
+import type { LabelNode } from './types';
+export declare class SpatialHash {
+    private cell;
+    private readonly buckets;
+    private static key;
+    build(nodes: LabelNode[], cell: number): void;
+    /** Nearest `max` nodes (by anchor distance) in the 3x3 cell block around `node`, excluding itself. */
+    queryNeighbors(node: LabelNode, max: number): LabelNode[];
+}

package/dist/components/Entities/labelLayout/spatialHash.js

@@ -0,0 +1,53 @@
+/**
+ * Uniform grid over label anchors, used to prune the O(n^2) cost evaluation to a
+ * bounded neighborhood. The cell size is chosen so any two labels whose boxes
+ * could possibly interact share or border a cell, so scanning the 3x3 block
+ * around a node finds every candidate.
+ */
+const KEY_OFFSET = 2048;
+const KEY_STRIDE = 4096;
+export class SpatialHash {
+    cell = 1;
+    buckets = new Map();
+    static key(gx, gy) {
+        return (gx + KEY_OFFSET) * KEY_STRIDE + (gy + KEY_OFFSET);
+    }
+    build(nodes, cell) {
+        this.cell = Math.max(cell, 1);
+        this.buckets.clear();
+        for (const node of nodes) {
+            const k = SpatialHash.key(Math.floor(node.ax / this.cell), Math.floor(node.ay / this.cell));
+            const bucket = this.buckets.get(k);
+            if (bucket)
+                bucket.push(node);
+            else
+                this.buckets.set(k, [node]);
+        }
+    }
+    /** Nearest `max` nodes (by anchor distance) in the 3x3 cell block around `node`, excluding itself. */
+    queryNeighbors(node, max) {
+        const gx = Math.floor(node.ax / this.cell);
+        const gy = Math.floor(node.ay / this.cell);
+        const found = [];
+        for (let ox = -1; ox <= 1; ox++) {
+            for (let oy = -1; oy <= 1; oy++) {
+                const bucket = this.buckets.get(SpatialHash.key(gx + ox, gy + oy));
+                if (!bucket)
+                    continue;
+                for (const other of bucket) {
+                    if (other !== node)
+                        found.push(other);
+                }
+            }
+        }
+        if (found.length <= max)
+            return found;
+        found.sort((a, b) => {
+            const da = (a.ax - node.ax) ** 2 + (a.ay - node.ay) ** 2;
+            const db = (b.ax - node.ax) ** 2 + (b.ay - node.ay) ** 2;
+            return da - db;
+        });
+        found.length = max;
+        return found;
+    }
+}

package/dist/components/Entities/labelLayout/types.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Shared types for the label layout engine.
+ *
+ * All spatial fields are in viewport pixels (one shared screen-space for every
+ * label) except where noted. Slots store dot-relative offsets so a camera pan
+ * never invalidates them.
+ */
+/** Axis-aligned rectangle as center + half-extents (viewport px). */
+export interface Rect {
+    cx: number;
+    cy: number;
+    hw: number;
+    hh: number;
+}
+/** Line segment (viewport px). */
+export interface Segment {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+}
+/** A candidate placement for a label box, expressed as the box-center offset from the dot. */
+export interface Slot {
+    /** Box-center offset from the dot, viewport px. */
+    dx: number;
+    dy: number;
+    /** Direction of the slot from the dot, radians. */
+    angle: number;
+    /** Distance from the dot to the box center, viewport px. */
+    radius: number;
+    /** Ring index (0 = innermost). */
+    ring: number;
+    /** Length-only cost (`W.len * radius`); slots are sorted ascending by this for early-out. */
+    baseCost: number;
+}
+export interface LabelNode {
+    /** Stable per-element id, assigned once. */
+    id: string;
+    /** FNV hash of `id`, used for deterministic tie-breaks and per-node slot phase. */
+    idHash: number;
+    ax: number;
+    ay: number;
+    dotR: number;
+    w: number;
+    h: number;
+    /** Per-island CSS scale (screenPx / localPx). */
+    scale: number;
+    /** Cached computed CSS width of the dot (local px); read once. */
+    cssDotW: number;
+    /** Dot center relative to the island origin, island-local px. Fixed CSS offset, measured once (NaN until then). */
+    dotLocalX: number;
+    dotLocalY: number;
+    slots: Slot[];
+    /** Hash of the box/dot geometry; slots regenerate only when this or `crowded` changes. */
+    geomKey: string;
+    crowded: boolean;
+    /** Committed slot (target). -1 before first placement. */
+    slotIndex: number;
+    /** Slot committed by the previous solve, for stickiness. */
+    prevSlotIndex: number;
+    cx: number;
+    cy: number;
+    tx: number;
+    ty: number;
+    settled: boolean;
+    /** Conflict cost of the current slot — the local-search loop key. */
+    conflict: number;
+    /** Locked at a local optimum for the current solve. */
+    locked: boolean;
+    /** Local cluster centroid (self + neighbors) for the outward-fan term. */
+    centroidX: number;
+    centroidY: number;
+    /** Anchor at the previous solve, for teleport detection. NaN before first solve. */
+    prevAx: number;
+    prevAy: number;
+    /** Pruned interaction set for the current solve (symmetric). */
+    neighbors: LabelNode[];
+    labelEl: HTMLElement;
+    textEl: HTMLElement;
+    dotEl: HTMLElement;
+    lineEl: SVGLineElement;
+}
+export interface SolverConfig {
+    /** Label-label clearance (viewport px). */
+    labelPadding: number;
+    /** Dot clearance (viewport px). */
+    dotPadding: number;
+    /** Candidate angles per ring (doubled for crowded nodes). */
+    anglesPerRing: number;
+    /** Ring radius multipliers for sparse nodes. */
+    ringRadii: number[];
+    /** Ring radius multipliers for crowded nodes (more escape room). */
+    ringRadiiCrowded: number[];
+    /** Max accepted local-search moves per solve. */
+    polishBudget: number;
+    /** Max neighbors considered per node (caps cost in dense clusters). */
+    maxNeighbors: number;
+    /** Distance (viewport px) under which a box is considered arrived. */
+    settleEps: number;
+    /** Neighbor count above which a node is "crowded". */
+    crowdedThreshold: number;
+    /** Fraction of the viewport diagonal that counts as a camera teleport. */
+    teleportFrac: number;
+}
+export declare const defaultSolverConfig: SolverConfig;

package/dist/components/Entities/labelLayout/types.js

@@ -0,0 +1,19 @@
+/**
+ * Shared types for the label layout engine.
+ *
+ * All spatial fields are in viewport pixels (one shared screen-space for every
+ * label) except where noted. Slots store dot-relative offsets so a camera pan
+ * never invalidates them.
+ */
+export const defaultSolverConfig = {
+    labelPadding: 6,
+    dotPadding: 6,
+    anglesPerRing: 12,
+    ringRadii: [1, 1.55, 2.2],
+    ringRadiiCrowded: [1, 1.45, 1.95, 2.6],
+    polishBudget: 240,
+    maxNeighbors: 24,
+    settleEps: 0.4,
+    crowdedThreshold: 8,
+    teleportFrac: 0.5,
+};

package/dist/components/Entities/labelLayout/writeBack.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Per-frame animation and DOM write-back. The solver produces a target box
+ * center; the animated center eases toward it (framerate-independent), and the
+ * eased position is written to the label as a scale-corrected local transform
+ * plus leader-line endpoints — the same coordinate handling the old engine used.
+ */
+import type { LabelNode } from './types';
+/**
+ * Ease `node`'s animated center toward its target. Returns true while still
+ * moving, false once arrived (and snapped). `delta` is seconds, pre-clamped by
+ * the engine so a long idle gap can't produce an overshoot.
+ */
+export declare function lerpStep(node: LabelNode, delta: number, settleEps: number): boolean;
+/**
+ * Write the eased position to the DOM. The label island is positioned at the dot
+ * by Threlte's <HTML>, so we work in island-local px: convert the viewport-space
+ * offset by the island's CSS scale, place the text box, and draw the leader from
+ * the dot's island-local position to the box center.
+ */
+export declare const writeBack: (node: LabelNode) => void;

package/dist/components/Entities/labelLayout/writeBack.js

@@ -0,0 +1,51 @@
+/**
+ * Per-frame animation and DOM write-back. The solver produces a target box
+ * center; the animated center eases toward it (framerate-independent), and the
+ * eased position is written to the label as a scale-corrected local transform
+ * plus leader-line endpoints — the same coordinate handling the old engine used.
+ */
+/** Easing time constant (seconds): ~3-4 frames to arrive at 60fps. */
+const TAU = 0.08;
+/**
+ * Ease `node`'s animated center toward its target. Returns true while still
+ * moving, false once arrived (and snapped). `delta` is seconds, pre-clamped by
+ * the engine so a long idle gap can't produce an overshoot.
+ */
+export function lerpStep(node, delta, settleEps) {
+    const dx = node.tx - node.cx;
+    const dy = node.ty - node.cy;
+    if (dx * dx + dy * dy <= settleEps * settleEps) {
+        node.cx = node.tx;
+        node.cy = node.ty;
+        node.settled = true;
+        return false;
+    }
+    const alpha = 1 - Math.exp(-delta / TAU);
+    node.cx += dx * alpha;
+    node.cy += dy * alpha;
+    node.settled = false;
+    return true;
+}
+/**
+ * Write the eased position to the DOM. The label island is positioned at the dot
+ * by Threlte's <HTML>, so we work in island-local px: convert the viewport-space
+ * offset by the island's CSS scale, place the text box, and draw the leader from
+ * the dot's island-local position to the box center.
+ */
+export const writeBack = (node) => {
+    const inv = 1 / node.scale;
+    // Box-center offset from the dot, in island-local px.
+    const dx = (node.cx - node.ax) * inv;
+    const dy = (node.cy - node.ay) * inv;
+    const wL = node.w * inv;
+    const hL = node.h * inv;
+    // The dot may not sit at the island origin, so anchor everything at the dot's
+    // measured local position rather than assuming (0, 0).
+    const ox = node.dotLocalX;
+    const oy = node.dotLocalY;
+    node.textEl.style.transform = `translate(${ox + dx - wL / 2}px, ${oy + dy - hL / 2}px)`;
+    node.lineEl.setAttribute('x1', `${ox}`);
+    node.lineEl.setAttribute('y1', `${oy}`);
+    node.lineEl.setAttribute('x2', `${ox + dx}`);
+    node.lineEl.setAttribute('y2', `${oy + dy}`);
+};

package/dist/components/Scene.svelte

@@ -19,7 +19,6 @@
 	import CameraControls from './CameraControls.svelte'
 	import KeyboardBindings from './KeyboardBindings.svelte'
 	import PointerMissBox from './PointerMissBox.svelte'
-	import { useOrigin } from './xr/useOrigin.svelte'
 
 	interface Props {
 		children?: Snippet
@@ -29,7 +28,6 @@
 
 	const threlte = useThrelte()
 	const settings = useSettings()
-	const origin = useOrigin()
 
 	// @ts-expect-error This is for debugging
 	globalThis.__threlte__ = threlte
@@ -51,7 +49,8 @@
 	const bvhEnabled = $derived(
 		settings.current.renderSubEntityHoverDetail ||
 			settings.current.interactionMode === 'measure' ||
-			settings.current.interactionMode === 'select'
+			settings.current.interactionMode === 'select' ||
+			settings.current.interactionMode === 'gizmo'
 	)
 
 	bvh(raycaster, () => ({ helper: false, enabled: bvhEnabled }))
@@ -66,48 +65,43 @@
 <KeyboardBindings />
 <Environment url={hdrImage} />
 
-<T.Group
-	position={origin.position}
-	rotation.z={origin.rotation}
->
-	<PointerMissBox />
-	<SelectedTransformControls />
-
-	{#if !$isPresenting && settings.current.grid}
-		<Grid
-			oncreate={(ref) => {
-				const material = ref.material as ShaderMaterial
-				material.depthWrite = false
-			}}
-			raycast={() => null}
-			bvh={{ enabled: false }}
-			plane="xy"
-			sectionColor="#333"
-			infiniteGrid
-			renderOrder={999}
-			cellSize={settings.current.gridCellSize}
-			sectionSize={settings.current.gridSectionSize}
-			fadeOrigin={[0, 0, 0]}
-			fadeDistance={settings.current.gridFadeDistance}
-		/>
-	{/if}
-
-	{#if !$isPresenting}
-		<Camera position={[3, 3, 3]}>
-			<CameraControls />
-		</Camera>
-	{/if}
-
-	<StaticGeometries />
-	<Selected />
-
-	<PortalTarget />
-
-	<Entities />
-	<BatchedArrows />
-
-	{@render children?.()}
-
-	<T.DirectionalLight position={[3, 3, 3]} />
-	<T.AmbientLight />
-</T.Group>
+<PointerMissBox />
+<SelectedTransformControls />
+
+{#if !$isPresenting && settings.current.grid}
+	<Grid
+		oncreate={(ref) => {
+			const material = ref.material as ShaderMaterial
+			material.depthWrite = false
+		}}
+		raycast={() => null}
+		bvh={{ enabled: false }}
+		plane="xy"
+		sectionColor="#333"
+		infiniteGrid
+		renderOrder={999}
+		cellSize={settings.current.gridCellSize}
+		sectionSize={settings.current.gridSectionSize}
+		fadeOrigin={[0, 0, 0]}
+		fadeDistance={settings.current.gridFadeDistance}
+	/>
+{/if}
+
+{#if !$isPresenting}
+	<Camera position={[3, 3, 3]}>
+		<CameraControls />
+	</Camera>
+{/if}
+
+<StaticGeometries />
+<Selected />
+
+<PortalTarget />
+
+<Entities />
+<BatchedArrows />
+
+{@render children?.()}
+
+<T.DirectionalLight position={[3, 3, 3]} />
+<T.AmbientLight />

package/dist/components/SceneProviders.svelte

@@ -21,8 +21,6 @@
 	import { provideResourceByName } from '../hooks/useResourceByName.svelte'
 	import { provideWorldStates } from '../hooks/useWorldState.svelte'
 
-	import { provideOrigin } from './xr/useOrigin.svelte'
-
 	interface Props {
 		children: Snippet
 	}
@@ -37,7 +35,6 @@
 	provideHierarchy()
 	provideWorldMatrix()
 	provideInheritedInvisible()
-	provideOrigin()
 
 	provideRelationships()