@galacean/engine-xr 1.6.8 → 1.6.10

package/types/feature/trackable/XRTrackableFeature.d.ts

@@ -0,0 +1,35 @@
+import { IXRTrackablePlatformFeature } from "@galacean/engine-design";
+import { XRTrackingState } from "../../input/XRTrackingState";
+import { XRFeature } from "../XRFeature";
+import { XRRequestTracking } from "./XRRequestTracking";
+import { XRTracked } from "./XRTracked";
+/**
+ * The base class of XR trackable manager.
+ */
+export declare abstract class XRTrackableFeature<T extends XRTracked = XRTracked, K extends XRRequestTracking<T> = XRRequestTracking<T>> extends XRFeature<IXRTrackablePlatformFeature<T, K>> {
+    protected static _uuid: number;
+    protected _requestTrackings: K[];
+    protected _tracked: T[];
+    protected _added: T[];
+    protected _updated: T[];
+    protected _removed: T[];
+    protected _statusSnapshot: Record<number, XRTrackingState>;
+    private _listeners;
+    /**
+     * Add a listening function for tracked object changes.
+     * @param listener - The listening function
+     */
+    addChangedListener(listener: (added: readonly T[], updated: readonly T[], removed: readonly T[]) => void): void;
+    /**
+     * Remove a listening function of tracked object changes.
+     * @param listener - The listening function
+     */
+    removeChangedListener(listener: (added: readonly T[], updated: readonly T[], removed: readonly T[]) => void): void;
+    _onUpdate(): void;
+    _onSessionStop(): void;
+    _onSessionExit(): void;
+    protected _addRequestTracking(requestTracking: K): void;
+    protected _removeRequestTracking(requestTracking: K): void;
+    protected _removeAllRequestTrackings(): void;
+    protected abstract _generateTracked(): T;
+}

package/types/feature/trackable/XRTracked.d.ts

@@ -0,0 +1,14 @@
+import { IXRTracked } from "@galacean/engine-design";
+import { XRPose } from "../../XRPose";
+import { XRTrackingState } from "../../input/XRTrackingState";
+/**
+ * The base class of XR tracked object.
+ */
+export declare abstract class XRTracked implements IXRTracked {
+    /** The unique id of the trackable. */
+    id: number;
+    /** The pose of the trackable in XR space. */
+    pose: XRPose;
+    /** The tracking state of the trackable. */
+    state: XRTrackingState;
+}

package/types/feature/trackable/anchor/XRAnchor.d.ts

@@ -0,0 +1,6 @@
+import { XRTracked } from "../XRTracked";
+/**
+ * The anchor in XR space.
+ */
+export declare class XRAnchor extends XRTracked {
+}

package/types/feature/trackable/anchor/XRAnchorTracking.d.ts

@@ -0,0 +1,38 @@
+import { Quaternion, Vector3 } from "@galacean/engine";
+import { XRManagerExtended } from "../../../XRManagerExtended";
+import { XRTrackableFeature } from "../XRTrackableFeature";
+import { XRAnchor } from "./XRAnchor";
+import { XRRequestAnchor } from "./XRRequestAnchor";
+/**
+ * The manager of XR anchor tracking.
+ */
+export declare class XRAnchorTracking extends XRTrackableFeature<XRAnchor, XRRequestAnchor> {
+    private _anchors;
+    /**
+     * The anchors to tracking.
+     */
+    get trackingAnchors(): readonly XRAnchor[];
+    /**
+     * The tracked anchors.
+     */
+    get trackedAnchors(): readonly XRAnchor[];
+    /**
+     * @param xrManager - The xr manager
+     */
+    constructor(xrManager: XRManagerExtended);
+    /**
+     * Add a anchor in XR space.
+     * @param anchor - The anchor to be added
+     */
+    addAnchor(position: Vector3, rotation: Quaternion): XRAnchor;
+    /**
+     * Remove a anchor in XR space.
+     * @param anchor - The anchor to be removed
+     */
+    removeAnchor(anchor: XRAnchor): void;
+    /**
+     * Remove all tracking anchors.
+     */
+    clearAnchors(): void;
+    protected _generateTracked(): XRAnchor;
+}

package/types/feature/trackable/anchor/XRRequestAnchor.d.ts

@@ -0,0 +1,16 @@
+import { Quaternion, Vector3 } from "@galacean/engine";
+import { IXRRequestAnchor } from "@galacean/engine-design";
+import { XRRequestTracking } from "../XRRequestTracking";
+import { XRAnchor } from "./XRAnchor";
+/**
+ * The request anchor in XR space.
+ */
+export declare class XRRequestAnchor extends XRRequestTracking<XRAnchor> implements IXRRequestAnchor {
+    position: Vector3;
+    rotation: Quaternion;
+    /**
+     * @param position - Requests the position of the anchor to be added
+     * @param rotation - Requests the rotation of the anchor to be added
+     */
+    constructor(position: Vector3, rotation: Quaternion);
+}

package/types/feature/trackable/image/XRImageTracking.d.ts

@@ -0,0 +1,25 @@
+import { XRManagerExtended } from "../../../XRManagerExtended";
+import { XRTrackableFeature } from "../XRTrackableFeature";
+import { XRReferenceImage } from "./XRReferenceImage";
+import { XRRequestImage } from "./XRRequestImage";
+import { XRTrackedImage } from "./XRTrackedImage";
+/**
+ * The manager of XR image tracking.
+ */
+export declare class XRImageTracking extends XRTrackableFeature<XRTrackedImage, XRRequestImage> {
+    private _trackingImages;
+    /**
+     * The image to tracking.
+     */
+    get trackingImages(): readonly XRReferenceImage[];
+    /**
+     * The tracked images.
+     */
+    get trackedImages(): readonly XRTrackedImage[];
+    /**
+     * @param xrManager - The xr manager
+     * @param trackingImages - The images to be tracked
+     */
+    constructor(xrManager: XRManagerExtended, trackingImages: XRReferenceImage[]);
+    protected _generateTracked(): XRTrackedImage;
+}

package/types/feature/trackable/image/XRReferenceImage.d.ts

@@ -0,0 +1,16 @@
+import { IXRReferenceImage } from "@galacean/engine-design";
+/**
+ *  A reference image is an image to look for in the physical environment.
+ */
+export declare class XRReferenceImage implements IXRReferenceImage {
+    name: string;
+    imageSource: ImageBitmapSource;
+    physicalWidth: number;
+    /**
+     * Create a reference image.
+     * @param name - The name of the image to be tracked
+     * @param imageSource - The image to be tracked
+     * @param physicalWidth - The expected physical width measurement for the real-world image being tracked in meters
+     */
+    constructor(name: string, imageSource: ImageBitmapSource, physicalWidth: number);
+}

package/types/feature/trackable/image/XRRequestImage.d.ts

@@ -0,0 +1,14 @@
+import { IXRRequestImage } from "@galacean/engine-design";
+import { XRRequestTracking } from "../XRRequestTracking";
+import { XRReferenceImage } from "./XRReferenceImage";
+import { XRTrackedImage } from "./XRTrackedImage";
+/**
+ * The request image in XR space.
+ */
+export declare class XRRequestImage extends XRRequestTracking<XRTrackedImage> implements IXRRequestImage {
+    image: XRReferenceImage;
+    /**
+     * @param image - The image to be tracked
+     */
+    constructor(image: XRReferenceImage);
+}

package/types/feature/trackable/image/XRTrackedImage.d.ts

@@ -0,0 +1,12 @@
+import { IXRTrackedImage } from "@galacean/engine-design";
+import { XRTracked } from "../XRTracked";
+import { XRReferenceImage } from "./XRReferenceImage";
+/**
+ * A tracked image in XR space.
+ */
+export declare class XRTrackedImage extends XRTracked implements IXRTrackedImage {
+    /** The reference image which was used to detect this image in the environment.  */
+    referenceImage: XRReferenceImage;
+    /** The width of the image in meters in the physical world. */
+    measuredPhysicalWidth: number;
+}

package/types/feature/trackable/plane/XRPlaneMode.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Enumerates modes of plane in XR.
+ */
+export declare enum XRPlaneMode {
+    /** None. */
+    None = 0,
+    /** Horizontal */
+    Horizontal = 1,
+    /** Vertical */
+    Vertical = 2,
+    /** Includes horizontal and vertical. */
+    EveryThing = 3
+}

package/types/feature/trackable/plane/XRPlaneTracking.d.ts

@@ -0,0 +1,24 @@
+import { XRManagerExtended } from "../../../XRManagerExtended";
+import { XRTrackableFeature } from "../XRTrackableFeature";
+import { XRPlaneMode } from "./XRPlaneMode";
+import { XRRequestPlane } from "./XRRequestPlane";
+import { XRTrackedPlane } from "./XRTrackedPlane";
+/**
+ * The manager of plane tracking feature.
+ */
+export declare class XRPlaneTracking extends XRTrackableFeature<XRTrackedPlane, XRRequestPlane> {
+    /**
+     * The plane detection mode.
+     */
+    get detectionMode(): XRPlaneMode;
+    /**
+     * The tracked planes.
+     */
+    get trackedPlanes(): readonly XRTrackedPlane[];
+    /**
+     * @param xrManager - The xr manager
+     * @param detectionMode - The plane detection mode
+     */
+    constructor(xrManager: XRManagerExtended, detectionMode?: XRPlaneMode);
+    protected _generateTracked(): XRTrackedPlane;
+}

package/types/feature/trackable/plane/XRRequestPlane.d.ts

@@ -0,0 +1,13 @@
+import { IXRRequestPlane } from "@galacean/engine-design";
+import { XRRequestTracking } from "../XRRequestTracking";
+import { XRTrackedPlane } from "./XRTrackedPlane";
+/**
+ * The request plane in XR space.
+ */
+export declare class XRRequestPlane extends XRRequestTracking<XRTrackedPlane> implements IXRRequestPlane {
+    detectionMode: number;
+    /**
+     * @param detectionMode - The plane detection mode
+     */
+    constructor(detectionMode: number);
+}

package/types/feature/trackable/plane/XRTrackedPlane.d.ts

@@ -0,0 +1,21 @@
+import { Vector3 } from "@galacean/engine";
+import { IXRTrackedPlane } from "@galacean/engine-design";
+import { XRTracked } from "../XRTracked";
+import { XRPlaneMode } from "./XRPlaneMode";
+/**
+ * The tracked plane in XR space.
+ */
+export declare class XRTrackedPlane extends XRTracked implements IXRTrackedPlane {
+    /** Whether the detected plane is horizontal or vertical. */
+    planeMode: XRPlaneMode;
+    /** The points that make up this plane.
+     *  Note: These points are in the plane coordinate system,
+     *  and their Y coordinates are all zero.
+     */
+    polygon: Vector3[];
+    /**
+     * Whether this frame changes the attributes of the plane.
+     * Note: Includes `polygon` but no `pose`.
+     */
+    attributesDirty: boolean;
+}

package/types/index.d.ts

@@ -0,0 +1,32 @@
+import "./XRManagerExtended";
+export { XRPose } from "./XRPose";
+export { XRFeature } from "./feature/XRFeature";
+export { XRTrackableFeature } from "./feature/trackable/XRTrackableFeature";
+export { XRTracked } from "./feature/trackable/XRTracked";
+export { XRCameraManager } from "./feature/camera/XRCameraManager";
+export { TrackableType } from "./feature/hitTest/TrackableType";
+export { XRHitResult } from "./feature/hitTest/XRHitResult";
+export { XRHitTest } from "./feature/hitTest/XRHitTest";
+export { XRAnchor } from "./feature/trackable/anchor/XRAnchor";
+export { XRAnchorTracking } from "./feature/trackable/anchor/XRAnchorTracking";
+export { XRImageTracking } from "./feature/trackable/image/XRImageTracking";
+export { XRReferenceImage } from "./feature/trackable/image/XRReferenceImage";
+export { XRTrackedImage } from "./feature/trackable/image/XRTrackedImage";
+export { XRPlaneMode } from "./feature/trackable/plane/XRPlaneMode";
+export { XRPlaneTracking } from "./feature/trackable/plane/XRPlaneTracking";
+export { XRTrackedPlane } from "./feature/trackable/plane/XRTrackedPlane";
+export { XRCamera } from "./input/XRCamera";
+export { XRController } from "./input/XRController";
+export { XRInputButton } from "./input/XRInputButton";
+export { XRInputManager } from "./input/XRInputManager";
+export { XRTrackedInputDevice } from "./input/XRTrackedInputDevice";
+export { XRTrackingState } from "./input/XRTrackingState";
+export { XRSessionManager } from "./session/XRSessionManager";
+export { XRSessionMode } from "./session/XRSessionMode";
+export { XRSessionState } from "./session/XRSessionState";
+export { XRFeatureType } from "./feature/XRFeatureType";
+export { XRRequestTrackingState } from "./feature/trackable/XRRequestTrackingState";
+export { XRInputEventType } from "./input/XRInputEventType";
+export { XRTargetRayMode } from "./input/XRTargetRayMode";
+export * from "./loader/XRReferenceImageDecoder";
+export * from "./loader/XRReferenceImageLoader";

package/types/input/XRCamera.d.ts

@@ -0,0 +1,15 @@
+import { IXRCamera } from "@galacean/engine-design";
+import { Matrix, Rect } from "@galacean/engine";
+import { XRPose } from "../XRPose";
+import { XRInput } from "./XRInput";
+/**
+ * The XR camera.
+ */
+export declare class XRCamera extends XRInput implements IXRCamera {
+    /** The pose of the camera in XR space. */
+    pose: XRPose;
+    /** The viewport of the camera. */
+    viewport: Rect;
+    /** The projection matrix of the camera. */
+    projectionMatrix: Matrix;
+}

package/types/input/XRController.d.ts

@@ -0,0 +1,38 @@
+import { IXRController } from "@galacean/engine-design";
+import { XRPose } from "../XRPose";
+import { XRInput } from "./XRInput";
+import { XRInputButton } from "./XRInputButton";
+/**
+ * The XR controller.
+ */
+export declare class XRController extends XRInput implements IXRController {
+    /** The grip space pose of the controller in XR space. */
+    gripPose: XRPose;
+    /** The target ray space pose of the controller in XR space. */
+    targetRayPose: XRPose;
+    /** The currently pressed buttons of this controller. */
+    pressedButtons: XRInputButton;
+    /** Record button lifted. */
+    down: XRInputButton;
+    /** Record button pressed. */
+    up: XRInputButton;
+    /**
+     *
+     * Returns whether the button is pressed.
+     * @param button - The button to check
+     * @returns Whether the button is pressed
+     */
+    isButtonDown(button: XRInputButton): boolean;
+    /**
+     * Returns whether the button is lifted.
+     * @param button - The button to check
+     * @returns Whether the button is lifted
+     */
+    isButtonUp(button: XRInputButton): boolean;
+    /**
+     * Returns whether the button is held down.
+     * @param button - The button to check
+     * @returns Whether the button is held down
+     */
+    isButtonHeldDown(button: XRInputButton): boolean;
+}

package/types/input/XRInput.d.ts

@@ -0,0 +1,8 @@
+import { IXRInput } from "@galacean/engine-design";
+import { XRTrackedInputDevice } from "./XRTrackedInputDevice";
+import { XRTrackingState } from "./XRTrackingState";
+export declare class XRInput implements IXRInput {
+    type: XRTrackedInputDevice;
+    /** The tracking state of xr input. */
+    trackingState: XRTrackingState;
+}

package/types/input/XRInputButton.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Enum for XR input button.
+ */
+export declare enum XRInputButton {
+    /** None */
+    None = 0,
+    /** Select */
+    Select = 1,
+    /** Select */
+    Trigger = 1,
+    /** Squeeze */
+    Squeeze = 2,
+    /** TouchPad */
+    TouchPad = 4,
+    /** A */
+    AButton = 8,
+    /** B */
+    BButton = 16
+}

package/types/input/XRInputEventType.d.ts

@@ -0,0 +1,8 @@
+export declare enum XRInputEventType {
+    SelectStart = 0,
+    Select = 1,
+    SelectEnd = 2,
+    SqueezeStart = 3,
+    Squeeze = 4,
+    SqueezeEnd = 5
+}

package/types/input/XRInputManager.d.ts

@@ -0,0 +1,32 @@
+import { XRInput } from "./XRInput";
+import { XRTrackedInputDevice } from "./XRTrackedInputDevice";
+/**
+ * The manager of XR input.
+ */
+export declare class XRInputManager {
+    private _xrManager;
+    private _engine;
+    private _added;
+    private _removed;
+    private _trackedDevices;
+    private _statusSnapshot;
+    private _listeners;
+    /**
+     * Returns the tracked device instance.
+     * @param type - The tracked input device type
+     * @returns The input instance
+     */
+    getTrackedDevice<T extends XRInput>(type: XRTrackedInputDevice): T;
+    /**
+     * Add a listener for tracked device changes.
+     * @param listener - The listener to add
+     */
+    addTrackedDeviceChangedListener(listener: (added: readonly XRInput[], removed: readonly XRInput[]) => void): void;
+    /**
+     * Remove a listener of tracked device changes.
+     * @param listener - The listener to remove
+     */
+    removeTrackedDeviceChangedListener(listener: (added: readonly XRInput[], removed: readonly XRInput[]) => void): void;
+    private _handleEvent;
+    private _makeUpPointerEvent;
+}

package/types/input/XRTargetRayMode.d.ts

@@ -0,0 +1,5 @@
+export declare enum XRTargetRayMode {
+    Gaze = 0,
+    TrackedPointer = 1,
+    Screen = 2
+}

package/types/input/XRTrackedInputDevice.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Enumerates some input devices that can be tracked.(including status, posture and other information)
+ */
+export declare enum XRTrackedInputDevice {
+    /** Controller */
+    Controller = 0,
+    /** Left controller */
+    LeftController = 1,
+    /** Right controller */
+    RightController = 2,
+    /** Camera */
+    Camera = 3,
+    /** Left camera */
+    LeftCamera = 4,
+    /** Right camera */
+    RightCamera = 5,
+    /** Head */
+    LeftHand = 6,
+    /** Right hand */
+    RightHand = 7
+}

package/types/input/XRTrackingState.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Enum for XR tracking state.
+ */
+export declare enum XRTrackingState {
+    /** Not tracking */
+    NotTracking = 0,
+    /** Tracking */
+    Tracking = 1,
+    /** Lost track */
+    TrackingLost = 2
+}

package/types/loader/XRReferenceImageDecoder.d.ts

@@ -0,0 +1,5 @@
+import { AssetPromise, BufferReader, Engine } from "@galacean/engine";
+import { XRReferenceImage } from "../feature/trackable/image/XRReferenceImage";
+export declare class XRReferenceImageDecoder {
+    static decode(engine: Engine, bufferReader: BufferReader): AssetPromise<XRReferenceImage>;
+}

package/types/loader/XRReferenceImageLoader.d.ts

@@ -0,0 +1,5 @@
+import { AssetPromise, Loader, LoadItem, ResourceManager } from "@galacean/engine";
+import { XRReferenceImage } from "../feature/trackable/image/XRReferenceImage";
+export declare class XRReferenceImageLoader extends Loader<XRReferenceImage> {
+    load(item: LoadItem, resourceManager: ResourceManager): AssetPromise<XRReferenceImage>;
+}

package/types/session/XRSessionManager.d.ts

@@ -0,0 +1,56 @@
+import { XRSessionMode } from "./XRSessionMode";
+import { XRSessionState } from "./XRSessionState";
+/**
+ * XRSessionManager manages the life cycle of XR sessions.
+ */
+export declare class XRSessionManager {
+    private _xrManager;
+    private _engine;
+    private _mode;
+    private _state;
+    private _rhi;
+    private _raf;
+    private _caf;
+    private _listeners;
+    /**
+     * The current session mode( AR or VR ).
+     */
+    get mode(): XRSessionMode;
+    /**
+     * Return the current session state.
+     */
+    get state(): XRSessionState;
+    /**
+     * Return a list of supported frame rates.(only available in-session)
+     */
+    get supportedFrameRate(): Float32Array;
+    /**
+     * Return the current frame rate as reported by the device.
+     */
+    get frameRate(): number;
+    /**
+     * Check if the specified mode is supported.
+     * @param mode - The mode to check
+     * @returns A promise that resolves if the mode is supported, otherwise rejects
+     */
+    isSupportedMode(mode: XRSessionMode): Promise<void>;
+    /**
+     * Run the session.
+     */
+    run(): void;
+    /**
+     * Stop the session.
+     */
+    stop(): void;
+    /**
+     * Add a listening function for session state changes.
+     * @param listener - The listening function
+     */
+    addStateChangedListener(listener: (state: XRSessionState) => void): void;
+    /**
+     * Remove a listening function of session state changes.
+     * @param listener - The listening function
+     */
+    removeStateChangedListener(listener: (state: XRSessionState) => void): void;
+    private _onSessionExit;
+}

package/types/session/XRSessionMode.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The type of XR session.
+ */
+export declare enum XRSessionMode {
+    None = 0,
+    AR = 1,
+    VR = 2
+}

package/types/session/XRSessionState.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The state of an XRSession.
+ */
+export declare enum XRSessionState {
+    /** Not initialized. */
+    None = 0,
+    /** Initializing session. */
+    Initializing = 1,
+    /** Initialized but not started. */
+    Initialized = 2,
+    /** Running. */
+    Running = 3,
+    /** Paused. */
+    Paused = 4
+}