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

package/types/xr/feature/XRFeatureManager.d.ts

@@ -0,0 +1,65 @@
+import { IXRFeatureDescriptor, IXRFeatureManager, IXRFeature, IXRSession, IXRFrame } from "@galacean/engine-design";
+import { Engine } from "../../Engine";
+/**
+ * The base class of XR feature manager.
+ */
+export declare abstract class XRFeatureManager<TDescriptor extends IXRFeatureDescriptor = IXRFeatureDescriptor, TFeature extends IXRFeature = IXRFeature> implements IXRFeatureManager {
+    protected _engine: Engine;
+    _feature: TFeature;
+    protected _descriptor: TDescriptor;
+    protected _enabled: boolean;
+    /**
+     * Return the descriptor of the feature.
+     */
+    get descriptor(): TDescriptor;
+    set descriptor(value: TDescriptor);
+    /**
+     * Returns whether the feature is enabled.
+     */
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    /**
+     * Returns whether the feature is supported.
+     * @param descriptor - The descriptor of the feature
+     * @returns The promise of the feature
+     */
+    isSupported(descriptor?: IXRFeatureDescriptor): Promise<void>;
+    /**
+     * Initialize the feature.
+     * @returns The promise of the feature
+     */
+    initialize(): Promise<void>;
+    /**
+     * Called when be enabled.
+     */
+    onEnable(): void;
+    /**
+     * Called when be disabled.
+     */
+    onDisable(): void;
+    /**
+     * Called when xr frame is updated.
+     */
+    onUpdate(session: IXRSession, frame: IXRFrame): void;
+    /**
+     * Called when the session is initialized.
+     */
+    onSessionInit(): void;
+    /**
+     * Called when session starts.
+     */
+    onSessionStart(): void;
+    /**
+     * Called when the session is stopped.
+     */
+    onSessionStop(): void;
+    /**
+     * Called when the session is destroyed.
+     */
+    onSessionDestroy(): void;
+    /**
+     * Called when the xr module is destroyed.
+     */
+    onDestroy(): void;
+    constructor(_engine: Engine);
+}

package/types/xr/feature/XRFeatureType.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Enum for XR feature type.
+ */
+export declare enum XRFeatureType {
+    /** Movement tracking */
+    MovementTracking = 0,
+    /** Control camera parameters such as focal length, etc.*/
+    CameraDevice = 1,
+    /** Anchor tracking */
+    AnchorTracking = 2,
+    /** Image tracking */
+    ImageTracking = 3,
+    /** Plane tracking */
+    PlaneTracking = 4,
+    /** Hit test */
+    HitTest = 5
+}

package/types/xr/feature/XRPlatformFeature.d.ts

@@ -0,0 +1,17 @@
+import { IXRPlatformFeature, IXRFeatureDescriptor } from "@galacean/engine-design";
+import { Engine } from "../../Engine";
+/**
+ * The base class of XR platform feature.
+ */
+export declare abstract class XRPlatformFeature implements IXRPlatformFeature {
+    protected _engine: Engine;
+    constructor(engine: Engine);
+    _isSupported(descriptor: IXRFeatureDescriptor): Promise<void>;
+    _initialize(descriptor?: IXRFeatureDescriptor): Promise<void>;
+    _onUpdate(): void;
+    _onDestroy(): void;
+    _onSessionInit(): void;
+    _onSessionStart(): void;
+    _onSessionStop(): void;
+    _onSessionDestroy(): void;
+}

package/types/xr/feature/camera/IXRCameraDescriptor.d.ts

@@ -0,0 +1,7 @@
+import { Camera } from "../../../Camera";
+import { IXRFeatureDescriptor } from "@galacean/engine-design";
+export interface IXRCameraDescriptor extends IXRFeatureDescriptor {
+    camera?: Camera;
+    leftCamera?: Camera;
+    rightCamera?: Camera;
+}

package/types/xr/feature/camera/XRCameraManager.d.ts

@@ -0,0 +1,35 @@
+import { Camera } from "../../../Camera";
+import { Engine } from "../../../Engine";
+import { XRInputType } from "../../input/XRInputType";
+import { XRFeatureManager } from "../XRFeatureManager";
+import { IXRCameraDescriptor } from "./IXRCameraDescriptor";
+export declare class XRCameraManager extends XRFeatureManager<IXRCameraDescriptor> {
+    private _inputManager;
+    private _sessionManager;
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    /**
+     * Attach the camera to the specified input type.
+     * @param type - The input type
+     * @param camera - The camera to be attached
+     */
+    attachCamera(type: XRInputType, camera: Camera): void;
+    /**
+     * Detach the camera from the specified input type.
+     * @param type - The input type
+     * @returns The camera that was detached
+     */
+    detachCamera(type: XRInputType): Camera;
+    /**
+     * Get the camera by the specified input type.
+     * @param type - The input type
+     * @returns The camera
+     */
+    getCameraByType(type: XRInputType): Camera;
+    /**
+     * Return fixed foveation of the camera.
+     */
+    get fixedFoveation(): number;
+    set fixedFoveation(value: number);
+    constructor(engine: Engine);
+}

package/types/xr/feature/camera/XRPlatformCamera.d.ts

@@ -0,0 +1,5 @@
+import { XRPlatformFeature } from "../XRPlatformFeature";
+export declare abstract class XRPlatformCamera extends XRPlatformFeature {
+    get fixedFoveation(): number;
+    set fixedFoveation(value: number);
+}

package/types/xr/feature/hitTest/XRHItTestType.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Enum for the types of hit test that can be performed.
+ * Note: currently only supports plane.
+ */
+export declare enum XRHitTestType {
+    /** None */
+    None = 0,
+    /** Tracked plane. */
+    Plane = 1,
+    /** Tracked mesh. */
+    Mesh = 2,
+    /** Tracked anchor. */
+    Anchor = 4,
+    /** All tracked objects. */
+    All = 7
+}

package/types/xr/feature/hitTest/XRHitTestManager.d.ts

@@ -0,0 +1,38 @@
+import { IXRFeatureDescriptor, IXRHitResult } from "@galacean/engine-design";
+import { XRHitTestType } from "./XRHitTestType";
+import { Ray } from "@galacean/engine-math";
+import { XRFeatureManager } from "../XRFeatureManager";
+export declare class XRHitTestManager extends XRFeatureManager {
+    private _tempRay;
+    private _tempVec2;
+    private _tempVec30;
+    private _tempVec31;
+    private _tempVec32;
+    private _tempVec33;
+    private _tempVec34;
+    private _tempVec35;
+    /**
+     * Returns whether the feature is supported.
+     * @param descriptor - The descriptor of the feature
+     * @returns The promise of the feature
+     */
+    isSupported(descriptor?: IXRFeatureDescriptor): Promise<void>;
+    /**
+     * Hit test.
+     * @param ray - The ray to test
+     * @param type - The type of hit test
+     * @returns The hit result
+     */
+    hitTest(ray: Ray, type: XRHitTestType): IXRHitResult[];
+    /**
+     * Screen hit test.
+     * @param x - The x coordinate of the screen point (normalized)
+     * @param y - The y coordinate of the screen point (normalized)
+     * @param type - The type of hit test
+     * @returns The hit result
+     */
+    screenHitTest(x: number, y: number, type: XRHitTestType): IXRHitResult[];
+    private _hitTest;
+    private _hitTestPlane;
+    private _checkPointerWithinPlane;
+}

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

@@ -0,0 +1,9 @@
+import { IXRFeatureDescriptor } from "@galacean/engine-design";
+import { XRMovementTrackingMode } from "./XRMovementTrackingMode";
+/**
+ * The descriptor of XR movement tracking.
+ */
+export interface IXRMovementTrackingDescriptor extends IXRFeatureDescriptor {
+    /** The mode of movement tracking. */
+    mode: XRMovementTrackingMode;
+}

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[];
+}