@threlte/xr 1.5.5 → 1.6.0

package/dist/plugins/touchControls/hook.js

@@ -0,0 +1,26 @@
+import { getControlsContext, getInternalContext } from './context.js';
+export const useTouchControls = () => {
+    const context = getControlsContext();
+    const { dispatchers } = getInternalContext();
+    if (!context) {
+        throw new Error('No touch controls context found. Did you forget to implement touchControls()?');
+    }
+    const addInteractiveObject = (object, events) => {
+        if (context.interactiveObjects.indexOf(object) > -1) {
+            return;
+        }
+        dispatchers.set(object, events);
+        context.interactiveObjects.push(object);
+    };
+    const removeInteractiveObject = (object) => {
+        const index = context.interactiveObjects.indexOf(object);
+        if (index === -1)
+            return;
+        context.interactiveObjects.splice(index, 1);
+        dispatchers.delete(object);
+    };
+    return {
+        addInteractiveObject,
+        removeInteractiveObject
+    };
+};

package/dist/plugins/touchControls/index.d.ts

@@ -0,0 +1,33 @@
+import { type ComputeFunction } from './compute.js';
+import type { FilterFunction } from './types.js';
+import type { HandJoints } from '../../lib/handJoints.js';
+export type TouchControlsOptions = {
+    enabled?: boolean;
+    /**
+     * Which hand joint to track. Defaults to the index fingertip.
+     * @default 'index-finger-tip'
+     */
+    joint?: HandJoints;
+    /**
+     * Distance at which an object starts receiving hover events.
+     * @default 0.03
+     */
+    hoverRadius?: number;
+    /**
+     * Distance below which a hover transitions to `pointerdown` (and crossing back up fires
+     * `pointerup` + `click`).
+     * @default 0.01
+     */
+    downRadius?: number;
+    compute?: ComputeFunction;
+    filter?: FilterFunction;
+    /**
+     * Interval at which joint positions are polled and intersections are recomputed.
+     * @default 1 / 40
+     */
+    fixedStep?: number;
+};
+export declare const touchControls: (handedness: "left" | "right", options?: TouchControlsOptions) => {
+    enabled: import("@threlte/core").CurrentWritable<boolean>;
+    hovered: Map<string, import("./types.js").IntersectionEvent>;
+};

package/dist/plugins/touchControls/index.js

@@ -0,0 +1,41 @@
+import { Vector3 } from 'three';
+import { currentWritable } from '@threlte/core';
+import { defaultComputeFunction } from './compute.js';
+import { injectTouchControlsPlugin } from './plugin.svelte.js';
+import { setupTouchControls } from './setup.svelte.js';
+import { getControlsContext, getHandContext, setControlsContext, setHandContext, setInternalContext } from './context.js';
+export const touchControls = (handedness, options) => {
+    if (getControlsContext() === undefined) {
+        injectTouchControlsPlugin();
+        setInternalContext();
+        setControlsContext({ interactiveObjects: [] });
+    }
+    const context = getControlsContext();
+    if (getHandContext(handedness) === undefined) {
+        const ctx = {
+            hand: handedness,
+            enabled: currentWritable(options?.enabled ?? true),
+            pointer: currentWritable(new Vector3()),
+            pointerOverTarget: currentWritable(false),
+            origin: new Vector3(),
+            originValid: false,
+            lastEvent: undefined,
+            initialClick: [0, 0, 0],
+            initialHits: [],
+            hovered: new Map(),
+            down: false,
+            joint: options?.joint ?? 'index-finger-tip',
+            hoverRadius: options?.hoverRadius ?? 0.03,
+            downRadius: options?.downRadius ?? 0.01,
+            compute: options?.compute ?? defaultComputeFunction,
+            filter: options?.filter
+        };
+        setHandContext(handedness, ctx);
+        setupTouchControls(context, ctx, options?.fixedStep);
+    }
+    const handContext = getHandContext(handedness);
+    return {
+        enabled: handContext.enabled,
+        hovered: handContext.hovered
+    };
+};

package/dist/plugins/touchControls/plugin.svelte.d.ts

@@ -0,0 +1 @@
+export declare const injectTouchControlsPlugin: () => void;

package/dist/plugins/touchControls/plugin.svelte.js

@@ -0,0 +1,24 @@
+import { injectPlugin, isInstanceOf } from '@threlte/core';
+import { useTouchControls } from './hook.js';
+import { events } from './types.js';
+export const injectTouchControlsPlugin = () => {
+    injectPlugin('threlte-touch-controls', (args) => {
+        if (!isInstanceOf(args.ref, 'Object3D'))
+            return;
+        const { addInteractiveObject, removeInteractiveObject } = useTouchControls();
+        $effect.pre(() => {
+            const ref = args.ref;
+            const props = args.props;
+            const hasEventHandlers = events.some((eventName) => typeof props[eventName] === 'function');
+            if (!hasEventHandlers)
+                return;
+            addInteractiveObject(ref, props);
+            return () => {
+                removeInteractiveObject(ref);
+            };
+        });
+        return {
+            pluginProps: events
+        };
+    });
+};

package/dist/plugins/touchControls/setup.svelte.d.ts

@@ -0,0 +1,2 @@
+import type { ControlsContext, HandContext } from './types.js';
+export declare const setupTouchControls: (context: ControlsContext, handContext: HandContext, fixedStep?: number) => void;

package/dist/plugins/touchControls/setup.svelte.js

@@ -0,0 +1,247 @@
+import { Matrix4, Mesh, Ray, Sphere, Vector3 } from 'three';
+import { observe } from '@threlte/core';
+import { fromStore } from 'svelte/store';
+import { getInternalContext } from './context.js';
+import { useFixed } from '../../internal/useFixed.js';
+import { isPresenting } from '../../internal/state.svelte.js';
+const getIntersectionId = (intersection) => {
+    const target = intersection.eventObject ?? intersection.object;
+    if (intersection.instanceId !== undefined) {
+        return `${target.uuid}|${intersection.instanceId}`;
+    }
+    if (intersection.object.isPoints) {
+        return `${target.uuid}|${intersection.index}`;
+    }
+    return target.uuid;
+};
+let nextPointerId = 2001;
+const worldSphere = new Sphere();
+const invMatrix = new Matrix4();
+const localOrigin = new Vector3();
+const localClamped = new Vector3();
+const surfacePoint = new Vector3();
+// The IntersectionEvent shape still carries `ray`, which isn't meaningful for
+// touch. A fixed dummy ray keeps the type happy and matches the shape that the
+// ray-based plugins provide.
+const dummyRay = new Ray();
+export const setupTouchControls = (context, handContext, fixedStep = 1 / 40) => {
+    const handedness = handContext.hand;
+    const pointerId = nextPointerId++;
+    const enabled = fromStore(handContext.enabled);
+    const { dispatchers } = getInternalContext();
+    let hits = [];
+    const pushHit = (raw, origin, reachSquared, object) => {
+        const mesh = object;
+        const geometry = mesh.geometry;
+        if (geometry === undefined)
+            return;
+        if (geometry.boundingSphere === null)
+            geometry.computeBoundingSphere();
+        if (geometry.boundingBox === null)
+            geometry.computeBoundingBox();
+        if (geometry.boundingSphere === null || geometry.boundingBox === null)
+            return;
+        mesh.updateWorldMatrix(true, false);
+        // Broad-phase: world-space bounding sphere reject.
+        worldSphere.copy(geometry.boundingSphere).applyMatrix4(mesh.matrixWorld);
+        const broad = handContext.hoverRadius + worldSphere.radius;
+        if (origin.distanceToSquared(worldSphere.center) > broad * broad)
+            return;
+        // Narrow-phase: closest point on the local-space AABB (so rotation /
+        // scale are handled exactly), projected back to world.
+        invMatrix.copy(mesh.matrixWorld).invert();
+        localOrigin.copy(origin).applyMatrix4(invMatrix);
+        geometry.boundingBox.clampPoint(localOrigin, localClamped);
+        surfacePoint.copy(localClamped).applyMatrix4(mesh.matrixWorld);
+        const distSq = origin.distanceToSquared(surfacePoint);
+        if (distSq > reachSquared)
+            return;
+        raw.push({
+            distance: Math.sqrt(distSq),
+            point: surfacePoint.clone(),
+            object: mesh,
+            eventObject: mesh,
+            face: null
+        });
+    };
+    const collectHits = (raw, origin, reachSquared, object, seen) => {
+        if (seen.has(object.uuid))
+            return;
+        seen.add(object.uuid);
+        pushHit(raw, origin, reachSquared, object);
+        for (const child of object.children) {
+            collectHits(raw, origin, reachSquared, child, seen);
+        }
+    };
+    function cancelPointer(intersections) {
+        if (handContext.hovered.size === 0)
+            return;
+        const currentIds = new Set();
+        for (const hit of intersections) {
+            currentIds.add(getIntersectionId(hit));
+        }
+        const toRemove = [];
+        for (const [id, hoveredObj] of handContext.hovered) {
+            if (!currentIds.has(id)) {
+                toRemove.push([id, hoveredObj]);
+            }
+        }
+        for (const [id, hoveredObj] of toRemove) {
+            const { eventObject } = hoveredObj;
+            handContext.hovered.delete(id);
+            const events = dispatchers.get(eventObject);
+            if (events !== undefined) {
+                const data = { ...hoveredObj, intersections };
+                events.onpointerout?.(data);
+                events.onpointerleave?.(data);
+            }
+        }
+        if (handContext.hovered.size === 0) {
+            handContext.pointerOverTarget.set(false);
+        }
+    }
+    // Unlike `pointerControls`, this plugin doesn't publish a per-hand
+    // `pointerIntersection` global. There's no on-screen cursor for touch — the
+    // tracked joint is the cursor — so nothing internal needs to subscribe to
+    // the closest hit. Consumers that want hover state from outside event
+    // handlers can read the returned `hovered` Map.
+    const getHits = () => {
+        if (!handContext.originValid)
+            return [];
+        const origin = handContext.origin;
+        const reach = handContext.hoverRadius;
+        const reachSquared = reach * reach;
+        const raw = [];
+        const seen = new Set();
+        for (const obj of context.interactiveObjects) {
+            collectHits(raw, origin, reachSquared, obj, seen);
+        }
+        raw.sort((a, b) => a.distance - b.distance);
+        const filtered = handContext.filter === undefined ? raw : handContext.filter(raw, context, handContext);
+        const intersections = [];
+        for (const hit of filtered) {
+            let eventObject = hit.object;
+            while (eventObject) {
+                if (dispatchers.has(eventObject)) {
+                    intersections.push({ ...hit, eventObject });
+                }
+                eventObject = eventObject.parent;
+            }
+        }
+        return intersections;
+    };
+    function pointerMissed(objects, event) {
+        for (const object of objects) {
+            dispatchers.get(object)?.onpointermissed?.(event);
+        }
+    }
+    const handleEvent = (name, event) => {
+        const isPointerMove = name === 'onpointermove';
+        const isClickEvent = name === 'onclick';
+        if (isClickEvent) {
+            pointerMissed(context.interactiveObjects.filter((object) => !handContext.initialHits.includes(object)), event);
+        }
+        if (isPointerMove)
+            cancelPointer(hits);
+        let stopped = false;
+        dispatchEvents: for (const hit of hits) {
+            const events = dispatchers.get(hit.eventObject);
+            if (events === undefined)
+                continue;
+            const intersectionEvent = {
+                stopped,
+                ...hit,
+                intersections: hits,
+                handedness,
+                pointerId,
+                stopPropagation() {
+                    stopped = true;
+                    intersectionEvent.stopped = true;
+                    if (handContext.hovered.size > 0 &&
+                        Array.from(handContext.hovered.values()).some((i) => i.eventObject === hit.eventObject)) {
+                        const higher = hits.slice(0, hits.indexOf(hit));
+                        cancelPointer([...higher, hit]);
+                    }
+                },
+                delta: 0,
+                nativeEvent: event,
+                pointer: handContext.pointer.current,
+                ray: dummyRay
+            };
+            if (isPointerMove) {
+                handContext.pointer.update((value) => value.copy(intersectionEvent.point));
+                if (events.onpointerover ||
+                    events.onpointerenter ||
+                    events.onpointerout ||
+                    events.onpointerleave) {
+                    const id = getIntersectionId(intersectionEvent);
+                    const hoveredItem = handContext.hovered.get(id);
+                    if (hoveredItem === undefined) {
+                        handContext.hovered.set(id, intersectionEvent);
+                        events.onpointerover?.(intersectionEvent);
+                        events.onpointerenter?.(intersectionEvent);
+                        handContext.pointerOverTarget.set(true);
+                    }
+                    else if (hoveredItem.stopped) {
+                        intersectionEvent.stopPropagation();
+                    }
+                }
+                events.onpointermove?.(intersectionEvent);
+            }
+            else if (events[name] !== undefined) {
+                if (!isClickEvent || handContext.initialHits.includes(hit.eventObject)) {
+                    events[name]?.(intersectionEvent);
+                }
+            }
+            if (stopped)
+                break dispatchEvents;
+        }
+    };
+    // Release-phase dispatch uses hits synthesized from `initialHits` (the
+    // objects that received pointerdown), so pointerup/click fire even if the
+    // finger has moved past the object — mirrors DOM pointer capture.
+    const buildCapturedHits = () => {
+        const [x, y, z] = handContext.initialClick;
+        return handContext.initialHits.map((object) => ({
+            distance: 0,
+            point: new Vector3(x, y, z),
+            object,
+            eventObject: object,
+            face: null
+        }));
+    };
+    const { start, stop } = useFixed(() => {
+        handContext.compute(context, handContext);
+        hits = getHits();
+        // Hover / move every tick — the joint moves continuously, so there is
+        // no "still pointer" optimization to make here.
+        handleEvent('onpointermove');
+        const closest = hits[0];
+        const shouldBeDown = closest !== undefined && closest.distance < handContext.downRadius;
+        if (shouldBeDown && !handContext.down) {
+            handContext.down = true;
+            handContext.initialClick = [closest.point.x, closest.point.y, closest.point.z];
+            handContext.initialHits = hits.map((h) => h.eventObject);
+            handleEvent('onpointerdown');
+        }
+        else if (!shouldBeDown && handContext.down) {
+            handContext.down = false;
+            const liveHits = hits;
+            hits = buildCapturedHits();
+            handleEvent('onpointerup');
+            handleEvent('onclick');
+            hits = liveHits;
+        }
+    }, {
+        fixedStep,
+        autoStart: false
+    });
+    observe.pre(() => [isPresenting.current, enabled.current], ([presenting, active]) => {
+        if (presenting && active) {
+            start();
+        }
+        else {
+            stop();
+        }
+    });
+};

package/dist/plugins/touchControls/types.d.ts

@@ -0,0 +1,62 @@
+import type { Intersection as ThreeIntersection, Object3D, Vector3, Ray, Event } from 'three';
+import type { CurrentWritable } from '@threlte/core';
+import type { ComputeFunction } from './compute.js';
+import type { HandJoints } from '../../lib/handJoints.js';
+export type Properties<T> = Pick<T, {
+    [K in keyof T]: T[K] extends (_: any) => any ? never : K;
+}[keyof T]>;
+export interface Intersection<T extends Object3D = Object3D> extends ThreeIntersection<T> {
+    eventObject: Object3D;
+}
+export interface IntersectionEvent extends Intersection {
+    eventObject: Object3D;
+    intersections: Intersection[];
+    handedness: 'left' | 'right';
+    pointerId: number;
+    pointer: Vector3;
+    delta: number;
+    ray: Ray;
+    stopPropagation: () => void;
+    nativeEvent: Event | undefined;
+    stopped: boolean;
+}
+export type FilterFunction = (items: Intersection[], state: ControlsContext, handState: HandContext) => Intersection[];
+export type ControlsContext = {
+    interactiveObjects: Object3D[];
+};
+export type HandContext = {
+    hand: 'left' | 'right';
+    enabled: CurrentWritable<boolean>;
+    pointer: CurrentWritable<Vector3>;
+    pointerOverTarget: CurrentWritable<boolean>;
+    /** World-space position of this hand's tracked joint, updated by `compute` each tick. */
+    origin: Vector3;
+    /** `false` when the joint isn't currently tracked. Skips intersection work and hides debug. */
+    originValid: boolean;
+    lastEvent: Event | undefined;
+    initialClick: [x: number, y: number, z: number];
+    initialHits: Object3D[];
+    hovered: Map<string, IntersectionEvent>;
+    /** Whether the joint is currently past the downRadius threshold. */
+    down: boolean;
+    /** Which joint to track for this hand. */
+    joint: HandJoints;
+    /** Distance at which an object starts receiving hover events for this hand. */
+    hoverRadius: number;
+    /** Distance at which hover transitions to pointerdown for this hand. */
+    downRadius: number;
+    compute: ComputeFunction;
+    filter?: FilterFunction | undefined;
+};
+export type ThrelteXREvents = {
+    onclick: IntersectionEvent;
+    onpointerup: IntersectionEvent;
+    onpointerdown: IntersectionEvent;
+    onpointerover: IntersectionEvent;
+    onpointerout: IntersectionEvent;
+    onpointerenter: IntersectionEvent;
+    onpointerleave: IntersectionEvent;
+    onpointermove: IntersectionEvent;
+    onpointermissed: IntersectionEvent;
+};
+export declare const events: (keyof ThrelteXREvents)[];

package/dist/plugins/touchControls/types.js

@@ -0,0 +1,11 @@
+export const events = [
+    'onclick',
+    'onpointerup',
+    'onpointerdown',
+    'onpointerover',
+    'onpointerout',
+    'onpointerenter',
+    'onpointerleave',
+    'onpointermove',
+    'onpointermissed'
+];

package/dist/types.d.ts

@@ -37,7 +37,7 @@ export type XRHandEvent<Type = XRHandEventType> = Type extends 'connected' | 'di
 } : Type extends 'pinchstart' | 'pinchend' ? {
     type: Type;
     handedness: 'left' | 'right';
-    target: null;
+    target: XRHandSpace;
 } : never;
 export type XRHandEventCallback<Type> = (event: XRHandEvent<Type>) => void;
 export interface XRHandEvents {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@threlte/xr",
-  "version": "1.5.5",
+  "version": "1.6.0",
   "author": "Micheal Parks <michealparks1989@gmail.com> (https://parks.lol)",
   "license": "MIT",
   "description": "Tools to more easily create VR and AR experiences with Threlte",
@@ -28,8 +28,8 @@
     "typescript-eslint": "^8.32.0",
     "vite": "^7.1.4",
     "vite-plugin-mkcert": "^1.17.5",
-    "@threlte/core": "8.5.9",
-    "@threlte/extras": "9.14.9"
+    "@threlte/extras": "9.15.0",
+    "@threlte/core": "8.5.10"
   },
   "peerDependencies": {
     "svelte": ">=5",

package/dist/internal/setupControllers.d.ts

@@ -1,2 +0,0 @@
-import { XRControllerModelFactory } from 'three/examples/jsm/webxr/XRControllerModelFactory.js';
-export declare const setupControllers: (factory?: XRControllerModelFactory) => void;

package/dist/internal/setupControllers.js

@@ -1,73 +0,0 @@
-import { XRControllerModelFactory } from 'three/examples/jsm/webxr/XRControllerModelFactory.js';
-import { useThrelte } from '@threlte/core';
-import { onMount } from 'svelte';
-import { useHandTrackingState } from './useHandTrackingState.js';
-import { controllers } from '../hooks/useController.svelte.js';
-import { controllerEvents } from './state.svelte.js';
-export const setupControllers = (factory) => {
-    const { xr } = useThrelte().renderer;
-    const hasHands = useHandTrackingState();
-    const targetRaySpaces = [xr.getController(0), xr.getController(1)];
-    const indexMap = new Map();
-    const modelFactory = factory ?? new XRControllerModelFactory();
-    targetRaySpaces.forEach((targetRay, index) => {
-        indexMap.set(targetRay, {
-            targetRay,
-            grip: xr.getControllerGrip(index),
-            model: modelFactory.createControllerModel(targetRay)
-        });
-    });
-    onMount(() => {
-        const dispatch = (event) => {
-            if (hasHands())
-                return;
-            const { data } = event;
-            controllerEvents[data.handedness]?.[`on${event.type}`]?.(event);
-        };
-        function handleConnected(event) {
-            const { data: inputSource } = event;
-            // The targetRaySpace 'connected' event fires for both controller and
-            // hand-tracking input sources. The controllers slot represents a physical
-            // controller — setupHands handles the hand-tracking side.
-            if (inputSource.hand)
-                return;
-            const { model, targetRay, grip } = indexMap.get(this);
-            controllers[event.data.handedness] = {
-                inputSource,
-                targetRay,
-                grip,
-                model
-            };
-            dispatch(event);
-        }
-        const handleDisconnected = (event) => {
-            dispatch(event);
-            controllers[event.data.handedness] = undefined;
-        };
-        for (const targetRay of targetRaySpaces) {
-            targetRay.addEventListener('connected', handleConnected);
-            targetRay.addEventListener('disconnected', handleDisconnected);
-            targetRay.addEventListener('select', dispatch);
-            targetRay.addEventListener('selectstart', dispatch);
-            targetRay.addEventListener('selectend', dispatch);
-            targetRay.addEventListener('squeeze', dispatch);
-            targetRay.addEventListener('squeezestart', dispatch);
-            targetRay.addEventListener('squeezeend', dispatch);
-        }
-        return () => {
-            for (const targetRay of targetRaySpaces) {
-                targetRay.removeEventListener('connected', handleConnected);
-                targetRay.removeEventListener('disconnected', handleDisconnected);
-                targetRay.removeEventListener('select', dispatch);
-                targetRay.removeEventListener('selectstart', dispatch);
-                targetRay.removeEventListener('selectend', dispatch);
-                targetRay.removeEventListener('squeeze', dispatch);
-                targetRay.removeEventListener('squeezestart', dispatch);
-                targetRay.removeEventListener('squeezeend', dispatch);
-            }
-            controllers.left = undefined;
-            controllers.right = undefined;
-            controllers.none = undefined;
-        };
-    });
-};

package/dist/internal/setupHands.d.ts

@@ -1,2 +0,0 @@
-import { XRHandModelFactory } from 'three/examples/jsm/webxr/XRHandModelFactory.js';
-export declare const setupHands: (factory?: XRHandModelFactory) => void;

package/dist/internal/setupHands.js

@@ -1,67 +0,0 @@
-import { XRHandModelFactory } from 'three/examples/jsm/webxr/XRHandModelFactory.js';
-import { useThrelte } from '@threlte/core';
-import { onMount } from 'svelte';
-import { hands } from '../hooks/useHand.svelte.js';
-import { useHandTrackingState } from './useHandTrackingState.js';
-import { handEvents } from './state.svelte.js';
-export const setupHands = (factory) => {
-    const { xr } = useThrelte().renderer;
-    const hasHands = useHandTrackingState();
-    const handSpaces = [xr.getHand(0), xr.getHand(1)];
-    const map = new Map();
-    const modelFactory = factory ?? new XRHandModelFactory();
-    handSpaces.forEach((handSpace, index) => {
-        map.set(handSpace, {
-            hand: handSpace,
-            targetRay: xr.getController(index),
-            model: modelFactory.createHandModel(handSpace, 'mesh')
-        });
-    });
-    onMount(() => {
-        const dispatch = (event) => {
-            if (!hasHands())
-                return;
-            const handEvent = event;
-            const handedness = 'handedness' in handEvent ? handEvent.handedness : handEvent.data.handedness;
-            handEvents[handedness]?.[`on${event.type}`]?.(event);
-        };
-        function handleConnected(event) {
-            const { model, targetRay } = map.get(this);
-            const { data } = event;
-            const { handedness, hand: inputSource } = data;
-            if (handedness === 'none' || inputSource === undefined) {
-                return;
-            }
-            hands[handedness] = {
-                hand: this,
-                model,
-                inputSource,
-                targetRay
-            };
-            dispatch(event);
-        }
-        const handleDisconnected = (event) => {
-            dispatch(event);
-            const { handedness } = event.data;
-            if (handedness === 'left' || handedness === 'right') {
-                hands[handedness] = undefined;
-            }
-        };
-        for (const handSpace of handSpaces) {
-            handSpace.addEventListener('connected', handleConnected);
-            handSpace.addEventListener('disconnected', handleDisconnected);
-            handSpace.addEventListener('pinchstart', dispatch);
-            handSpace.addEventListener('pinchend', dispatch);
-        }
-        return () => {
-            for (const handSpace of handSpaces) {
-                handSpace.removeEventListener('connected', handleConnected);
-                handSpace.removeEventListener('disconnected', handleDisconnected);
-                handSpace.removeEventListener('pinchstart', dispatch);
-                handSpace.removeEventListener('pinchend', dispatch);
-            }
-            hands.left = undefined;
-            hands.right = undefined;
-        };
-    });
-};

package/dist/internal/useHandTrackingState.d.ts

@@ -1,5 +0,0 @@
-/**
- * There are some cases where we need to know if hand tracking is now active before an input source
- * connection or disconnection event. This is the way to do that.
- */
-export declare const useHandTrackingState: () => () => boolean;

package/dist/internal/useHandTrackingState.js

@@ -1,20 +0,0 @@
-import { useThrelte } from '@threlte/core';
-/**
- * There are some cases where we need to know if hand tracking is now active before an input source
- * connection or disconnection event. This is the way to do that.
- */
-export const useHandTrackingState = () => {
-    const { renderer } = useThrelte();
-    return () => {
-        const sources = renderer.xr.getSession()?.inputSources;
-        if (sources === undefined) {
-            return false;
-        }
-        for (const source of sources) {
-            if (source.hand !== undefined) {
-                return true;
-            }
-        }
-        return false;
-    };
-};