@threlte/xr 0.0.11 → 0.0.12

package/dist/internal/stores.d.ts

@@ -5,6 +5,32 @@ export declare const isPresenting: import("@threlte/core").CurrentWritable<boole
 export declare const isHandTracking: import("@threlte/core").CurrentWritable<boolean>;
 export declare const session: import("@threlte/core").CurrentWritable<XRSession | undefined>;
 export declare const referenceSpaceType: import("@threlte/core").CurrentWritable<XRReferenceSpaceType | undefined>;
-export declare const activeTeleportController: import("@threlte/core").CurrentWritable<import("three").XRTargetRaySpace | undefined>;
-export declare const pendingTeleportDestination: import("@threlte/core").CurrentWritable<import("three").Vector3 | undefined>;
 export declare const xr: import("@threlte/core").CurrentWritable<import("three").WebXRManager | undefined>;
+export declare const teleportState: import("@threlte/core").CurrentWritable<{
+    left: {
+        enabled: boolean;
+        hovering: boolean;
+    };
+    right: {
+        enabled: boolean;
+        hovering: boolean;
+    };
+}>;
+export declare const teleportIntersection: {
+    left: import("@threlte/core").CurrentWritable<import("three").Intersection<import("three").Object3D<import("three").Event>> | undefined>;
+    right: import("@threlte/core").CurrentWritable<import("three").Intersection<import("three").Object3D<import("three").Event>> | undefined>;
+};
+export declare const pointerState: import("@threlte/core").CurrentWritable<{
+    left: {
+        enabled: boolean;
+        hovering: boolean;
+    };
+    right: {
+        enabled: boolean;
+        hovering: boolean;
+    };
+}>;
+export declare const pointerIntersection: {
+    left: import("@threlte/core").CurrentWritable<import("three").Intersection<import("three").Object3D<import("three").Event>> | undefined>;
+    right: import("@threlte/core").CurrentWritable<import("three").Intersection<import("three").Object3D<import("three").Event>> | undefined>;
+};

package/dist/internal/stores.js

@@ -5,6 +5,32 @@ export const isPresenting = currentWritable(false);
 export const isHandTracking = currentWritable(false);
 export const session = currentWritable(undefined);
 export const referenceSpaceType = currentWritable(undefined);
-export const activeTeleportController = currentWritable(undefined);
-export const pendingTeleportDestination = currentWritable(undefined);
 export const xr = currentWritable(undefined);
+export const teleportState = currentWritable({
+    left: {
+        enabled: false,
+        hovering: false,
+    },
+    right: {
+        enabled: false,
+        hovering: false,
+    },
+});
+export const teleportIntersection = {
+    left: currentWritable(undefined),
+    right: currentWritable(undefined),
+};
+export const pointerState = currentWritable({
+    left: {
+        enabled: false,
+        hovering: false,
+    },
+    right: {
+        enabled: false,
+        hovering: false,
+    }
+});
+export const pointerIntersection = {
+    left: currentWritable(undefined),
+    right: currentWritable(undefined),
+};

package/dist/internal/useFixed.d.ts

@@ -0,0 +1,11 @@
+import { type ThrelteUseFrameOptions, type ThrelteContext } from '@threlte/core';
+type UseFixedOptions = ThrelteUseFrameOptions & {
+    fixedStep?: number;
+};
+/**
+ * A fixed useFrame, based on https://github.com/threlte/threlte/pull/654
+ *
+ * @Todo Can be removed if this or a similar feature is merged.
+ */
+export declare const useFixed: (fn: (ctx: ThrelteContext, delta: number) => void, options: UseFixedOptions) => import("@threlte/core/dist/hooks/useFrame").ThrelteUseFrame;
+export {};

package/dist/internal/useFixed.js

@@ -0,0 +1,17 @@
+import { useFrame } from '@threlte/core';
+/**
+ * A fixed useFrame, based on https://github.com/threlte/threlte/pull/654
+ *
+ * @Todo Can be removed if this or a similar feature is merged.
+ */
+export const useFixed = (fn, options) => {
+    let fixedStepTimeAccumulator = 0;
+    let fixedStep = options.fixedStep ?? 1 / 60;
+    return useFrame((ctx, delta) => {
+        fixedStepTimeAccumulator += delta;
+        while (fixedStepTimeAccumulator >= fixedStep) {
+            fixedStepTimeAccumulator -= fixedStep;
+            fn(ctx, fixedStep);
+        }
+    }, options);
+};

package/dist/plugins/pointerControls/compute.d.ts

@@ -0,0 +1,3 @@
+import type { ControlsContext, HandContext } from './types';
+export type ComputeFunction = (state: ControlsContext, handState: HandContext) => void;
+export declare const defaultComputeFunction: ComputeFunction;

package/dist/plugins/pointerControls/compute.js

@@ -0,0 +1,14 @@
+import { Vector3 } from 'three';
+import { useController } from '../../hooks/useController';
+const controllers = {
+    left: useController('left'),
+    right: useController('right')
+};
+const forward = new Vector3();
+export const defaultComputeFunction = (context, handContext) => {
+    const targetRay = controllers[handContext.hand].current?.targetRay;
+    if (targetRay === undefined)
+        return;
+    forward.set(0, 0, -1).applyQuaternion(targetRay.quaternion);
+    context.raycaster.set(targetRay.position, forward);
+};

package/dist/plugins/pointerControls/context.d.ts

@@ -0,0 +1,12 @@
+import type { createRawEventDispatcher } from '@threlte/core';
+import type { ControlsContext, HandContext, ThrelteXREvents } from './types';
+export declare const getHandContext: (hand: 'left' | 'right') => HandContext;
+export declare const setHandContext: (hand: 'left' | 'right', context: HandContext) => void;
+export declare const getControlsContext: () => ControlsContext;
+export declare const setControlsContext: (context: ControlsContext) => void;
+interface InternalContext {
+    dispatchers: WeakMap<THREE.Object3D, ReturnType<typeof createRawEventDispatcher<ThrelteXREvents>>>;
+}
+export declare const getInternalContext: () => InternalContext;
+export declare const setInternalContext: () => void;
+export {};

package/dist/plugins/pointerControls/context.js

@@ -0,0 +1,27 @@
+import { getContext, setContext } from 'svelte';
+const handContextKeys = {
+    left: Symbol('pointer-controls-context-left'),
+    right: Symbol('pointer-controls-context-right')
+};
+const contextKey = Symbol('pointer-controls-context');
+export const getHandContext = (hand) => {
+    return getContext(handContextKeys[hand]);
+};
+export const setHandContext = (hand, context) => {
+    setContext(handContextKeys[hand], context);
+};
+export const getControlsContext = () => {
+    return getContext(contextKey);
+};
+export const setControlsContext = (context) => {
+    setContext(contextKey, context);
+};
+const internalContextKey = Symbol('pointer-controls-internal-context');
+export const getInternalContext = () => {
+    return getContext(internalContextKey);
+};
+export const setInternalContext = () => {
+    setContext(internalContextKey, {
+        dispatchers: new WeakMap()
+    });
+};

package/dist/plugins/pointerControls/hook.d.ts

@@ -0,0 +1,5 @@
+import type { Object3D } from 'three';
+export declare const usePointerControls: () => {
+    addInteractiveObject: (object: Object3D) => void;
+    removeInteractiveObject: (object: Object3D) => void;
+};

package/dist/plugins/pointerControls/hook.js

@@ -0,0 +1,24 @@
+import { createRawEventDispatcher } from '@threlte/core';
+import { getControlsContext, getInternalContext } from './context';
+export const usePointerControls = () => {
+    const { dispatchers } = getInternalContext();
+    const context = getControlsContext();
+    const eventDispatcher = createRawEventDispatcher();
+    const addInteractiveObject = (object) => {
+        // check if the object is already in the list
+        if (context.interactiveObjects.indexOf(object) > -1) {
+            return;
+        }
+        dispatchers.set(object, eventDispatcher);
+        context.interactiveObjects.push(object);
+    };
+    const removeInteractiveObject = (object) => {
+        const index = context.interactiveObjects.indexOf(object);
+        context.interactiveObjects.splice(index, 1);
+        dispatchers.delete(object);
+    };
+    return {
+        addInteractiveObject,
+        removeInteractiveObject
+    };
+};

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

@@ -0,0 +1,27 @@
+import { type ComputeFunction } from './compute';
+import type { FilterFunction } from './types';
+export type PointerControlsOptions = {
+    enabled?: boolean;
+    /**
+     * The compute function is responsible for updating the state of the pointerControls plugin.
+     * It needs to set up the raycaster and the pointer vector. If no compute function is provided,
+     * the plugin will use the default compute function.
+     */
+    compute?: ComputeFunction;
+    /**
+     * The filter function is responsible for filtering and sorting the
+     * intersections. By default, the intersections are sorted by distance. If no
+     * filter function is provided, the plugin will use the default filter function.
+     */
+    filter?: FilterFunction;
+    /**
+     * Sets the interval at which raycasting occurs.
+     *
+     * @default 1 / 40
+     */
+    fixedStep?: number;
+};
+export declare const pointerControls: (handedness: 'left' | 'right', options?: PointerControlsOptions) => {
+    enabled: import("@threlte/core").CurrentWritable<boolean>;
+    hovered: Map<string, import("./types").IntersectionEvent>;
+};

package/dist/plugins/pointerControls/index.js

@@ -0,0 +1,54 @@
+import { Raycaster, Vector3 } from 'three';
+import { currentWritable, watch } from '@threlte/core';
+import { defaultComputeFunction } from './compute';
+import { injectPointerControlsPlugin } from './plugin';
+import { setupPointerControls } from './setup';
+import { getControlsContext, getHandContext, setControlsContext, setHandContext, setInternalContext } from './context';
+import { pointerState } from '../../internal/stores';
+let controlsCounter = 0;
+export const pointerControls = (handedness, options) => {
+    if (getControlsContext() === undefined) {
+        injectPointerControlsPlugin();
+        setInternalContext();
+        setControlsContext({
+            interactiveObjects: [],
+            raycaster: new Raycaster(),
+            compute: options?.compute ?? defaultComputeFunction,
+            filter: options?.filter,
+        });
+    }
+    const context = getControlsContext();
+    if (getHandContext(handedness) === undefined) {
+        const enabled = options?.enabled ?? true;
+        const ctx = {
+            hand: handedness,
+            enabled: currentWritable(enabled),
+            pointer: currentWritable(new Vector3()),
+            pointerOverTarget: currentWritable(false),
+            lastEvent: undefined,
+            initialClick: [0, 0, 0],
+            initialHits: [],
+            hovered: new Map(),
+        };
+        setHandContext(handedness, ctx);
+        setupPointerControls(context, ctx, options?.fixedStep);
+    }
+    const handContext = getHandContext(handedness);
+    watch(handContext.enabled, (enabled) => {
+        controlsCounter += (enabled ? 1 : -1);
+        pointerState.update((value) => {
+            value[handedness].enabled = controlsCounter > 0;
+            return value;
+        });
+    });
+    watch(handContext.pointerOverTarget, (hovering) => {
+        pointerState.update((value) => {
+            value[handedness].hovering = hovering;
+            return value;
+        });
+    });
+    return {
+        enabled: handContext.enabled,
+        hovered: handContext.hovered,
+    };
+};

package/dist/plugins/pointerControls/plugin.d.ts

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

package/dist/plugins/pointerControls/plugin.js

@@ -0,0 +1,28 @@
+import { injectPlugin, watch } from '@threlte/core';
+import { writable } from 'svelte/store';
+import { usePointerControls } from './hook';
+import { useComponentHasEventHandlers } from './useComponentEventHandlers';
+export const injectPointerControlsPlugin = () => {
+    injectPlugin('threlte-pointer-controls', ({ ref }) => {
+        if (ref.isMesh !== true)
+            return;
+        const { addInteractiveObject, removeInteractiveObject } = usePointerControls();
+        const refStore = writable(ref);
+        const { hasEventHandlers } = useComponentHasEventHandlers();
+        watch([hasEventHandlers, refStore], ([hasEventHandlers, ref]) => {
+            // Because hasEventHandlers will only be set from false to true in the
+            // lifecycle of the component, we can safely assume that we do not need to
+            // remove the object from the list of interactive objects when
+            // hasEventHandlers is false.
+            if (!hasEventHandlers)
+                return;
+            addInteractiveObject(ref);
+            return () => removeInteractiveObject(ref);
+        });
+        return {
+            onRefChange(ref) {
+                refStore.set(ref);
+            }
+        };
+    });
+};

package/dist/plugins/pointerControls/setup.d.ts

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

package/dist/plugins/pointerControls/setup.js

@@ -0,0 +1,203 @@
+import { Vector3 } from 'three';
+import { watch } from '@threlte/core';
+import { getInternalContext } from './context';
+import { useController } from '../../hooks/useController';
+import { useHand } from '../../hooks/useHand';
+import { useXR } from '../../hooks/useXR';
+import { useFixed } from '../../internal/useFixed';
+import { pointerIntersection } from '../../internal/stores';
+const getIntersectionId = (intersection) => {
+    return `${(intersection.eventObject || intersection.object).uuid}/${intersection.index}${intersection.instanceId ?? ''}`;
+};
+const EPSILON = 0.0001;
+export const setupPointerControls = (context, handContext, fixedStep = 1 / 40) => {
+    const handedness = handContext.hand;
+    const controller = useController(handedness);
+    const hand = useHand(handedness);
+    const { dispatchers } = getInternalContext();
+    let hits = [];
+    let lastPosition = new Vector3();
+    const handlePointerDown = (event) => {
+        // Save initial coordinates on pointer-down
+        const [hit] = hits;
+        if (!hit)
+            return;
+        handContext.initialClick = [hit.point.x, hit.point.y, hit.point.z];
+        handContext.initialHits = hits.map((hit) => hit.eventObject);
+        handleEvent('pointerdown', event);
+    };
+    const handlePointerUp = (event) => {
+        handleEvent('pointerup', event);
+    };
+    const handleClick = (event) => {
+        // If a click yields no results, pass it back to the user as a miss
+        // Missed events have to come first in order to establish user-land side-effect clean up
+        if (hits.length === 0) {
+            pointerMissed(context.interactiveObjects, event);
+        }
+        handleEvent('click', event);
+    };
+    function cancelPointer(intersections) {
+        for (const [, hoveredObj] of handContext.hovered) {
+            // When no objects were hit or the the hovered object wasn't found underneath the cursor
+            // we call pointerout and delete the object from the hovered elements map
+            if (intersections.length === 0 ||
+                !intersections.some((hit) => hit.object === hoveredObj.object &&
+                    hit.index === hoveredObj.index &&
+                    hit.instanceId === hoveredObj.instanceId)) {
+                const { eventObject } = hoveredObj;
+                handContext.hovered.delete(getIntersectionId(hoveredObj));
+                const eventDispatcher = dispatchers.get(eventObject);
+                if (eventDispatcher) {
+                    // Clear out intersects, they are outdated by now
+                    const data = { ...hoveredObj, intersections };
+                    eventDispatcher('pointerout', data);
+                    eventDispatcher('pointerleave', data);
+                    // Deal with cancelation
+                    handContext.pointerOverTarget.set(false);
+                    cancelPointer([]);
+                }
+            }
+        }
+    }
+    const getHits = () => {
+        const intersections = [];
+        const hits = context.raycaster.intersectObjects(context.interactiveObjects, true);
+        const filtered = context.filter === undefined ? hits : context.filter(hits, context, handContext);
+        pointerIntersection[handedness].set(filtered[0]);
+        // Bubble up the events, find the event source (eventObject)
+        for (const hit of filtered) {
+            let eventObject = hit.object;
+            // Bubble event up
+            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)?.('pointermissed', event);
+        }
+    }
+    function processHits() {
+        context.compute(context, handContext);
+        return getHits();
+    }
+    const handleEvent = (name, event) => {
+        const isPointerMove = name === 'pointermove';
+        const isClickEvent = name === 'click' || name === 'contextmenu';
+        // Take care of unhover
+        if (isPointerMove)
+            cancelPointer(hits);
+        let stopped = false;
+        // loop through all hits and dispatch events
+        dispatchEvents: for (const hit of hits) {
+            const intersectionEvent = {
+                stopped,
+                ...hit,
+                intersections: hits,
+                stopPropagation() {
+                    stopped = true;
+                    intersectionEvent.stopped = true;
+                    if (handContext.hovered.size > 0 &&
+                        Array.from(handContext.hovered.values()).some((i) => i.eventObject === hit.eventObject)) {
+                        // Objects cannot flush out higher up objects that have already caught the event
+                        const higher = hits.slice(0, hits.indexOf(hit));
+                        cancelPointer([...higher, hit]);
+                    }
+                },
+                delta: 0,
+                nativeEvent: event,
+                pointer: handContext.pointer.current,
+                ray: context.raycaster.ray
+            };
+            const eventDispatcher = dispatchers.get(hit.eventObject);
+            if (eventDispatcher === undefined)
+                return;
+            if (isPointerMove) {
+                // Move event ...
+                handContext.pointer.update((value) => value.copy(intersectionEvent.point));
+                if (eventDispatcher.hasEventListener('pointerover') ||
+                    eventDispatcher.hasEventListener('pointerenter') ||
+                    eventDispatcher.hasEventListener('pointerout') ||
+                    eventDispatcher.hasEventListener('pointerleave')) {
+                    const id = getIntersectionId(intersectionEvent);
+                    const hoveredItem = handContext.hovered.get(id);
+                    if (hoveredItem === undefined) {
+                        // If the object wasn't previously hovered, book it and call its handler
+                        handContext.hovered.set(id, intersectionEvent);
+                        eventDispatcher('pointerover', intersectionEvent);
+                        eventDispatcher('pointerenter', intersectionEvent);
+                        handContext.pointerOverTarget.set(true);
+                    }
+                    else if (hoveredItem.stopped) {
+                        // If the object was previously hovered and stopped, we shouldn't allow other items to proceed
+                        intersectionEvent.stopPropagation();
+                    }
+                }
+                // Call pointer move
+                eventDispatcher('pointermove', intersectionEvent);
+            }
+            else if ((!isClickEvent || handContext.initialHits.includes(hit.eventObject)) &&
+                eventDispatcher.hasEventListener(name)) {
+                // Missed events have to come first
+                pointerMissed(context.interactiveObjects.filter((object) => !handContext.initialHits.includes(object)), event);
+                // Call the event
+                eventDispatcher(name, intersectionEvent);
+            }
+            else if (isClickEvent && handContext.initialHits.includes(hit.eventObject)) {
+                pointerMissed(context.interactiveObjects.filter((object) => !handContext.initialHits.includes(object)), event);
+            }
+            if (stopped)
+                break dispatchEvents;
+        }
+    };
+    const { start, stop } = useFixed(() => {
+        hits = processHits();
+        const targetRay = controller.current?.targetRay;
+        if (targetRay === undefined)
+            return;
+        if (targetRay.position.distanceTo(lastPosition) > EPSILON) {
+            handleEvent('pointermove');
+        }
+        lastPosition.copy(targetRay.position);
+    }, {
+        fixedStep,
+        autostart: false
+    });
+    watch(controller, (input) => {
+        if (input === undefined)
+            return;
+        input.targetRay.addEventListener('selectstart', handlePointerDown);
+        input.targetRay.addEventListener('selectend', handlePointerUp);
+        input.targetRay.addEventListener('select', handleClick);
+        return () => {
+            input.targetRay.removeEventListener('selectstart', handlePointerDown);
+            input.targetRay.removeEventListener('selectend', handlePointerUp);
+            input.targetRay.removeEventListener('select', handleClick);
+        };
+    });
+    // watch(hand, (input) => {
+    //   if (input === undefined) return
+    //   input.hand.addEventListener('pinchstart', handlePointerDown)
+    //   input.hand.addEventListener('pinchend', handlePointerUp)
+    //   input.hand.addEventListener('pinchend', handleClick)
+    //   return () => {
+    //     input.hand.removeEventListener('pinchstart', handlePointerDown)
+    //     input.hand.removeEventListener('pinchend', handlePointerUp)
+    //     input.hand.removeEventListener('pinchend', handleClick)
+    //   }
+    // })
+    watch([useXR().isPresenting, handContext.enabled], ([isPresenting, enabled]) => {
+        if (isPresenting && enabled) {
+            start();
+        }
+        else {
+            stop();
+        }
+    });
+};

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

@@ -0,0 +1,61 @@
+import type { CurrentWritable } from '@threlte/core';
+import type { ComputeFunction } from './compute';
+export type Properties<T> = Pick<T, {
+    [K in keyof T]: T[K] extends (_: any) => any ? never : K;
+}[keyof T]>;
+export interface Intersection extends THREE.Intersection {
+    /** The event source (the object which registered the handler) */
+    eventObject: THREE.Object3D;
+}
+export interface IntersectionEvent extends Intersection {
+    /** The event source (the object which registered the handler) */
+    eventObject: THREE.Object3D;
+    /** An array of intersections */
+    intersections: Intersection[];
+    /** Normalized event coordinates */
+    pointer: THREE.Vector3;
+    /** Delta between first click and this event */
+    delta: number;
+    /** The ray that pierced it */
+    ray: THREE.Ray;
+    /** stopPropagation will stop underlying handlers from firing */
+    stopPropagation: () => void;
+    /** The original host event */
+    nativeEvent: THREE.Event | undefined;
+    /** If the event was stopped by calling stopPropagation */
+    stopped: boolean;
+}
+export type FilterFunction = (items: THREE.Intersection[], state: ControlsContext, handState: HandContext) => THREE.Intersection[];
+export type ControlsContext = {
+    interactiveObjects: THREE.Object3D[];
+    raycaster: THREE.Raycaster;
+    compute: ComputeFunction;
+    filter?: FilterFunction | undefined;
+};
+export type HandContext = {
+    hand: 'left' | 'right';
+    enabled: CurrentWritable<boolean>;
+    pointer: CurrentWritable<THREE.Vector3>;
+    pointerOverTarget: CurrentWritable<boolean>;
+    lastEvent: THREE.Event | undefined;
+    initialClick: [x: number, y: number, z: number];
+    initialHits: THREE.Object3D[];
+    hovered: Map<string, IntersectionEvent>;
+};
+export interface PointerCaptureTarget {
+    intersection: Intersection;
+    target: Element;
+}
+export type ThrelteXREvents = {
+    click: IntersectionEvent;
+    contextmenu: IntersectionEvent;
+    pointerup: IntersectionEvent;
+    pointerdown: IntersectionEvent;
+    pointerover: IntersectionEvent;
+    pointerout: IntersectionEvent;
+    pointerenter: IntersectionEvent;
+    pointerleave: IntersectionEvent;
+    pointermove: IntersectionEvent;
+    pointermissed: IntersectionEvent;
+};
+export declare const events: (keyof ThrelteXREvents)[];

package/dist/plugins/pointerControls/types.js

@@ -0,0 +1,11 @@
+export const events = [
+    'click',
+    'contextmenu',
+    'pointerup',
+    'pointerdown',
+    'pointerover',
+    'pointerout',
+    'pointerenter',
+    'pointerleave',
+    'pointermove'
+];

package/dist/plugins/pointerControls/useComponentEventHandlers.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="svelte" />
+export declare const useComponentHasEventHandlers: () => {
+    hasEventHandlers: import("svelte/store").Writable<boolean>;
+};

package/dist/plugins/pointerControls/useComponentEventHandlers.js

@@ -0,0 +1,15 @@
+import { onMount } from 'svelte';
+import { get_current_component } from 'svelte/internal';
+import { writable } from 'svelte/store';
+import { events } from './types';
+export const useComponentHasEventHandlers = () => {
+    const component = get_current_component();
+    const hasEventHandlers = writable(false);
+    onMount(() => {
+        const match = Object.keys(component.$$.callbacks).some((callback) => events.includes(callback));
+        hasEventHandlers.set(match);
+    });
+    return {
+        hasEventHandlers
+    };
+};

package/dist/plugins/teleportControls/compute.d.ts

@@ -0,0 +1,3 @@
+import type { Context, HandContext } from './context';
+export type ComputeFunction = (context: Context, handContext: HandContext) => void;
+export declare const defaultComputeFunction: (context: Context, handContext: HandContext) => void;

package/dist/plugins/teleportControls/compute.js

@@ -0,0 +1,14 @@
+import { Vector3 } from 'three';
+import { useController } from '../../hooks/useController';
+const controllers = {
+    left: useController('left'),
+    right: useController('right')
+};
+const forward = new Vector3();
+export const defaultComputeFunction = (context, handContext) => {
+    const targetRay = controllers[handContext.hand].current?.targetRay;
+    if (targetRay === undefined)
+        return;
+    forward.set(0, 0, -1).applyQuaternion(targetRay.quaternion);
+    context.raycaster.set(targetRay.position, forward);
+};

package/dist/plugins/teleportControls/context.d.ts

@@ -0,0 +1,20 @@
+import type { CurrentWritable, createRawEventDispatcher } from '@threlte/core';
+export type ComputeFunction = (context: Context, handContext: HandContext) => void;
+export interface Context {
+    interactiveObjects: THREE.Mesh[];
+    surfaces: Map<string, THREE.Mesh>;
+    blockers: Map<string, THREE.Mesh>;
+    dispatchers: WeakMap<THREE.Mesh, ReturnType<typeof createRawEventDispatcher>>;
+    raycaster: THREE.Raycaster;
+    compute: ComputeFunction;
+}
+export interface HandContext {
+    hand: 'left' | 'right';
+    enabled: CurrentWritable<boolean>;
+    active: CurrentWritable<boolean>;
+    hovered: CurrentWritable<THREE.Intersection | undefined>;
+}
+export declare const getHandContext: (hand: 'left' | 'right') => HandContext;
+export declare const setHandContext: (hand: 'left' | 'right', context: HandContext) => void;
+export declare const getTeleportContext: () => Context;
+export declare const setTeleportContext: (context: Context) => void;