@viamrobotics/motion-tools 1.10.0 → 1.11.0

package/dist/hooks/useArmKinematics.svelte.js

@@ -0,0 +1,31 @@
+import { ArmClient } from '@viamrobotics/sdk';
+import { createResourceClient, createResourceQuery, useResourceNames, } from '@viamrobotics/svelte-sdk';
+import { getContext, setContext } from 'svelte';
+const key = Symbol('arm-kinematics-context');
+export const provideArmKinematics = (partID) => {
+    const arms = useResourceNames(partID, 'arm');
+    // Kinematics are static config data, so fetch once and cache indefinitely
+    const options = { staleTime: Infinity, refetchOnMount: false, refetchInterval: false };
+    const names = $derived(arms.current.map((arm) => arm.name));
+    const clients = $derived(arms.current.map((arm) => createResourceClient(ArmClient, partID, () => arm.name)));
+    const kinematicsQueries = $derived(clients.map((client) => [client.current?.name, createResourceQuery(client, 'getKinematics', () => options)]));
+    const kinematics = $derived(Object.fromEntries(kinematicsQueries.map(([name, query]) => [
+        name,
+        query.data?.joints.map((j) => ({
+            id: j.id,
+            min: j.min,
+            max: j.max,
+        })),
+    ])));
+    setContext(key, {
+        get names() {
+            return names;
+        },
+        get kinematics() {
+            return kinematics;
+        },
+    });
+};
+export const useArmKinematics = () => {
+    return getContext(key);
+};

package/dist/hooks/useGeometries.svelte.js

@@ -1,5 +1,5 @@
 import { ArmClient, CameraClient, GantryClient, GripperClient } from '@viamrobotics/sdk';
-import { setContext, getContext } from 'svelte';
+import { untrack, setContext, getContext } from 'svelte';
 import { RefreshRates, useMachineSettings } from './useMachineSettings.svelte';
 import { createResourceClient, createResourceQuery, useResourceNames, } from '@viamrobotics/svelte-sdk';
 import { useLogs } from './useLogs.svelte';
@@ -27,8 +27,8 @@ export const provideGeometries = (partID) => {
     const gripperClients = $derived(grippers.current.map((gripper) => createResourceClient(GripperClient, partID, () => gripper.name)));
     const cameraClients = $derived(cameras.current.map((camera) => createResourceClient(CameraClient, partID, () => camera.name)));
     const gantryClients = $derived(gantries.current.map((gantry) => createResourceClient(GantryClient, partID, () => gantry.name)));
+    const interval = $derived(refreshRates.get(RefreshRates.poses));
     const options = $derived.by(() => {
-        const interval = refreshRates.get(RefreshRates.poses);
         return {
             enabled: refreshRates.get(RefreshRates.poses) !== RefetchRates.OFF &&
                 environment.current.viewerMode === 'monitor',
@@ -40,13 +40,20 @@ export const provideGeometries = (partID) => {
     const cameraQueries = $derived(cameraClients.map((client) => [client.current?.name, createResourceQuery(client, 'getGeometries', () => options)]));
     const gantryQueries = $derived(gantryClients.map((client) => [client.current?.name, createResourceQuery(client, 'getGeometries', () => options)]));
     $effect(() => {
+        if (interval === RefetchRates.FPS_30 || interval === RefetchRates.FPS_60) {
+            return logs.add(`Fetching geometries every ${interval}ms...`);
+        }
         for (const [name, query] of queries) {
-            if (query.isFetching) {
-                logs.add(`Fetching geometries for ${name}...`);
-            }
-            else if (query.error) {
-                logs.add(`Error fetching geometries from ${name}: ${query.error.message}`, 'error');
-            }
+            untrack(() => {
+                $effect(() => {
+                    if (query.isFetching) {
+                        logs.add(`Fetching geometries for ${name}...`);
+                    }
+                    else if (query.error) {
+                        logs.add(`Error fetching geometries from ${name}: ${query.error.message}`, 'error');
+                    }
+                });
+            });
         }
     });
     const queries = $derived([...armQueries, ...gripperQueries, ...cameraQueries, ...gantryQueries]);
@@ -54,34 +61,38 @@ export const provideGeometries = (partID) => {
     $effect(() => {
         const active = {};
         for (const [name, query] of queries) {
-            if (name && query.data) {
-                let index = 0;
-                for (const geometry of query.data) {
-                    index += 1;
-                    const resourceName = resources.current[name];
-                    const label = geometry.label ? geometry.label : `${name} geometry ${index}`;
-                    active[`${name}:${label}`] = true;
-                    const pose = createPose(geometry.center);
-                    const subtype = resourceName?.subtype;
-                    const existing = entities.get(`${name}:${label}`);
-                    if (existing) {
-                        existing.set(traits.Pose, pose);
-                        continue;
-                    }
-                    const entityTraits = [
-                        traits.Parent(name),
-                        traits.Name(label),
-                        traits.Pose(pose),
-                        traits.GeometriesAPI,
-                        traits.Geometry(geometry),
-                    ];
-                    if (subtype) {
-                        entityTraits.push(traits.Color(subtype ? colorUtil.set(resourceColors[subtype]) : undefined));
+            untrack(() => {
+                $effect(() => {
+                    if (name && query.data) {
+                        let index = 0;
+                        for (const geometry of query.data) {
+                            index += 1;
+                            const resourceName = resources.current[name];
+                            const label = geometry.label ? geometry.label : `${name} geometry ${index}`;
+                            active[`${name}:${label}`] = true;
+                            const pose = createPose(geometry.center);
+                            const subtype = resourceName?.subtype;
+                            const existing = entities.get(`${name}:${label}`);
+                            if (existing) {
+                                existing.set(traits.Pose, pose);
+                                continue;
+                            }
+                            const entityTraits = [
+                                traits.Parent(name),
+                                traits.Name(label),
+                                traits.Pose(pose),
+                                traits.GeometriesAPI,
+                                traits.Geometry(geometry),
+                            ];
+                            if (subtype) {
+                                entityTraits.push(traits.Color(subtype ? colorUtil.set(resourceColors[subtype]) : undefined));
+                            }
+                            const entity = world.spawn(...entityTraits);
+                            entities.set(`${name}:${label}`, entity);
+                        }
                     }
-                    const entity = world.spawn(...entityTraits);
-                    entities.set(`${name}:${label}`, entity);
-                }
-            }
+                });
+            });
         }
         // Clean up non-active entities
         for (const [label, entity] of entities) {

package/dist/hooks/useObjectEvents.svelte.js

@@ -4,6 +4,7 @@ import { useVisibility } from './useVisibility.svelte';
 import { Vector2 } from 'three';
 import { traits } from '../ecs';
 import { updateHoverInfo } from '../HoverUpdater.svelte';
+import { createPose, matrixToPose, poseToMatrix } from '../transform';
 export const useObjectEvents = (entity) => {
     const down = new Vector2();
     const selectedEntity = useSelectedEntity();
@@ -36,16 +37,32 @@ export const useObjectEvents = (entity) => {
         event.stopPropagation();
         if (currentEntity && currentEntity.has(traits.Hovered)) {
             const hoverInfo = updateHoverInfo(currentEntity, event);
-            if (hoverInfo) {
-                currentEntity.set(traits.InstancedPose, {
-                    index: hoverInfo.index,
+            const hoverPose = createPose(hoverInfo
+                ? {
                     x: hoverInfo.x,
                     y: hoverInfo.y,
                     z: hoverInfo.z,
-                    oX: hoverInfo.oX,
-                    oY: hoverInfo.oY,
-                    oZ: hoverInfo.oZ,
-                    theta: hoverInfo.theta,
+                    oX: 0,
+                    oY: 0,
+                    oZ: 1,
+                    theta: 0,
+                }
+                : undefined);
+            const worldPose = currentEntity.get(traits.WorldPose) ?? createPose();
+            const hoverPoseMatrix = poseToMatrix(hoverPose);
+            const worldPoseMatrix = poseToMatrix(worldPose);
+            const resultMatrix = worldPoseMatrix.multiply(hoverPoseMatrix);
+            const resultPose = matrixToPose(resultMatrix);
+            if (hoverInfo) {
+                currentEntity.set(traits.InstancedPose, {
+                    index: hoverInfo.index,
+                    x: resultPose.x,
+                    y: resultPose.y,
+                    z: resultPose.z,
+                    oX: resultPose.oX,
+                    oY: resultPose.oY,
+                    oZ: resultPose.oZ,
+                    theta: resultPose.theta,
                 });
             }
         }

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

@@ -28,49 +28,14 @@ interface PartConfigContext {
 }
 export declare const providePartConfig: (params: () => PartConfigParams) => void;
 export declare const usePartConfig: () => PartConfigContext;
-interface LocalPartConfig {
-    isDirty: () => boolean;
-    hasEditPermissions: () => boolean;
-    getLocalPartConfig: () => Struct;
-    setLocalPartConfig: (config: Struct) => void;
-    componentNameToFragmentId: () => Record<string, string>;
-    saveLocalPartConfig?: () => void;
-    resetLocalPartConfig?: () => void;
-}
 interface AppEmbeddedPartConfigProps {
     isDirty: () => boolean;
     getLocalPartConfig: () => Struct;
     setLocalPartConfig: (config: Struct) => void;
     getComponentToFragId: () => Record<string, string>;
 }
-export declare class AppEmbeddedPartConfig implements LocalPartConfig {
-    private _appEmbeddedPartConfigProps;
-    constructor(appEmbeddedPartConfigProps: AppEmbeddedPartConfigProps);
-    isDirty(): boolean;
-    getLocalPartConfig(): Struct;
-    setLocalPartConfig(config: Struct): void;
-    componentNameToFragmentId(): Record<string, string>;
-    hasEditPermissions(): boolean;
-}
 interface StandalonePartConfigProps {
     viamClient: () => ViamClient | undefined;
     partID: () => string;
 }
-export declare class StandalonePartConfig implements LocalPartConfig {
-    private _standalonePartConfigProps;
-    private _isDirty;
-    private _hasEditPermissions;
-    private _networkPartConfig;
-    private _localPartConfig;
-    private _partName;
-    private _componentNameToFragmentId;
-    constructor(standalonePartConfigProps: StandalonePartConfigProps);
-    getLocalPartConfig(): Struct;
-    setLocalPartConfig(config: Struct): void;
-    isDirty(): boolean;
-    hasEditPermissions(): boolean;
-    componentNameToFragmentId(): Record<string, string>;
-    saveLocalPartConfig(): Promise<void>;
-    resetLocalPartConfig(): Promise<void>;
-}
 export {};

package/dist/hooks/usePartConfig.svelte.js

@@ -218,7 +218,7 @@ export const providePartConfig = (params) => {
 export const usePartConfig = () => {
     return getContext(key);
 };
-export class AppEmbeddedPartConfig {
+class AppEmbeddedPartConfig {
     _appEmbeddedPartConfigProps;
     constructor(appEmbeddedPartConfigProps) {
         this._appEmbeddedPartConfigProps = appEmbeddedPartConfigProps;
@@ -239,7 +239,7 @@ export class AppEmbeddedPartConfig {
         return true;
     }
 }
-export class StandalonePartConfig {
+class StandalonePartConfig {
     _standalonePartConfigProps;
     _isDirty = $state(false);
     _hasEditPermissions = $state(false);

package/dist/hooks/usePointcloudObjects.svelte.js

@@ -1,9 +1,9 @@
-import { GeometriesInFrame, PointCloudObject, VisionClient } from '@viamrobotics/sdk';
+import { VisionClient } from '@viamrobotics/sdk';
 import { createResourceClient, createResourceQuery, useResourceNames, } from '@viamrobotics/svelte-sdk';
 import { RefreshRates, useMachineSettings } from './useMachineSettings.svelte';
 import { useLogs } from './useLogs.svelte';
 import { parsePcdInWorker } from '../lib';
-import { getContext, setContext } from 'svelte';
+import { getContext, setContext, untrack } from 'svelte';
 import { traits, useWorld } from '../ecs';
 import { createBufferGeometry, updateBufferGeometry } from '../attribute';
 import { useEnvironment } from './useEnvironment.svelte';
@@ -66,71 +66,50 @@ export const providePointcloudObjects = (partID) => {
     ]));
     $effect(() => {
         for (const [name, query] of queries) {
-            if (query.isFetching) {
-                logs.add(`Fetching pointcloud for ${name}...`);
-            }
-            else if (query.error) {
-                logs.add(`Error fetching pointcloud from ${name}: ${query.error.message}`, 'error');
-            }
-        }
-    });
-    let pcResults = $state.raw([]);
-    $effect(() => {
-        const responses = [];
-        for (const [name, query] of queries) {
-            const { data } = query;
-            if (name && data) {
-                responses.push([name, data]);
-            }
+            untrack(() => {
+                $effect(() => {
+                    if (query.isFetching) {
+                        logs.add(`Fetching pointcloud for ${name}...`);
+                    }
+                    else if (query.error) {
+                        logs.add(`Error fetching pointcloud from ${name}: ${query.error.message}`, 'error');
+                    }
+                });
+            });
         }
-        Promise.allSettled(responses.map(async ([name, pointcloudObjects]) => {
-            const pointclouds = await Promise.all(pointcloudObjects
-                .filter((value) => value !== undefined)
-                .map((value) => {
-                return parsePcdInWorker(new Uint8Array(value.pointCloud));
-            }));
-            return {
-                name,
-                pointclouds,
-                geometries: pointcloudObjects.map((value) => value.geometries),
-            };
-        })).then((results) => {
-            const fulfilledResults = [];
-            for (const result of results) {
-                if (result.status === 'fulfilled') {
-                    fulfilledResults.push(result.value);
-                }
-                else if (result.status === 'rejected') {
-                    logs.add(result.reason, 'error');
-                }
-            }
-            pcResults = fulfilledResults;
-        });
     });
     const entities = new Map();
     $effect(() => {
         const active = {};
-        for (const { name, pointclouds, geometries } of pcResults) {
-            for (const [pointcloudIndex, pointcloud] of pointclouds.entries()) {
-                const poincloudLabel = `${name} pointcloud ${pointcloudIndex + 1}`;
-                const existing = entities.get(poincloudLabel);
-                active[poincloudLabel] = true;
-                if (existing) {
-                    const geometry = existing.get(traits.BufferGeometry);
-                    if (geometry) {
-                        updateBufferGeometry(geometry, pointcloud.positions, pointcloud.colors);
-                    }
-                }
-                else {
-                    const geometry = createBufferGeometry(pointcloud.positions, pointcloud.colors);
-                    const entity = world.spawn(traits.Name(poincloudLabel), traits.BufferGeometry(geometry), traits.Points);
-                    entities.set(poincloudLabel, entity);
-                }
-                if (geometries) {
-                    for (const geometriesInFrame of geometries) {
+        for (const [name, query] of queries) {
+            untrack(() => {
+                $effect(() => {
+                    const { data } = query;
+                    if (!data || data.length === 0)
+                        return;
+                    let index = 0;
+                    for (const { geometries: geometriesInFrame, pointCloud } of data) {
+                        if (pointCloud.length > 0) {
+                            parsePcdInWorker(pointCloud).then(({ positions, colors }) => {
+                                const poincloudLabel = `${name} pointcloud ${index + 1}`;
+                                const existing = entities.get(poincloudLabel);
+                                if (existing) {
+                                    const geometry = existing.get(traits.BufferGeometry);
+                                    if (geometry) {
+                                        updateBufferGeometry(geometry, positions, colors);
+                                    }
+                                }
+                                else {
+                                    const geometry = createBufferGeometry(positions, colors);
+                                    const entity = world.spawn(traits.Name(poincloudLabel), traits.BufferGeometry(geometry), traits.Points);
+                                    entities.set(poincloudLabel, entity);
+                                }
+                            });
+                        }
                         if (geometriesInFrame) {
-                            for (const [geometryIndex, geometry] of geometriesInFrame.geometries.entries()) {
-                                const geometryLabel = `${name} pointcloud ${pointcloudIndex} geometry ${geometryIndex + 1}`;
+                            let geometryIndex = 0;
+                            for (const geometry of geometriesInFrame.geometries) {
+                                const geometryLabel = `${name} pointcloud ${index} geometry ${geometryIndex + 1}`;
                                 const pose = createPose(geometry.center);
                                 active[geometryLabel] = true;
                                 const existing = entities.get(geometryLabel);
@@ -152,11 +131,13 @@ export const providePointcloudObjects = (partID) => {
                                     const entity = world.spawn(...entityTraits);
                                     entities.set(geometryLabel, entity);
                                 }
+                                geometryIndex += 1;
                             }
                         }
+                        index += 1;
                     }
-                }
-            }
+                });
+            });
         }
         // Clean up old entities
         for (const [label, entity] of entities) {

package/dist/hooks/usePointclouds.svelte.js

@@ -65,12 +65,16 @@ export const providePointclouds = (partID) => {
     const queryMap = $derived(typeSafeObjectFromEntries(queries));
     $effect(() => {
         for (const [name, query] of queries) {
-            if (query.isFetching) {
-                logs.add(`Fetching pointcloud for ${name}...`);
-            }
-            else if (query.error) {
-                logs.add(`Error fetching pointcloud from ${name}: ${query.error.message}`, 'error');
-            }
+            untrack(() => {
+                $effect(() => {
+                    if (query.isFetching) {
+                        logs.add(`Fetching pointcloud for ${name}...`);
+                    }
+                    else if (query.error) {
+                        logs.add(`Error fetching pointcloud from ${name}: ${query.error.message}`, 'error');
+                    }
+                });
+            });
         }
     });
     const entities = new Map();

package/dist/hooks/usePose.svelte.js

@@ -24,7 +24,7 @@ export const usePose = (name, parent) => {
     const resource = $derived(currentName ? resourceByName.current[currentName] : undefined);
     const parentResource = $derived(currentParent ? resourceByName.current[currentParent] : undefined);
     const frames = useFrames();
-    let pose = $state(undefined);
+    let pose = $state();
     const interval = $derived(refreshRates.get(RefreshRates.poses));
     const resolvedParent = $derived(origingFrameComponentTypes.includes(parentResource?.subtype ?? '')
         ? `${parent()}_origin`
@@ -43,6 +43,9 @@ export const usePose = (name, parent) => {
     });
     $effect(() => addQueryToRefetch(query));
     $effect(() => {
+        if (interval === RefetchRates.FPS_30 || interval === RefetchRates.FPS_60) {
+            return logs.add(`Fetching pose for ${currentName} every ${interval}ms...`);
+        }
         if (query.isFetching) {
             logs.add(`Fetching pose for ${currentName}...`);
         }

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

@@ -0,0 +1,7 @@
+import type { ResourceName } from '@viamrobotics/sdk';
+interface Context {
+    current: Record<string, ResourceName | undefined>;
+}
+export declare const provideResourceByName: (partID: () => string) => void;
+export declare const useResourceByName: () => Context;
+export {};

package/dist/hooks/useResourceByName.svelte.js

@@ -1,7 +1,7 @@
 import { useResourceNames } from '@viamrobotics/svelte-sdk';
 import { getContext, setContext } from 'svelte';
-export const RESOURCE_BY_NAME_CONTEXT_KEY = Symbol('resource-by-name-context');
-export const createResourceByName = (partID) => {
+const RESOURCE_BY_NAME_CONTEXT_KEY = Symbol('resource-by-name-context');
+const createResourceByName = (partID) => {
     const resourceNames = useResourceNames(partID);
     const resourceByName = $derived.by(() => {
         const results = {};

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

@@ -25,6 +25,20 @@ export interface Settings {
     renderStats: boolean;
     renderArmModels: 'colliders' | 'colliders+model' | 'model';
     renderSubEntityHoverDetail: boolean;
+    xrController: {
+        left: {
+            armName?: string;
+            gripperName?: string;
+            scaleFactor: number;
+            rotationEnabled: boolean;
+        };
+        right: {
+            armName?: string;
+            gripperName?: string;
+            scaleFactor: number;
+            rotationEnabled: boolean;
+        };
+    };
 }
 interface Context {
     current: Settings;

package/dist/hooks/useSettings.svelte.js

@@ -28,6 +28,16 @@ const defaults = () => ({
     renderStats: false,
     renderArmModels: 'colliders+model',
     renderSubEntityHoverDetail: false,
+    xrController: {
+        left: {
+            scaleFactor: 1.0,
+            rotationEnabled: true,
+        },
+        right: {
+            scaleFactor: 1.0,
+            rotationEnabled: true,
+        },
+    },
 });
 export const provideSettings = () => {
     let settings = $state(defaults());

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

@@ -1,9 +1 @@
-import { type TransformChangeEvent, type TransformWithUUID } from '@viamrobotics/sdk';
-export type ChangeMessage = {
-    type: 'change';
-    events: TransformChangeEvent[];
-};
-export type TransformEvent = TransformChangeEvent & {
-    transform: TransformWithUUID;
-};
 export declare const provideWorldStates: () => void;

package/dist/lib.d.ts

@@ -1,9 +1,7 @@
-export { default as Geometry } from './components/Geometry.svelte';
 export { default as AxesHelper } from './components/AxesHelper.svelte';
 export { default as Snapshot } from './components/Snapshot.svelte';
-export { Snapshot as SnapshotProto } from './draw/v1/snapshot_pb';
+export { Snapshot as SnapshotProto } from './buf/draw/v1/snapshot_pb';
 export { BatchedArrow } from './three/BatchedArrow';
 export { CapsuleGeometry } from './three/CapsuleGeometry';
 export { OrientationVector } from './three/OrientationVector';
-export { WorldObject } from './WorldObject.svelte';
 export { parsePcdInWorker } from './loaders/pcd';

package/dist/lib.js

@@ -1,15 +1,13 @@
 // Components
 // NOTE: These components should be pure and not use any hooks if you add a new component to export here
 // ensure you write a corresponding unit test to assert the component works in absence of parent providers in /src/lib/__tests__/PureComponents.svelte.spec.ts
-export { default as Geometry } from './components/Geometry.svelte';
 export { default as AxesHelper } from './components/AxesHelper.svelte';
 // Snapshot component (uses context, requires MotionTools parent)
 export { default as Snapshot } from './components/Snapshot.svelte';
-export { Snapshot as SnapshotProto } from './draw/v1/snapshot_pb';
+export { Snapshot as SnapshotProto } from './buf/draw/v1/snapshot_pb';
 // Classes
 export { BatchedArrow } from './three/BatchedArrow';
 export { CapsuleGeometry } from './three/CapsuleGeometry';
 export { OrientationVector } from './three/OrientationVector';
-export { WorldObject } from './WorldObject.svelte';
 // Functions
 export { parsePcdInWorker } from './loaders/pcd';

package/dist/snapshot.d.ts

@@ -1,6 +1,6 @@
 import type { World, Entity } from 'koota';
-import type { Snapshot } from './draw/v1/snapshot_pb';
-import { type SceneMetadata } from './draw/v1/scene_pb';
+import type { Snapshot } from './buf/draw/v1/snapshot_pb';
+import { type SceneMetadata } from './buf/draw/v1/scene_pb';
 import type { Settings } from './hooks/useSettings.svelte';
 export declare const applySceneMetadata: (settings: Settings, metadata: SceneMetadata) => Settings;
 export declare const spawnSnapshotEntities: (world: World, snapshot: Snapshot) => Entity[];

package/dist/snapshot.js

@@ -1,7 +1,7 @@
 import { Vector3, Vector4 } from 'three';
 import { NURBSCurve } from 'three/addons/curves/NURBSCurve.js';
-import { RenderArmModels } from './draw/v1/scene_pb';
-import {} from './draw/v1/drawing_pb';
+import { RenderArmModels } from './buf/draw/v1/scene_pb';
+import {} from './buf/draw/v1/drawing_pb';
 import { traits } from './ecs';
 import { Geometry } from '@viamrobotics/sdk';
 import { parseMetadata } from './WorldObject.svelte';

package/dist/three/InstancedArrows/raycast.d.ts

@@ -1,8 +1,6 @@
-import { Object3D, BufferGeometry, Raycaster, type Intersection } from 'three';
+import { Raycaster, type Intersection } from 'three';
 import type { InstancedArrows } from './InstancedArrows';
-export declare function meshBoundsRaycast(this: Object3D & {
-    geometry: BufferGeometry;
-}, raycaster: Raycaster, intersects: Intersection[]): void;
+export declare function meshBoundsRaycast(this: InstancedArrows, raycaster: Raycaster, intersects: Intersection[]): void;
 /**
  * Currently unused. In the future will be used for click only (not mousemove) due to complexity.
  */

package/dist/three/InstancedArrows/raycast.js

@@ -1,4 +1,4 @@
-import { Object3D, BufferGeometry, Ray, Matrix4, Raycaster, Vector3, Box3, RawShaderMaterial, } from 'three';
+import { Ray, Matrix4, Raycaster, Vector3, Box3, RawShaderMaterial } from 'three';
 const vec3 = new Vector3();
 const inverseMatrix = new Matrix4();
 const localRay = new Ray();
@@ -41,10 +41,10 @@ function closestPointsRaySegment(ray, a, b, outRay, outSeg) {
     return outRay.distanceToSquared(outSeg);
 }
 export function meshBoundsRaycast(raycaster, intersects) {
-    if (this.geometry.boundingBox === null) {
-        this.geometry.computeBoundingBox();
+    if (this.shaftMesh.geometry.boundingBox === null) {
+        this.shaftMesh.geometry.computeBoundingBox();
     }
-    box.copy(this.geometry.boundingBox ?? box);
+    box.copy(this.shaftMesh.geometry.boundingBox ?? box);
     if (!raycaster.ray.intersectsBox(box)) {
         return;
     }
@@ -119,7 +119,7 @@ export function raycast(raycaster, intersects) {
             distance: bestDistance,
             point: bestPointWorld,
             object: this.shaftMesh,
-            instanceId: bestInstanceId,
+            index: bestInstanceId,
         });
     }
 }

package/dist/transform.js

@@ -8,6 +8,7 @@ const scale = new Vector3();
 export const createPose = (pose) => {
     // We should only default to the 0,0,1,0 orientation vector if the entire vector component is missing
     const oZ = pose?.oX === undefined && pose?.oY === undefined && pose?.oZ === undefined ? 1 : (pose?.oZ ?? 0);
+    // pose expects theta in degrees
     return {
         x: pose?.x ?? 0,
         y: pose?.y ?? 0,