@galacean/engine-core 1.1.0-beta.2 → 1.1.0-beta.20

package/types/xr/feature/movementTracking/XRMovementTrackingManager.d.ts

@@ -0,0 +1,8 @@
+import { IXRMovementTrackingDescriptor } from "./IXRMovementTrackingDescriptor";
+import { XRMovementTrackingMode } from "./XRMovementTrackingMode";
+import { XRFeatureManager } from "../XRFeatureManager";
+import { IXRMovementTracking } from "@galacean/engine-design";
+export declare class XRMovementTrackingManager extends XRFeatureManager<IXRMovementTrackingDescriptor, IXRMovementTracking> {
+    get trackingMode(): XRMovementTrackingMode;
+    set trackingMode(value: XRMovementTrackingMode);
+}

package/types/xr/feature/movementTracking/XRMovementTrackingMode.d.ts

@@ -0,0 +1,5 @@
+export declare enum XRMovementTrackingMode {
+    None = 0,
+    Dof3 = 1,
+    Dof6 = 2
+}

package/types/xr/feature/movementTracking/XRPlatformMovementTracking.d.ts

@@ -0,0 +1,10 @@
+import { XRPlatformFeature } from "../XRPlatformFeature";
+import { XRMovementTrackingMode } from "./XRMovementTrackingMode";
+/**
+ * The base class of XR platform movement tracking.
+ */
+export declare abstract class XRPlatformMovementTracking extends XRPlatformFeature {
+    private _trackingMode;
+    get trackingMode(): XRMovementTrackingMode;
+    set trackingMode(value: XRMovementTrackingMode);
+}

package/types/xr/feature/trackable/XRRequestTrackingState.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Enum for the state of a request to track a trackable.
+ */
+export declare enum XRRequestTrackingState {
+    None = 0,
+    Submitted = 1,
+    Resolved = 2,
+    Rejected = 3,
+    Destroyed = 4,
+    WaitingDestroy = 5
+}

package/types/xr/feature/trackable/XRTrackableManager.d.ts

@@ -0,0 +1,41 @@
+import { IXRFeatureDescriptor, IXRFrame, IXRRequestTracking, IXRSession, IXRTrackableFeature, IXRTracked } from "@galacean/engine-design";
+import { XRTrackedUpdateFlag } from "../../input/XRTrackedUpdateFlag";
+import { XRFeatureManager } from "../XRFeatureManager";
+import { XRTrackingState } from "../../input/XRTrackingState";
+/**
+ * The base class of XR trackable manager.
+ */
+export declare abstract class XRTrackableManager<TDescriptor extends IXRFeatureDescriptor, TXRTracked extends IXRTracked, TXRRequestTracking extends IXRRequestTracking<TXRTracked>, TTrackableFeature extends IXRTrackableFeature<TXRTracked, TXRRequestTracking>> extends XRFeatureManager<TDescriptor, TTrackableFeature> {
+    protected _requestTrackings: TXRRequestTracking[];
+    protected _trackedObjects: TXRTracked[];
+    protected _added: TXRTracked[];
+    protected _updated: TXRTracked[];
+    protected _removed: TXRTracked[];
+    protected _statusSnapshot: Record<number, XRTrackingState>;
+    private _trackedUpdateFlag;
+    /**
+     * Return Request tracking requirements.
+     */
+    get requestTrackings(): readonly TXRRequestTracking[];
+    /**
+     * Returns the tracked objects.
+     */
+    get trackedObjects(): readonly TXRTracked[];
+    addRequestTracking(add: TXRRequestTracking): void;
+    removeRequestTracking(remove: TXRRequestTracking): void;
+    removeAllRequestTrackings(): void;
+    /**
+     * Add a listening function to track changes.
+     * @param listener - The listening function
+     */
+    addListener(listener: (type: XRTrackedUpdateFlag, param: readonly TXRTracked[]) => any): void;
+    /**
+     * Remove a listening function to track changes.
+     * @param listener - The listening function
+     */
+    removeListener(listener: (type: XRTrackedUpdateFlag, param: readonly TXRTracked[]) => any): void;
+    onUpdate(session: IXRSession, frame: IXRFrame): void;
+    onSessionStop(): void;
+    onSessionDestroy(): void;
+    onDestroy(): void;
+}

package/types/xr/feature/trackable/XRTrackablePlatformFeature.d.ts

@@ -0,0 +1,29 @@
+import { IXRTrackable } from "@galacean/engine-design";
+import { XRPlatformFeature } from "../XRPlatformFeature";
+/**
+ * The base class of XR trackable platform feature.
+ */
+export declare abstract class XRTrackablePlatformFeature<T extends IXRTrackable> extends XRPlatformFeature {
+    private static _trackId;
+    protected _trackedObjects: T[];
+    protected _added: T[];
+    protected _updated: T[];
+    protected _removed: T[];
+    /**
+     * Returns the tracked objects.
+     */
+    get trackedObjects(): readonly T[];
+    /**
+     * Returns the changes tracked in this frame.
+     * @returns The changes of tracked objects
+     */
+    getChanges(): {
+        readonly added: T[];
+        readonly updated: T[];
+        readonly removed: T[];
+    };
+    _onSessionStop(): void;
+    _onSessionDestroy(): void;
+    _onDestroy(): void;
+    protected _generateUUID(): number;
+}

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

@@ -0,0 +1,9 @@
+import { IXRPose, IXRTracked } from "@galacean/engine-design";
+import { XRTrackingState } from "../../input/XRTrackingState";
+export declare class XRTracked implements IXRTracked {
+    id: number;
+    pose: IXRPose;
+    state: XRTrackingState;
+    frameCount: number;
+    constructor(id: number, pose: IXRPose, state?: XRTrackingState, frameCount?: number);
+}

package/types/xr/feature/trackable/XRTrackedUpdateFlag.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Enum for XR tracked update flag.
+ */
+export declare enum XRTrackedUpdateFlag {
+    /** The object that was not tracked in the previous frame was tracked in this frame. */
+    Added = 0,
+    /** Both the previous frame and this frame are tracked */
+    Updated = 1,
+    /** The object that was tracked in the previous frame is not tracked in this frame. */
+    Removed = 2
+}

package/types/xr/feature/trackable/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/xr/feature/trackable/anchor/IXRAnchorTrackingDescriptor.d.ts

@@ -0,0 +1,8 @@
+import { IXRFeatureDescriptor, IXRPose } from "@galacean/engine-design";
+/**
+ * The descriptor of XR anchor tracking.
+ */
+export interface IXRAnchorTrackingDescriptor extends IXRFeatureDescriptor {
+    /** Request tracking anchor. */
+    anchors?: IXRPose[];
+}

package/types/xr/feature/trackable/anchor/XRAnchorTrackingManager.d.ts

@@ -0,0 +1,22 @@
+import { IXRAnchorTracking, IXRPose } from "@galacean/engine-design";
+import { IXRAnchorTrackingDescriptor } from "./IXRAnchorTrackingDescriptor";
+import { XRTrackableManager } from "../XRTrackableManager";
+import { XRRequestTrackingAnchor } from "./XRRequestTrackingAnchor";
+import { XRTracked } from "../XRTracked";
+export declare class XRAnchorTrackingManager extends XRTrackableManager<IXRAnchorTrackingDescriptor, XRTracked, XRRequestTrackingAnchor, IXRAnchorTracking> {
+    /**
+     * Add a tracking anchor.
+     * @param pose - The pose of anchor to be added
+     */
+    addAnchor(pose: IXRPose): XRRequestTrackingAnchor;
+    /**
+     * Remove a tracking anchor.
+     * @param anchor - The anchor to be removed
+     */
+    removeAnchor(pose: IXRPose): void;
+    /**
+     * Remove all tracking anchors.
+     */
+    removeAllAnchors(): void;
+    initialize(): Promise<void>;
+}

package/types/xr/feature/trackable/anchor/XRAnchorTrackingMode.d.ts

@@ -0,0 +1,4 @@
+export declare enum XRAnchorTrackingMode {
+    None = 0,
+    Auto = 1
+}

package/types/xr/feature/trackable/anchor/XRPlatformAnchorTracking.d.ts

@@ -0,0 +1,12 @@
+import { IXRRequestTrackingAnchor, IXRTrackedAnchor } from "@galacean/engine-design";
+import { XRTrackablePlatformFeature } from "../XRTrackablePlatformFeature";
+import { IXRAnchorTrackingDescriptor } from "./IXRAnchorTrackingDescriptor";
+/**
+ * The base class of XR anchor tracking.
+ */
+export declare abstract class XRPlatformAnchorTracking extends XRTrackablePlatformFeature<IXRTrackedAnchor> {
+    protected _requestTrackingAnchors: IXRRequestTrackingAnchor[];
+    get requestTrackingAnchors(): readonly IXRRequestTrackingAnchor[];
+    _initialize(descriptor: IXRAnchorTrackingDescriptor): Promise<void>;
+    protected _disposeAnchor(anchor: IXRRequestTrackingAnchor): void;
+}

package/types/xr/feature/trackable/anchor/XRRequestTrackingAnchor.d.ts

@@ -0,0 +1,10 @@
+import { IXRPose, IXRRequestTracking } from "@galacean/engine-design";
+import { XRRequestTrackingState } from "../XRRequestTrackingState";
+import { XRTracked } from "../XRTracked";
+export declare class XRRequestTrackingAnchor implements IXRRequestTracking<XRTracked> {
+    pose: IXRPose;
+    state: XRRequestTrackingState;
+    tracked: XRTracked[];
+    constructor(pose: IXRPose, state?: XRRequestTrackingState, tracked?: XRTracked[]);
+    equals(other: XRRequestTrackingAnchor): boolean;
+}

package/types/xr/feature/trackable/image/IXRImageTrackingDescriptor.d.ts

@@ -0,0 +1,5 @@
+import { IXRFeatureDescriptor } from "@galacean/engine-design";
+import { XRReferenceImage } from "./XRReferenceImage";
+export interface IXRImageTrackingDescriptor extends IXRFeatureDescriptor {
+    images?: XRReferenceImage[];
+}

package/types/xr/feature/trackable/image/XRImageTrackingManager.d.ts

@@ -0,0 +1,33 @@
+import { IXRImageTracking } from "@galacean/engine-design";
+import { IXRImageTrackingDescriptor } from "./IXRImageTrackingDescriptor";
+import { XRTrackableManager } from "../XRTrackableManager";
+import { XRReferenceImage } from "./XRReferenceImage";
+import { XRTrackedImage } from "./XRTrackedImage";
+import { XRRequestTrackingImage } from "./XRRequestTrackingImage";
+export declare class XRImageTrackingManager extends XRTrackableManager<IXRImageTrackingDescriptor, XRTrackedImage, XRRequestTrackingImage, IXRImageTracking> {
+    /**
+     * Add a tracking image
+     * @param image - xr reference image
+     */
+    addImage(image: XRReferenceImage): void;
+    /**
+     * Add tracking images
+     * @param images - xr reference images
+     */
+    addImage(images: XRReferenceImage[]): void;
+    /**
+     * Remove a tracking image
+     * @param image - xr reference image
+     */
+    removeImage(image: XRReferenceImage): void;
+    /**
+     * Remove tracking images
+     * @param images - xr reference images
+     */
+    removeImage(images: XRReferenceImage[]): void;
+    /**
+     * Remove all tracking images
+     */
+    removeAllImages(): void;
+    initialize(): Promise<void>;
+}

package/types/xr/feature/trackable/image/XRPlatformImageTracking.d.ts

@@ -0,0 +1,14 @@
+import { IXRRequestTrackingImage, IXRTrackedImage } from "@galacean/engine-design";
+import { XRTrackablePlatformFeature } from "../XRTrackablePlatformFeature";
+import { IXRImageTrackingDescriptor } from "./IXRImageTrackingDescriptor";
+/**
+ * The base class of XR image tracking.
+ */
+export declare abstract class XRPlatformImageTracking extends XRTrackablePlatformFeature<IXRTrackedImage> {
+    protected _requestTrackingImages: IXRRequestTrackingImage[];
+    get requestTrackingImages(): readonly IXRRequestTrackingImage[];
+    _initialize(descriptor: IXRImageTrackingDescriptor): Promise<void>;
+    _onSessionDestroy(): void;
+    _onDestroy(): void;
+    protected _disposeImage(image: IXRRequestTrackingImage): void;
+}

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

@@ -0,0 +1,14 @@
+/**
+ *  A reference image is an image to look for in the physical environment.
+ */
+export declare class XRReferenceImage {
+    name: string;
+    src: string | HTMLImageElement | SVGImageElement | HTMLVideoElement | HTMLCanvasElement | Blob | ImageData | ImageBitmap | OffscreenCanvas;
+    private _id;
+    physicalWidth: number;
+    physicalHeight: number;
+    private static _uuid;
+    constructor(name: string, src: string | HTMLImageElement | SVGImageElement | HTMLVideoElement | HTMLCanvasElement | Blob | ImageData | ImageBitmap | OffscreenCanvas, _id?: number, physicalWidth?: number, physicalHeight?: number);
+    get id(): number;
+    dispose(): void;
+}

package/types/xr/feature/trackable/image/XRRequestTrackingImage.d.ts

@@ -0,0 +1,11 @@
+import { IXRRequestTracking } from "@galacean/engine-design";
+import { XRRequestTrackingState } from "../XRRequestTrackingState";
+import { XRTrackedImage } from "./XRTrackedImage";
+import { XRReferenceImage } from "./XRReferenceImage";
+export declare class XRRequestTrackingImage implements IXRRequestTracking<XRTrackedImage> {
+    image: XRReferenceImage;
+    state: XRRequestTrackingState;
+    tracked: XRTrackedImage[];
+    constructor(image: XRReferenceImage, state?: XRRequestTrackingState, tracked?: XRTrackedImage[]);
+    equals(other: XRRequestTrackingImage): boolean;
+}

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

@@ -0,0 +1,5 @@
+import { XRTracked } from "../XRTracked";
+export declare class XRTrackedImage extends XRTracked {
+    /** The width of the image in meters in the physical world. */
+    measuredWidthInMeters: number;
+}

package/types/xr/feature/trackable/plane/IXRPlaneTrackingDescriptor.d.ts

@@ -0,0 +1,9 @@
+import { IXRFeatureDescriptor } from "@galacean/engine-design";
+import { XRPlaneMode } from "./XRPlaneMode";
+/**
+ * The descriptor of XR plane tracking.
+ */
+export interface IXRPlaneTrackingDescriptor extends IXRFeatureDescriptor {
+    /** Rules for detecting planes. */
+    mode: XRPlaneMode;
+}

package/types/xr/feature/trackable/plane/XRPlaneDetectionMode.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Enumerates valid modes of plane to detect.
+ */
+export declare enum XRPlaneDetectionMode {
+    /** Plane detection is disabled. */
+    None = 0,
+    /** Plane detection will only detect horizontal planes. */
+    Horizontal = 1,
+    /** Plane detection will only detect vertical planes. */
+    Vertical = 2,
+    /** Plane detection will detect both horizontal and vertical planes. */
+    EveryThing = 3
+}

package/types/xr/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/xr/feature/trackable/plane/XRPlaneTrackingManager.d.ts

@@ -0,0 +1,14 @@
+import { IXRPlaneTrackingDescriptor } from "./IXRPlaneTrackingDescriptor";
+import { XRPlaneMode } from "./XRPlaneMode";
+import { XRTrackableManager } from "../XRTrackableManager";
+import { XRTrackedPlane } from "./XRTrackedPlane";
+import { XRRequestTrackingPlane } from "./XRRequestTrackingPlane";
+import { IXRPlaneTracking } from "@galacean/engine-design";
+export declare class XRPlaneTrackingManager extends XRTrackableManager<IXRPlaneTrackingDescriptor, XRTrackedPlane, XRRequestTrackingPlane, IXRPlaneTracking> {
+    /**
+     * Return the plane detection mode for XR.
+     */
+    get detectionMode(): XRPlaneMode;
+    set detectionMode(value: XRPlaneMode);
+    initialize(): Promise<void>;
+}

package/types/xr/feature/trackable/plane/XRPlatformPlaneTracking.d.ts

@@ -0,0 +1,11 @@
+import { IXRTrackedPlane } from "@galacean/engine-design";
+import { XRTrackablePlatformFeature } from "../XRTrackablePlatformFeature";
+import { XRPlaneDetectionMode } from "./XRPlaneDetectionMode";
+/**
+ * The base class of XR plane tracking.
+ */
+export declare abstract class XRPlatformPlaneTracking extends XRTrackablePlatformFeature<IXRTrackedPlane> {
+    protected _trackingMode: XRPlaneDetectionMode;
+    get trackingMode(): XRPlaneDetectionMode;
+    set trackingMode(value: XRPlaneDetectionMode);
+}

package/types/xr/feature/trackable/plane/XRRequestTrackingPlane.d.ts

@@ -0,0 +1,11 @@
+import { IXRRequestTracking } from "@galacean/engine-design";
+import { XRRequestTrackingState } from "../XRRequestTrackingState";
+import { XRPlaneMode } from "./XRPlaneMode";
+import { XRTrackedPlane } from "./XRTrackedPlane";
+export declare class XRRequestTrackingPlane implements IXRRequestTracking<XRTrackedPlane> {
+    orientation: XRPlaneMode;
+    state: XRRequestTrackingState;
+    tracked: XRTrackedPlane[];
+    constructor(orientation: XRPlaneMode, state?: XRRequestTrackingState, tracked?: XRTrackedPlane[]);
+    equals(other: XRRequestTrackingPlane): boolean;
+}

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

@@ -0,0 +1,11 @@
+import { Vector3 } from "@galacean/engine-math";
+import { XRTracked } from "../XRTracked";
+export declare class XRTrackedPlane extends XRTracked {
+    /** Whether the detected plane is horizontal or vertical. */
+    orientation: number;
+    /** 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[];
+}

package/types/xr/index.d.ts

@@ -1,18 +1,39 @@
-export { XRManager, registerFeature } from "./XRManager";
-export { EnumXRMode } from "./enum/EnumXRMode";
-export { EnumXRButton } from "./enum/EnumXRButton";
-export { EnumXRFeature } from "./enum/EnumXRFeature";
-export { EnumXRSubsystem } from "./enum/EnumXRSubsystem";
-export { EnumXRDevicePhase } from "./enum/EnumXRDevicePhase";
-export { EnumXRInputSource } from "./enum/EnumXRInputSource";
-export { EnumXRTrackingMode } from "./enum/EnumXRTrackingMode";
-export { XRInputManager } from "./feature/XRInputManager";
-export { XRCameraManager } from "./feature/XRCameraManager";
-export { XRImageTrackManager } from "./feature/XRImageTrackManager";
-export { XRSubsystem } from "./subsystem/XRSubsystem";
-export { XRInputSubsystem } from "./subsystem/XRInputSubsystem";
-export { XRProvider } from "./provider/XRProvider";
-export { XRPoseDriver } from "./component/XRPoseDriver";
-export { XRDevice } from "./data/XRDevice";
-export { XRCamera } from "./data/XRCamera";
-export { XRHandle } from "./data/XRHandle";
+export { XRManager, registerXRFeatureManager } from "./XRManager";
+export type { IXRDevice } from "@galacean/engine-design/src/xr/IXRDevice";
+export { XRFeatureType } from "./feature/XRFeatureType";
+export { XRFeatureManager } from "./feature/XRFeatureManager";
+export type { IXRCameraDescriptor } from "./feature/camera/IXRCameraDescriptor";
+export { XRCameraManager } from "./feature/camera/XRCameraManager";
+export { XRHitTestManager } from "./feature/hitTest/XRHitTestManager";
+export { XRHitTestType } from "./feature/hitTest/XRHitTestType";
+export { XRRequestTrackingState } from "./feature/trackable/XRRequestTrackingState";
+export { XRTracked } from "./feature/trackable/XRTracked";
+export type { IXRMovementTrackingDescriptor } from "./feature/movementTracking/IXRMovementTrackingDescriptor";
+export { XRMovementTrackingManager } from "./feature/movementTracking/XRMovementTrackingManager";
+export { XRMovementTrackingMode } from "./feature/movementTracking/XRMovementTrackingMode";
+export type { IXRAnchorTrackingDescriptor } from "./feature/trackable/anchor/IXRAnchorTrackingDescriptor";
+export { XRAnchorTrackingManager } from "./feature/trackable/anchor/XRAnchorTrackingManager";
+export { XRRequestTrackingAnchor } from "./feature/trackable/anchor/XRRequestTrackingAnchor";
+export type { IXRImageTrackingDescriptor } from "./feature/trackable/image/IXRImageTrackingDescriptor";
+export { XRImageTrackingManager } from "./feature/trackable/image/XRImageTrackingManager";
+export { XRReferenceImage } from "./feature/trackable/image/XRReferenceImage";
+export { XRRequestTrackingImage } from "./feature/trackable/image/XRRequestTrackingImage";
+export { XRTrackedImage } from "./feature/trackable/image/XRTrackedImage";
+export type { IXRPlaneTrackingDescriptor } from "./feature/trackable/plane/IXRPlaneTrackingDescriptor";
+export { XRPlaneTrackingManager } from "./feature/trackable/plane/XRPlaneTrackingManager";
+export { XRPlaneMode } from "./feature/trackable/plane/XRPlaneMode";
+export { XRRequestTrackingPlane } from "./feature/trackable/plane/XRRequestTrackingPlane";
+export { XRTrackedPlane } from "./feature/trackable/plane/XRTrackedPlane";
+export { XRTrackingState } from "./input/XRTrackingState";
+export { XRInputManager } from "./input/XRInputManager";
+export { XRInputButton } from "./input/XRInputButton";
+export { XRInputEvent } from "./input/XRInputEvent";
+export { XRController } from "./input/XRController";
+export { XRInputType } from "./input/XRInputType";
+export { XRCamera } from "./input/XRCamera";
+export { XRTargetRayMode } from "./input/XRTargetRayMode";
+export { XRInputEventType } from "./input/XRInputEventType";
+export { XRTrackedUpdateFlag } from "./input/XRTrackedUpdateFlag";
+export { XRSessionManager } from "./session/XRSessionManager";
+export { XRSessionType } from "./session/XRSessionType";
+export { XRSessionState } from "./session/XRSessionState";

package/types/xr/input/XRCamera.d.ts

@@ -0,0 +1,28 @@
+import { Matrix, Rect } from "@galacean/engine-math";
+import { Camera } from "../../Camera";
+import { IXRInput, IXRPose } from "@galacean/engine-design";
+import { XRInputType } from "./XRInputType";
+import { XRTrackingState } from "./XRTrackingState";
+/**
+ * The XR camera.
+ */
+export declare class XRCamera implements IXRInput {
+    type: XRInputType;
+    /** The update frame count of xr input. */
+    frameCount: number;
+    /** The tracking state of xr input. */
+    trackingState: XRTrackingState;
+    /** The viewport of the camera. */
+    viewport: Rect;
+    /** The projection matrix of the camera. */
+    projectionMatrix: Matrix;
+    /** The associated virtual camera. */
+    camera: Camera;
+    /** The pose of the input. */
+    protected _pose: IXRPose;
+    /**
+     * Return the pose of the input.
+     */
+    get pose(): IXRPose;
+    constructor(type: XRInputType);
+}

package/types/xr/input/XRController.d.ts

@@ -0,0 +1,38 @@
+import { XRControllerPoseMode } from "./XRControllerPoseMode";
+import { DisorderedArray } from "../../DisorderedArray";
+import { IXRInput, IXRPose } from "@galacean/engine-design";
+import { XRInputButton } from "./XRInputButton";
+import { XRInputType } from "./XRInputType";
+import { XRTrackingState } from "./XRTrackingState";
+/**
+ * The XR controller.
+ */
+export declare class XRController implements IXRInput {
+    type: XRInputType;
+    /** The update frame count of xr input. */
+    frameCount: number;
+    /** The tracking state of xr input. */
+    trackingState: XRTrackingState;
+    /** The currently pressed buttons of this controller. */
+    pressedButtons: XRInputButton;
+    /** Record button lifted. */
+    upMap: number[];
+    /** Record button pressed. */
+    downMap: number[];
+    /** Record button lifted in the current frame. */
+    upList: DisorderedArray<XRInputButton>;
+    /** Record button pressed in the current frame. */
+    downList: DisorderedArray<XRInputButton>;
+    /** the pose mode of the controller. (Default is Grip) */
+    poseMode: XRControllerPoseMode;
+    /** The grip space pose of the controller. */
+    gripPose: IXRPose;
+    /** The target ray space pose of the controller. */
+    targetRayPose: IXRPose;
+    protected _pose: IXRPose;
+    /**
+     * Returns the pose of the controller.
+     */
+    get pose(): IXRPose;
+    constructor(type: XRInputType);
+}

package/types/xr/input/XRControllerPoseMode.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The mode of the XRControllerPose component.
+ */
+export declare enum XRControllerPoseMode {
+    /** Grip mode. */
+    Grip = 0,
+    /** Target ray mode. */
+    TargetRay = 1
+}

package/types/xr/input/XRInput.d.ts

@@ -0,0 +1,14 @@
+import { IXRInput, IXRPose } from "@galacean/engine-design";
+import { XRTrackingState } from "../feature/trackable/XRTrackingState";
+export declare abstract class XRInput implements IXRInput {
+    /**
+     * The tracking state of xr input.
+     */
+    trackingState: XRTrackingState;
+    protected _pose: IXRPose;
+    /**
+     * Returns the pose of the input.
+     */
+    get pose(): IXRPose;
+    set pose(value: IXRPose);
+}

package/types/xr/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/xr/input/XRInputEvent.d.ts

@@ -0,0 +1,24 @@
+import { IXRInputEvent } from "@galacean/engine-design";
+import { XRInputEventType } from "./XRInputEventType";
+import { XRTargetRayMode } from "./XRTargetRayMode";
+import { XRInputType } from "./XRInputType";
+/**
+ * XR interaction events.
+ */
+export declare class XRInputEvent implements IXRInputEvent {
+    /**
+     *  TargetRayMode indicates the method by which the target ray for
+     *  the input source should be generated and how it should be presented to the user.
+     */
+    targetRayMode: XRTargetRayMode;
+    /** The type of input event. */
+    type: XRInputEventType;
+    /** The type of input. */
+    input: XRInputType;
+    /** The unique ID of the touch point. (Appears only when targetRayMode is screen.)*/
+    id?: number;
+    /** The coordinate x on the screen. (Appears only when targetRayMode is screen.)*/
+    x?: number;
+    /** The coordinate y on the screen. (Appears only when targetRayMode is screen.) */
+    y?: number;
+}

package/types/xr/input/XRInputEventType.d.ts

@@ -0,0 +1,11 @@
+/**
+ *  The type of input event.
+ */
+export declare enum XRInputEventType {
+    SelectStart = 0,
+    Select = 1,
+    SelectEnd = 2,
+    SqueezeStart = 3,
+    Squeeze = 4,
+    SqueezeEnd = 5
+}