@viamrobotics/motion-tools 1.30.0 → 1.32.0

package/dist/ecs/traits.js

@@ -6,6 +6,7 @@ import { ColorFormat } from '../buf/draw/v1/metadata_pb';
 import { createBox, createCapsule, createSphere } from '../geometry';
 import { parsePcdInWorker } from '../loaders/pcd';
 import { parsePlyInput } from '../ply';
+import { createPose, matrixToPose, poseToMatrix } from '../transform';
 export const Name = trait(() => '');
 export const UUID = trait(() => '');
 /**
@@ -61,6 +62,13 @@ export const InstancedMatrix = trait(() => ({
 }));
 export const Hovered = trait(() => true);
 export const Invisible = trait(() => true);
+/**
+ * Suppresses the default frame-style world/local pose and parent-frame blocks
+ * in the details panel. Entities that render their own pose UI via the
+ * `details-extensions` portal target (e.g. gizmo plugin entities) opt in by
+ * adding this trait.
+ */
+export const CustomDetails = trait(() => true);
 /**
  * True when the entity itself, or any of its parents up the `ChildOf`
  * chain, has `Invisible`. Maintained by `provideInheritedInvisible`;
@@ -72,11 +80,14 @@ export const InheritedInvisible = trait(() => true);
  * Represents that an entity is composed of many instances, so that the treeview and
  * details panel may display all instances
  */
-export const Instanced = trait(() => true);
+export const InstanceId = trait(() => -1);
 export const Instance = trait({
     meshID: -1,
     instanceID: -1,
 });
+export const Instances = trait({
+    count: 0,
+});
 export const RenderOrder = trait(() => 0);
 export const Opacity = trait(() => 1);
 /**
@@ -100,9 +111,6 @@ export const Colors = trait(() => new Uint8Array());
  * Per-vertex opacity values packed as uint8 (0-255).
  */
 export const Opacities = trait(() => new Uint8Array());
-export const Instances = trait({
-    count: 0,
-});
 export const Arrows = trait({
     headAtPose: true,
 });
@@ -175,6 +183,10 @@ export const ReferenceFrame = trait(() => true);
  */
 export const ChunkProgress = trait({ loaded: 0, total: 0 });
 export const SelectToolInteractionLayer = trait(() => true);
+/**
+ * This entity is selected by the user
+ */
+export const Selected = trait();
 /**
  * This entity can be safely removed from the scene by the user
  */
@@ -250,6 +262,23 @@ export const updateGeometryTrait = (entity, geometry) => {
         updatePointCloud(entity, geometry.geometryType.value.pointCloud);
     }
 };
+/**
+ * Patches an entity's `Matrix` trait in-place via the `Pose` round-trip
+ * (`matrixToPose` → merge → `poseToMatrix`), then signals `entity.changed(Matrix)`.
+ * No-ops silently if the entity has no `Matrix` trait.
+ */
+export const writeMatrix = (entity, patch) => {
+    const matrix = entity.get(Matrix);
+    if (!matrix)
+        return;
+    const pose = matrixToPose(matrix, createPose());
+    const filtered = Object.fromEntries(Object.entries(patch).filter(([, v]) => v !== undefined));
+    if (Object.keys(filtered).length === 0)
+        return;
+    Object.assign(pose, filtered);
+    poseToMatrix(pose, matrix);
+    entity.changed(Matrix);
+};
 const updatePointCloud = (entity, pointCloud) => {
     parsePcdInWorker(new Uint8Array(pointCloud))
         .then((parsed) => {

package/dist/ecs/useTag.svelte.d.ts

@@ -0,0 +1,5 @@
+import { type Entity, type TagTrait, type World } from 'koota';
+export declare function isWorld(target: Entity | World): target is World;
+export declare function useTag(target: () => Entity | World | undefined | null, tag: TagTrait): {
+    readonly current: boolean;
+};

package/dist/ecs/useTag.svelte.js

@@ -0,0 +1,43 @@
+import { $internal as internal } from 'koota';
+import { useWorld } from './useWorld';
+export function isWorld(target) {
+    return typeof target?.spawn === 'function';
+}
+export function useTag(target, tag) {
+    const contextWorld = useWorld();
+    let value = $state(false);
+    $effect(() => {
+        const t = target();
+        if (!t) {
+            value = false;
+            return;
+        }
+        const world = isWorld(t) ? t : contextWorld;
+        // ???
+        // eslint-disable-next-line prefer-const
+        let entity;
+        /**
+         * Subscribe before reading worldEntity: world.onAdd triggers lazy
+         * registration so worldEntity is guaranteed to exist after this.
+         */
+        const onAddUnsub = world.onAdd(tag, (e) => {
+            if (e === entity)
+                value = true;
+        });
+        const onRemoveUnsub = world.onRemove(tag, (e) => {
+            if (e === entity)
+                value = false;
+        });
+        entity = isWorld(t) ? t[internal].worldEntity : t;
+        value = entity.has(tag);
+        return () => {
+            onAddUnsub();
+            onRemoveUnsub();
+        };
+    });
+    return {
+        get current() {
+            return value;
+        },
+    };
+}

package/dist/hooks/useConfigFrames.svelte.js

@@ -25,7 +25,7 @@ export const provideConfigFrames = () => {
     });
     const [fragmentFrames, fragmentUnsetFrameNames] = $derived.by(() => {
         const { fragment_mods: fragmentMods = [] } = partConfig.current;
-        const fragmentDefinedComponents = Object.keys(partConfig.componentNameToFragmentInfo);
+        const fragmentDefinedComponents = Object.keys(partConfig.componentNameToFragmentInfo ?? {});
         const results = {};
         const unsetResults = [];
         // deal with fragment defined components

package/dist/hooks/useEnvironment.svelte.d.ts

@@ -1,6 +1,6 @@
 export declare const ENVIRONMENT_CONTEXT_KEY: unique symbol;
 interface Environemnt {
-    viewerMode: 'edit' | 'monitor' | 'focus';
+    viewerMode: 'edit' | 'monitor';
     isStandalone: boolean;
     inputBindingsEnabled: boolean;
 }

package/dist/hooks/useLinked.svelte.js

@@ -1,20 +1,19 @@
 import { getContext, setContext } from 'svelte';
-import { relations, useWorld } from '../ecs';
-import { useFocusedEntity, useSelectedEntity } from './useSelection.svelte';
+import { relations, traits, useQuery, useWorld } from '../ecs';
 const linkedKey = Symbol('linked-context');
 export const provideLinkedEntities = () => {
     const world = useWorld();
-    const selectedEntity = useSelectedEntity();
-    const focusedEntity = useFocusedEntity();
-    const displayEntity = $derived(selectedEntity.current ?? focusedEntity.current);
-    let linkedEntities = $derived(displayEntity?.targetsFor(relations.SubEntityLink) ?? []);
+    const selected = useQuery(traits.Selected);
+    let linkedEntities = $derived(selected.current
+        .flatMap((entity) => entity.targetFor(relations.SubEntityLink))
+        .filter((entity) => entity !== undefined));
     const unsubAdd = world.onAdd(relations.SubEntityLink, (entity, target) => {
-        if (entity === displayEntity) {
+        if (selected.current.includes(entity)) {
             linkedEntities = [...linkedEntities, target];
         }
     });
     const unsubRemove = world.onRemove(relations.SubEntityLink, (entity, target) => {
-        if (entity === displayEntity) {
+        if (selected.current.includes(entity)) {
             linkedEntities = linkedEntities.filter((e) => e !== target);
         }
     });

package/dist/hooks/useMouseRaycaster.svelte.d.ts

@@ -5,9 +5,10 @@ interface RaycastEvent<T extends EventNames> {
     intersections: Intersection[];
 }
 type Callback<T extends EventNames> = (event: RaycastEvent<T>) => void;
-export declare const useMouseRaycaster: (getOptions?: () => {
-    enabled: boolean;
-}) => {
+interface MouseRaycasterOptions {
+    enabled?: boolean;
+}
+export declare const useMouseRaycaster: (getOptions?: () => MouseRaycasterOptions) => {
     raycaster: Raycaster;
     onclick: (cb: Callback<"click">) => void;
     onmove: (cb: Callback<"move">) => void;

package/dist/hooks/useMouseRaycaster.svelte.js

@@ -69,6 +69,7 @@ export const useMouseRaycaster = (getOptions) => {
         if (!options.enabled) {
             return;
         }
+        raycaster.firstHitOnly = true;
         dom.addEventListener('pointermove', onPointerMove, { passive: true });
         dom.addEventListener('pointerdown', onPointerDown, { passive: true });
         dom.addEventListener('pointerup', onPointerUp, { passive: true });

package/dist/hooks/useSettings.svelte.d.ts

@@ -1,7 +1,7 @@
 import type { ColorRepresentation } from 'three';
 export interface Settings {
     cameraMode: 'orthographic' | 'perspective';
-    interactionMode: 'navigate' | 'measure' | 'select';
+    interactionMode: 'navigate' | 'measure' | 'select' | 'gizmo';
     refreshRates: {
         poses: number;
         pointclouds: number;

package/dist/lib.d.ts

@@ -7,3 +7,4 @@ export { OrientationVector } from './three/OrientationVector';
 export { parsePcdInWorker } from './loaders/pcd';
 export { createBinaryPCD } from './pcd';
 export { metadataFromStruct } from './metadata';
+export { decodeDrawnSnapshotPointClouds } from './snapshot';

package/dist/lib.js

@@ -13,3 +13,4 @@ export { OrientationVector } from './three/OrientationVector';
 export { parsePcdInWorker } from './loaders/pcd';
 export { createBinaryPCD } from './pcd';
 export { metadataFromStruct } from './metadata';
+export { decodeDrawnSnapshotPointClouds } from './snapshot';