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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@galacean/engine-core",
-  "version": "1.1.0-beta.20",
+  "version": "1.1.0-beta.22",
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org"
@@ -15,10 +15,10 @@
     "types/**/*"
   ],
   "dependencies": {
-    "@galacean/engine-math": "1.1.0-beta.20"
+    "@galacean/engine-math": "1.1.0-beta.22"
   },
   "devDependencies": {
-    "@galacean/engine-design": "1.1.0-beta.20"
+    "@galacean/engine-design": "1.1.0-beta.22"
   },
   "scripts": {
     "b:types": "tsc"

package/types/animation/AnimatorLayerMask.d.ts

@@ -0,0 +1,45 @@
+import { Entity } from "../Entity";
+import { LayerPathMask } from "./LayerPathMask";
+/**
+ * AnimatorLayerMask is used to mask out certain entities from being animated by an AnimatorLayer.
+ */
+export declare class AnimatorLayerMask {
+    /**
+     * Creates an AnimatorLayerMask instance by specifying an entity.
+     * This will automatically add path masks for the entity and all its children.
+     * @param entity - The root entity to create path masks for
+     */
+    static createByEntity(entity: Entity): AnimatorLayerMask;
+    private static _addPathMaskWithChildren;
+    private _pathMasks;
+    private _pathMaskMap;
+    /**
+     * The list of path masks.
+     */
+    get pathMasks(): Readonly<LayerPathMask[]>;
+    /**
+     * Adds a path mask to the AnimatorLayerMask, the root path is "".
+     * @param path - The path to add a mask for
+     * @returns The created or existing LayerPathMask
+     */
+    addPathMask(path: string): LayerPathMask;
+    /**
+     * Removes a path mask from the AnimatorLayerMask.
+     * @param path - The path of the mask to remove
+     */
+    removePathMask(path: any): void;
+    /**
+     * Get a path mask based on the given path.
+     * @param path - The path of the mask to get
+     * @returns The LayerPathMask for the given path
+     */
+    getPathMask(path: string): LayerPathMask;
+    /**
+     * Sets the active state of a path mask.
+     * If recursive is true, it also sets the active state of all child path masks.
+     * @param path - The path of the mask to modify
+     * @param active - The active state to set
+     * @param withChildren - Whether to apply the active state recursively to child paths
+     */
+    setPathMaskActive(path: string, active: boolean, withChildren?: boolean): void;
+}

package/types/animation/LayerPathMask.d.ts

@@ -0,0 +1,16 @@
+/**
+ * LayerPathMask represents a mask for a specific entity in an animation layer.
+ * It is used to control the animation whether to be applied to the entity or not.
+ */
+export declare class LayerPathMask {
+    /**
+     * It identifies a particular entity in the hierarchy.
+     * Example: "arm/left/hand" could be a path to the left hand of a character.
+     */
+    path: string;
+    /**
+     * The active property is indicating whether the animation at this path is active or not.
+     * When true, the animation for this path is applied; when false, the animation for this path is ignored.
+     */
+    active: boolean;
+}

package/types/xr/XRManager.d.ts

@@ -1,15 +1,13 @@
-import { IXRFeatureDescriptor, IXRFeature } from "@galacean/engine-design";
 import { XRInputManager } from "./input/XRInputManager";
-import { XRFeatureType } from "./feature/XRFeatureType";
 import { XRSessionManager } from "./session/XRSessionManager";
-import { XRSessionType } from "./session/XRSessionType";
-import { XRFeatureManager } from "./feature/XRFeatureManager";
+import { XRCameraManager } from "./feature/camera/XRCameraManager";
+import { XRSessionMode } from "./session/XRSessionMode";
+import { XRFeature } from "./feature/XRFeature";
 import { IXRDevice } from "@galacean/engine-design/src/xr/IXRDevice";
 import { Engine } from "../Engine";
 import { Scene } from "../Scene";
 import { Entity } from "../Entity";
-type TXRFeatureManager = XRFeatureManager<IXRFeatureDescriptor, IXRFeature>;
-type TXRFeatureManagerConstructor = new (engine: Engine) => TXRFeatureManager;
+type TConstructor<T extends new (engine: Engine, ...args: any[]) => XRFeature> = T extends new (engine: Engine, ...args: infer P) => XRFeature ? P : never;
 /**
  * XRManager is the entry point of the XR system.
  */
@@ -18,12 +16,13 @@ export declare class XRManager {
     inputManager: XRInputManager;
     /** Session manager for XR. */
     sessionManager: XRSessionManager;
+    /** Camera manager for XR. */
+    cameraManager: XRCameraManager;
     private _engine;
     private _scene;
     private _origin;
-    private _features;
     private _mode;
-    private _requestFeatures;
+    private _features;
     /**
      * The current xr scene.
      */
@@ -37,60 +36,59 @@ export declare class XRManager {
     /**
      * The current session mode( AR or VR ).
      */
-    get mode(): XRSessionType;
-    /**
-     * The requested features.
-     */
-    get requestFeatures(): IXRFeatureDescriptor[];
+    get mode(): XRSessionMode;
     /**
      * 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
      */
-    isSupported(mode: XRSessionType): Promise<void>;
+    isSupportedSessionMode(mode: XRSessionMode): Promise<void>;
     /**
      * Check if the specified feature is supported.
      * @param descriptors - The feature descriptor to check
      * @returns A promise that resolves if the feature is supported, otherwise rejects
      */
-    isSupportedFeature(descriptors: IXRFeatureDescriptor | IXRFeatureDescriptor[]): Promise<void>;
+    isSupportedFeature<T extends XRFeature>(type: new (engine: Engine) => T): Promise<void>;
     /**
-     * Disable all features.
+     * Add feature based on the xr feature type.
+     * @param type - The type of the feature
+     * @returns The feature which has been added
      */
-    disableAllFeatures(): void;
+    addFeature<T extends new (engine: Engine, ...args: any[]) => XRFeature>(type: T, ...constructor: TConstructor<T>): XRFeature | null;
     /**
-     * Get the feature instance.
-     * @param type - The type of feature
-     * @returns The feature instance
+     * Get feature which match the type.
+     * @param type - The type of the feature
+     * @returns	The feature which match type
      */
-    getFeature<T extends XRFeatureManager>(type: XRFeatureType): T;
+    getFeature<T extends XRFeature>(type: new (engine: Engine, ...args: any[]) => T): T | null;
+    /**
+     * Disable all features.
+     */
+    disableAllFeatures(): void;
     /**
-     * Initialize the session.
-     * @param mode - The mode of the session
-     * @param requestFeatures - The requested features
-     * @returns A promise that resolves if the session is initialized, otherwise rejects
+     * Enter the session.
+     * @returns A promise that resolves if the session is entered, otherwise rejects
      */
-    initSession(mode: XRSessionType, requestFeatures?: IXRFeatureDescriptor[]): Promise<void>;
+    enterXR(mode: XRSessionMode): Promise<void>;
     /**
-     * Destroy the session.
+     * Exit the session.
      * @returns A promise that resolves if the session is destroyed, otherwise rejects
      */
-    destroySession(): Promise<void>;
+    exitXR(): Promise<void>;
     /**
      * Start the session.
      * @returns A promise that resolves if the session is started, otherwise rejects
      */
-    startSession(): Promise<void>;
+    run(): Promise<void>;
     /**
      * Stop the session.
      * @returns A promise that resolves if the session is stopped, otherwise rejects
      */
-    stopSession(): Promise<void>;
+    stop(): Promise<void>;
     /**
      * Destroy xr module.
      */
     destroy(): void;
     constructor(engine: Engine, xrDevice: IXRDevice);
 }
-export declare function registerXRFeatureManager(feature: XRFeatureType): (featureManagerConstructor: TXRFeatureManagerConstructor) => void;
 export {};

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

@@ -1,29 +1,60 @@
+import { IXRFeatureConfig, IXRFeature, IXRPlatformFeature, IXRSession, IXRFrame } from "@galacean/engine-design";
 import { Engine } from "../../Engine";
-export declare abstract class XRFeature {
+/**
+ * The base class of XR feature manager.
+ */
+export declare abstract class XRFeature<TConfig extends IXRFeatureConfig = IXRFeatureConfig, TFeature extends IXRPlatformFeature = IXRPlatformFeature> implements IXRFeature {
     protected _engine: Engine;
+    _platformFeature: TFeature;
+    protected _enabled: boolean;
+    protected _config: TConfig;
     /**
-     * Enable an instance of a feature.
-     * This method needs to be override.
-     * @returns
+     * Returns whether the feature is enabled.
+     */
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    /**
+     * Returns whether the feature is supported.
+     * @returns The promise of the feature
+     */
+    isSupported(): Promise<void>;
+    /**
+     * Initialize the feature.
+     * @returns The promise of the feature
+     */
+    initialize(): Promise<void>;
+    /**
+     * Called when be enabled.
      */
     onEnable(): void;
     /**
-     * Disable an instance of a feature.
-     * This method needs to be override.
-     * @returns
+     * Called when be disabled.
      */
     onDisable(): void;
     /**
-     * Update an instance of a feature.
-     * This method needs to be override.
-     * @returns
+     * Called when xr frame is updated.
+     * @param session - The xr session
+     * @param frame - The xr frame
+     */
+    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.
      */
-    onUpdate(): void;
+    onSessionDestroy(): void;
     /**
-     * Destroy an instance of a feature.
-     * This method needs to be override.
-     * @returns
+     * Called when the xr module is destroyed.
      */
     onDestroy(): void;
-    constructor(engine: Engine);
 }

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

@@ -5,7 +5,7 @@ import { Engine } from "../../Engine";
  */
 export declare abstract class XRFeatureManager<TDescriptor extends IXRFeatureDescriptor = IXRFeatureDescriptor, TFeature extends IXRFeature = IXRFeature> implements IXRFeatureManager {
     protected _engine: Engine;
-    _feature: TFeature;
+    _platformFeature: TFeature;
     protected _descriptor: TDescriptor;
     protected _enabled: boolean;
     /**

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

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

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

@@ -1,35 +1,34 @@
 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);
+/**
+ * The manager of XR camera.
+ */
+export declare class XRCameraManager {
+    private _engine;
     /**
-     * Attach the camera to the specified input type.
+     * Attach the camera to the specified input type(Camera, LeftCamera or RightCamera).
+     * The camera entity need to be moved to the XROrigin entity.
      * @param type - The input type
      * @param camera - The camera to be attached
      */
-    attachCamera(type: XRInputType, camera: Camera): void;
+    attachCamera(type: XRInputType.Camera | XRInputType.LeftCamera | XRInputType.RightCamera, 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;
+    detachCamera(type: XRInputType.Camera | XRInputType.LeftCamera | XRInputType.RightCamera): Camera;
     /**
      * Get the camera by the specified input type.
      * @param type - The input type
      * @returns The camera
      */
-    getCameraByType(type: XRInputType): Camera;
+    getCameraByType(type: XRInputType.Camera | XRInputType.LeftCamera | XRInputType.RightCamera): Camera;
     /**
      * Return fixed foveation of the camera.
      */
     get fixedFoveation(): number;
     set fixedFoveation(value: number);
-    constructor(engine: Engine);
+    constructor(_engine: Engine);
 }

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

@@ -0,0 +1,12 @@
+/**
+ * Enum for the types of hit test that can be performed.
+ * Note: currently only supports plane.
+ */
+export declare enum TrackableType {
+    /** None */
+    None = 0,
+    /** Tracked plane. */
+    Plane = 1,
+    /** All tracked objects. */
+    All = 1
+}

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

@@ -0,0 +1,41 @@
+import { IXRHitResult } from "@galacean/engine-design";
+import { TrackableType } from "./TrackableType";
+import { Ray } from "@galacean/engine-math";
+import { XRFeature } from "../XRFeature";
+import { Engine } from "../../../Engine";
+/**
+ * The manager of XR hit test.
+ */
+export declare class XRHitTest extends XRFeature {
+    private _xrCameraManager;
+    private _tempRay;
+    private _tempVec2;
+    private _tempVec30;
+    private _tempVec31;
+    private _tempVec32;
+    private _tempVec33;
+    private _tempVec34;
+    private _tempVec35;
+    /**
+     * Hit test.
+     * @param ray - The ray to test
+     * @param type - The type of hit test
+     * @returns The hit result
+     */
+    hitTest(ray: Ray, type: TrackableType): 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: TrackableType): IXRHitResult[];
+    private _hitTest;
+    /**
+     * @param engine - The engine
+     */
+    constructor(engine: Engine);
+    private _hitTestPlane;
+    private _checkPointerWithinPlane;
+}

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

@@ -0,0 +1,18 @@
+import { IXRMovementTracking, IXRMovementTrackingConfig } from "@galacean/engine-design";
+import { XRMovementTrackingMode } from "./XRMovementTrackingMode";
+import { XRFeature } from "../XRFeature";
+import { Engine } from "../../../Engine";
+/**
+ * The manager of XR movement tracking.
+ */
+export declare class XRMovementTracking extends XRFeature<IXRMovementTrackingConfig, IXRMovementTracking> {
+    /**
+     * Get the tracking mode.
+     */
+    get trackingMode(): XRMovementTrackingMode;
+    /**
+     * @param engine - The engine
+     * @param trackingMode - The tracking mode
+     */
+    constructor(engine: Engine, trackingMode?: XRMovementTrackingMode);
+}

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

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

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

@@ -0,0 +1,44 @@
+import { IXRFrame, IXRSession, IXRTracked, IXRFeatureConfig, IXRRequestTracking, IXRTrackableFeature } from "@galacean/engine-design";
+import { XRTrackedUpdateFlag } from "../../input/XRTrackedUpdateFlag";
+import { XRFeature } from "../XRFeature";
+import { XRTrackingState } from "../../input/XRTrackingState";
+import { XRSessionManager } from "../../session/XRSessionManager";
+/**
+ * The base class of XR trackable manager.
+ */
+export declare abstract class XRTrackableFeature<TDescriptor extends IXRFeatureConfig, TXRTracked extends IXRTracked, TXRRequestTracking extends IXRRequestTracking<TXRTracked>, TTrackableFeature extends IXRTrackableFeature<TXRTracked, TXRRequestTracking>> extends XRFeature<TDescriptor, TTrackableFeature> {
+    protected _sessionManager: XRSessionManager;
+    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[];
+    /**
+     * 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;
+    protected _addRequestTracking(requestTracking: TXRRequestTracking): void;
+    protected _removeRequestTracking(requestTracking: TXRRequestTracking): void;
+    protected _removeAllRequestTrackings(): void;
+    private _canModifyRequestTracking;
+}

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

@@ -21,7 +21,7 @@ export declare abstract class XRTrackableManager<TDescriptor extends IXRFeatureD
      * Returns the tracked objects.
      */
     get trackedObjects(): readonly TXRTracked[];
-    addRequestTracking(add: TXRRequestTracking): void;
+    addRequestTracking(requestTracking: TXRRequestTracking): void;
     removeRequestTracking(remove: TXRRequestTracking): void;
     removeAllRequestTrackings(): void;
     /**

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

@@ -0,0 +1,29 @@
+import { IXRPose, IXRTracked, IXRAnchorTracking, IXRAnchorTrackingConfig, IXRRequestAnchorTracking } from "@galacean/engine-design";
+import { XRTrackableFeature } from "../XRTrackableFeature";
+import { Engine } from "../../../../Engine";
+/**
+ * The manager of XR anchor tracking.
+ */
+export declare class XRAnchorTracking extends XRTrackableFeature<IXRAnchorTrackingConfig, IXRTracked, IXRRequestAnchorTracking, IXRAnchorTracking> {
+    /**
+     * Add a tracking anchor.
+     * @param pose - The pose of anchor to be added
+     */
+    addAnchor(pose: IXRPose): IXRRequestAnchorTracking;
+    /**
+     * Remove a tracking anchor.
+     * @param anchor - The anchor to be removed
+     */
+    removeAnchor(anchor: IXRRequestAnchorTracking): void;
+    /**
+     * Remove all tracking anchors.
+     */
+    removeAllAnchors(): void;
+    /**
+     * @param engine - The engine
+     * @param anchors - The anchors to be tracked
+     */
+    constructor(engine: Engine, anchors?: IXRPose[]);
+    _generateConfig(): IXRAnchorTrackingConfig;
+    private _createRequestTracking;
+}

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

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

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

@@ -0,0 +1,40 @@
+import { IXRTrackedImage, IXRImageTracking, IXRImageTrackingConfig, IXRRequestImageTracking, IXRReferenceImage } from "@galacean/engine-design";
+import { XRTrackableFeature } from "../XRTrackableFeature";
+import { XRReferenceImage } from "./XRReferenceImage";
+import { Engine } from "../../../../Engine";
+/**
+ * The manager of XR image tracking.
+ */
+export declare class XRImageTracking extends XRTrackableFeature<IXRImageTrackingConfig, IXRTrackedImage, IXRRequestImageTracking, 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;
+    /**
+     * @param engine - The engine
+     * @param images - The images to be tracked
+     */
+    constructor(engine: Engine, images: IXRReferenceImage[]);
+    _generateConfig(): IXRImageTrackingConfig;
+    private _createRequestTracking;
+}

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

@@ -1,10 +1,7 @@
-import { IXRImageTracking } from "@galacean/engine-design";
-import { IXRImageTrackingDescriptor } from "./IXRImageTrackingDescriptor";
+import { IXRImageTracking, IXRRequestImageTracking, IXRTrackedImage, IXRImageTrackingDescriptor } from "@galacean/engine-design";
 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> {
+export declare class XRImageTrackingManager extends XRTrackableManager<IXRImageTrackingDescriptor, IXRTrackedImage, IXRRequestImageTracking, IXRImageTracking> {
     /**
      * Add a tracking image
      * @param image - xr reference image
@@ -30,4 +27,5 @@ export declare class XRImageTrackingManager extends XRTrackableManager<IXRImageT
      */
     removeAllImages(): void;
     initialize(): Promise<void>;
+    private _createRequestTracking;
 }

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

@@ -1,14 +1,11 @@
+import { IXRReferenceImage } from "@galacean/engine-design";
 /**
  *  A reference image is an image to look for in the physical environment.
  */
-export declare class XRReferenceImage {
+export declare class XRReferenceImage implements IXRReferenceImage {
     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;
+    constructor(name: string, src: string | HTMLImageElement | SVGImageElement | HTMLVideoElement | HTMLCanvasElement | Blob | ImageData | ImageBitmap | OffscreenCanvas, physicalWidth?: number, physicalHeight?: number);
 }