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

package/types/physics/Collider.d.ts

@@ -1,11 +1,12 @@
 import { BoolUpdateFlag } from "../BoolUpdateFlag";
 import { Component } from "../Component";
 import { ColliderShape } from "./shape/ColliderShape";
+import { ICustomClone } from "../clone/ComponentCloner";
 /**
  * Base class for all colliders.
  * @decorator `@dependentComponents(Transform, DependentMode.CheckOnly)`
  */
-export declare class Collider extends Component {
+export declare class Collider extends Component implements ICustomClone {
     protected _updateFlag: BoolUpdateFlag;
     protected _shapes: ColliderShape[];
     /**
@@ -26,4 +27,5 @@ export declare class Collider extends Component {
      * Remove all shape attached.
      */
     clearShapes(): void;
+    protected _addPhysicsShape(shape: ColliderShape): void;
 }

package/types/physics/PhysicsMaterial.d.ts

@@ -8,6 +8,7 @@ export declare class PhysicsMaterial {
     private _staticFriction;
     private _bounceCombine;
     private _frictionCombine;
+    private _destroyed;
     constructor();
     /**
      * The coefficient of bounciness.

package/types/physics/joint/HingeJoint.d.ts

@@ -28,7 +28,7 @@ export declare class HingeJoint extends Joint {
     /**
      * The angular velocity of the joint in degrees per second.
      */
-    get velocity(): Readonly<Vector3>;
+    get velocity(): Readonly<number>;
     /**
      * Enables the joint's limits. Disabled by default.
      */

package/types/physics/joint/Joint.d.ts

@@ -3,13 +3,14 @@ import { Vector3 } from "@galacean/engine-math";
 import { Component } from "../../Component";
 import { Entity } from "../../Entity";
 import { Collider } from "../Collider";
+import { ICustomClone } from "../../clone/ComponentCloner";
 /**
  * A base class providing common functionality for joints.
  * @decorator `@dependentComponents(Collider, DependentMode.CheckOnly)`
  */
-export declare class Joint extends Component {
-    protected _connectedCollider: JointCollider;
-    protected _collider: JointCollider;
+export declare class Joint extends Component implements ICustomClone {
+    protected _colliderInfo: JointColliderInfo;
+    protected _connectedColliderInfo: JointColliderInfo;
     protected _nativeJoint: IJoint;
     private _force;
     private _torque;

package/types/physics/shape/ColliderShape.d.ts

@@ -1,10 +1,11 @@
 import { PhysicsMaterial } from "../PhysicsMaterial";
 import { Vector3 } from "@galacean/engine-math";
 import { Collider } from "../Collider";
+import { ICustomClone } from "../../clone/ComponentCloner";
 /**
  * Abstract class for collider shapes.
  */
-export declare abstract class ColliderShape {
+export declare abstract class ColliderShape implements ICustomClone {
     private static _idGenerator;
     protected _id: number;
     protected _material: PhysicsMaterial;

package/types/physics/shape/SphereColliderShape.d.ts

@@ -10,4 +10,5 @@ export declare class SphereColliderShape extends ColliderShape {
     get radius(): number;
     set radius(value: number);
     constructor();
+    _cloneTo(target: SphereColliderShape): void;
 }

package/types/shader/Shader.d.ts

@@ -19,7 +19,7 @@ export declare class Shader {
      * // Import shaderLab
      * import { ShaderLab } from "@galacean/engine-shader-lab";
      * // Create engine with shaderLab
-     * const engine = await WebGLEngine.create({ canvas: "canvas", new ShaderLab() });
+     * const engine = await WebGLEngine.create({ canvas: "canvas", shader: new ShaderLab() });
      * ...
      * ```
      *

package/types/xr/IXRDevice.d.ts

@@ -0,0 +1,26 @@
+import { IXRSession, IXRFeatureDescriptor, IXRPlatformFeature } from "@galacean/engine-design";
+import { Engine } from "../Engine";
+import { XRSessionType } from "./session/XRSessionType";
+/**
+ * The interface of XR device.
+ */
+export interface IXRDevice {
+    /**
+     * Whether the device is supported.
+     * @param mode - The mode of the session.
+     */
+    isSupported(mode: XRSessionType): Promise<void>;
+    /**
+     * Get the platform feature instance of this device
+     * @param engine - The engine.
+     * @param type - The type of the feature.
+     */
+    createPlatformFeature(engine: Engine, type: number): IXRPlatformFeature;
+    /**
+     * Request a session.
+     * @param engine - The engine
+     * @param mode - The mode of the session
+     * @param requestFeatures - The requested features
+     */
+    requestSession(engine: Engine, mode: XRSessionType, requestFeatures: IXRFeatureDescriptor[]): Promise<IXRSession>;
+}

package/types/xr/XRManager.d.ts

@@ -1,31 +1,96 @@
+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 { IXRDevice } from "@galacean/engine-design/src/xr/IXRDevice";
 import { Engine } from "../Engine";
-import { EnumXRMode } from "./enum/EnumXRMode";
-import { EnumXRFeature } from "./enum/EnumXRFeature";
-import { EnumXRTrackingMode } from "./enum/EnumXRTrackingMode";
-import { XRFeature } from "./feature/XRFeature";
-import { EnumXRSubsystem } from "./enum/EnumXRSubsystem";
-import { XRProvider } from "./provider/XRProvider";
-import { XRSubsystem } from "./subsystem/XRSubsystem";
-type FeatureConstructor = new (engine: Engine) => XRFeature;
+import { Scene } from "../Scene";
+import { Entity } from "../Entity";
+type TXRFeatureManager = XRFeatureManager<IXRFeatureDescriptor, IXRFeature>;
+type TXRFeatureManagerConstructor = new (engine: Engine) => TXRFeatureManager;
+/**
+ * XRManager is the entry point of the XR system.
+ */
 export declare class XRManager {
+    /** Input manager for XR. */
+    inputManager: XRInputManager;
+    /** Session manager for XR. */
+    sessionManager: XRSessionManager;
     private _engine;
-    private _provider;
+    private _scene;
+    private _origin;
     private _features;
-    private _subsystems;
-    private _isPaused;
-    isSupportedMode(mode: EnumXRMode): Promise<void>;
-    isSupportedTrackingMode(mode: EnumXRTrackingMode): Promise<void>;
-    isSupportedFeature(feature: EnumXRFeature): Promise<void>;
-    getFeature<T extends XRFeature>(feature: EnumXRFeature): T;
-    enableFeature(feature: EnumXRFeature): void;
-    disableFeature(feature: EnumXRFeature): void;
-    getSubsystem<T extends XRSubsystem>(subsystem: EnumXRSubsystem): T;
-    initialize(mode: EnumXRMode, trackingMode: EnumXRTrackingMode, requestFeatures?: EnumXRFeature[]): Promise<void>;
-    start(): Promise<void>;
-    pause(): void;
-    resume(): void;
+    private _mode;
+    private _requestFeatures;
+    /**
+     * The current xr scene.
+     */
+    get scene(): Scene;
+    set scene(value: Scene);
+    /**
+     * The current xr origin.
+     */
+    get origin(): Entity;
+    set origin(value: Entity);
+    /**
+     * The current session mode( AR or VR ).
+     */
+    get mode(): XRSessionType;
+    /**
+     * The requested features.
+     */
+    get requestFeatures(): IXRFeatureDescriptor[];
+    /**
+     * 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>;
+    /**
+     * 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>;
+    /**
+     * Disable all features.
+     */
+    disableAllFeatures(): void;
+    /**
+     * Get the feature instance.
+     * @param type - The type of feature
+     * @returns The feature instance
+     */
+    getFeature<T extends XRFeatureManager>(type: XRFeatureType): T;
+    /**
+     * 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
+     */
+    initSession(mode: XRSessionType, requestFeatures?: IXRFeatureDescriptor[]): Promise<void>;
+    /**
+     * Destroy the session.
+     * @returns A promise that resolves if the session is destroyed, otherwise rejects
+     */
+    destroySession(): Promise<void>;
+    /**
+     * Start the session.
+     * @returns A promise that resolves if the session is started, otherwise rejects
+     */
+    startSession(): Promise<void>;
+    /**
+     * Stop the session.
+     * @returns A promise that resolves if the session is stopped, otherwise rejects
+     */
+    stopSession(): Promise<void>;
+    /**
+     * Destroy xr module.
+     */
     destroy(): void;
-    constructor(engine: Engine, type: new (engine: Engine) => XRProvider);
+    constructor(engine: Engine, xrDevice: IXRDevice);
 }
-export declare function registerFeature(feature: EnumXRFeature, dependentSubsystem?: EnumXRSubsystem[]): (featureConstructor: FeatureConstructor) => void;
+export declare function registerXRFeatureManager(feature: XRFeatureType): (featureManagerConstructor: TXRFeatureManagerConstructor) => void;
 export {};

package/types/xr/XRModule.d.ts

@@ -0,0 +1,126 @@
+import { IXRFeatureDescriptor, IXRPlatformFeature } from "@galacean/engine-design";
+import { Engine } from "../Engine";
+import { IXRDevice } from "./IXRDevice";
+import { XRInputManager } from "./input/XRInputManager";
+import { XRFeatureType } from "./feature/XRFeatureType";
+import { XRSessionManager } from "./session/XRSessionManager";
+import { XRSessionState } from "./session/XRSessionState";
+import { XRSessionType } from "./session/XRSessionType";
+import { XRFeatureManager } from "./feature/XRFeatureManager";
+import { XRPlatformFeature } from "./feature/XRPlatformFeature";
+import { Scene } from "../Scene";
+import { Entity } from "../Entity";
+import { Component } from "../Component";
+type TXRFeatureManager = XRFeatureManager<IXRFeatureDescriptor, IXRPlatformFeature>;
+type TXRFeatureManagerConstructor = new (engine: Engine) => TXRFeatureManager;
+type TXRSessionStateChangeListener = (from: XRSessionState, to: XRSessionState) => void;
+type TXRTrackedComponent = new (entity: Entity) => Component;
+/**
+ * XRModule is the entry point of the XR system.
+ */
+export declare class XRModule {
+    /** Hardware adaptation for XR. */
+    xrDevice: IXRDevice;
+    /** Input manager for XR. */
+    inputManager: XRInputManager;
+    /** Session manager for XR. */
+    sessionManager: XRSessionManager;
+    private _engine;
+    private _scene;
+    private _origin;
+    private _features;
+    private _sessionState;
+    private _listeners;
+    private _mode;
+    private _requestFeatures;
+    /**
+     * The current xr scene.
+     */
+    get scene(): Scene;
+    set scene(value: Scene);
+    /**
+     * The current xr origin.
+     */
+    get origin(): Entity;
+    set origin(value: Entity);
+    /**
+     * The current session mode( AR or VR ).
+     */
+    get mode(): XRSessionType;
+    /**
+     * The requested features.
+     */
+    get requestFeatures(): IXRFeatureDescriptor[];
+    /**
+     * The current session state.
+     */
+    get sessionState(): XRSessionState;
+    /**
+     * 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>;
+    /**
+     * 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>;
+    /**
+     * Disable all features.
+     */
+    disableAllFeatures(): void;
+    /**
+     * Get the feature instance.
+     * @param type - The type of feature
+     * @returns The feature instance
+     */
+    getFeature<T extends XRFeatureManager<IXRFeatureDescriptor, XRPlatformFeature>>(type: XRFeatureType): T;
+    /**
+     * 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
+     */
+    initSession(mode: XRSessionType, requestFeatures?: IXRFeatureDescriptor[]): Promise<void>;
+    /**
+     * Destroy the session.
+     * @returns A promise that resolves if the session is destroyed, otherwise rejects
+     */
+    destroySession(): Promise<void>;
+    /**
+     * Start the session.
+     * @returns A promise that resolves if the session is started, otherwise rejects
+     */
+    startSession(): Promise<void>;
+    /**
+     * Stop the session.
+     * @returns A promise that resolves if the session is stopped, otherwise rejects
+     */
+    stopSession(): Promise<void>;
+    /**
+     * Reset the session.
+     */
+    destroy(): void;
+    /**
+     * Add a session state change listener.
+     * @param listener - The listener to add
+     */
+    addSessionStateChangeListener(listener: TXRSessionStateChangeListener): void;
+    /**
+     * Remove a session state change listener.
+     * @param listener - The listener to remove
+     */
+    removeSessionStateChangeListener(listener: TXRSessionStateChangeListener): void;
+    /**
+     * Remove all session state change listeners.
+     */
+    removeAllSessionStateChangeListener(): void;
+    constructor(engine: Engine, xrDevice: IXRDevice);
+    private _setSessionState;
+    private _dispatchSessionStateChange;
+}
+export declare function registerXRFeatureManager(feature: XRFeatureType): (featureManagerConstructor: TXRFeatureManagerConstructor) => void;
+export declare function registerXRComponent(feature: XRFeatureType): (componentConstructor: TXRTrackedComponent) => void;
+export {};

package/types/xr/component/XRPoseDriver.d.ts

@@ -1,10 +1,10 @@
 import { Script } from "../../Script";
-import { EnumXRInputSource } from "../enum/EnumXRInputSource";
-import { EnumXRTrackingMode } from "../enum/EnumXRTrackingMode";
+import { XRTrackingMode } from "./XRTrackingMode";
+import { XRInputType } from "../input/XRInputType";
 export declare class XRPoseDriver extends Script {
-    source: EnumXRInputSource;
-    updateType: EnumXRTrackingMode;
-    private _xrManager;
+    type: XRInputType;
+    trackingMode: XRTrackingMode;
+    private _inputManager;
     onLateUpdate(): void;
     onAwake(): void;
 }

package/types/xr/component/XRTrackingMode.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Enum of XR tracking mode.
+ */
+export declare enum XRTrackingMode {
+    /** None */
+    None = 0,
+    /** Orientation only */
+    RotationOnly = 1,
+    /** Position only */
+    PositionOnly = 2,
+    /** Orientation and position */
+    RotationAndPosition = 3,
+    /** Auto ( RotationAndPosition ) */
+    Auto = 4
+}

package/types/xr/component/trackable/XRAnchor.d.ts

@@ -0,0 +1,4 @@
+import { IXRTrackedAnchor } from "@galacean/engine-design";
+import { XRTracked } from "./XRTracked";
+export declare class XRAnchor extends XRTracked<IXRTrackedAnchor> {
+}

package/types/xr/component/trackable/XRImage.d.ts

@@ -0,0 +1,6 @@
+import { IXRReferenceImage, IXRTrackedImage } from "@galacean/engine-design";
+import { XRTracked } from "./XRTracked";
+export declare class XRImage extends XRTracked<IXRTrackedImage> {
+    get referenceImage(): IXRReferenceImage;
+    get measuredWidthInMeters(): number;
+}

package/types/xr/component/trackable/XRPlane.d.ts

@@ -0,0 +1,7 @@
+import { IXRTrackedPlane } from "@galacean/engine-design";
+import { XRTracked } from "./XRTracked";
+import { Vector3 } from "@galacean/engine-math";
+export declare class XRPlane extends XRTracked<IXRTrackedPlane> {
+    get polygon(): readonly Vector3[];
+    get orientation(): "horizontal" | "vertical";
+}

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

@@ -0,0 +1,13 @@
+import { IXRTrackable } from "@galacean/engine-design";
+import { Component } from "../../../Component";
+import { XRTrackingState } from "../../feature/trackable/XRTrackingState";
+export declare abstract class XRTracked<T extends IXRTrackable> extends Component {
+    protected _platformData: T;
+    protected _destroyOnRemoval: boolean;
+    get destroyOnRemoval(): boolean;
+    set destroyOnRemoval(value: boolean);
+    get trackableId(): number;
+    get trackingState(): XRTrackingState;
+    get platformData(): T;
+    set platformData(value: T);
+}

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