@galacean/engine-xr 2.0.0-alpha.5 → 2.0.0-alpha.51

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@galacean/engine-xr",
-  "version": "2.0.0-alpha.5",
+  "version": "2.0.0-alpha.51",
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org"
@@ -11,8 +11,9 @@
   "license": "MIT",
   "main": "dist/main.js",
   "module": "dist/module.js",
+  "unpkg": "dist/browser.min.js",
+  "jsdelivr": "dist/browser.min.js",
   "debug": "src/index.ts",
-  "browser": "dist/browser.js",
   "types": "types/index.d.ts",
   "umd": {
     "name": "Galacean.XR",
@@ -26,11 +27,11 @@
     "types/**/*"
   ],
   "devDependencies": {
-    "@galacean/engine-design": "2.0.0-alpha.5",
-    "@galacean/engine": "2.0.0-alpha.5"
+    "@galacean/engine": "2.0.0-alpha.51",
+    "@galacean/engine-design": "2.0.0-alpha.51"
   },
   "peerDependencies": {
-    "@galacean/engine": "2.0.0-alpha.5"
+    "@galacean/engine": "2.0.0-alpha.51"
   },
   "scripts": {
     "b:types": "tsc"

package/types/XRManagerExtended.d.ts

@@ -1,13 +1,59 @@
-import { Entity } from "@galacean/engine";
+import { CameraClearFlags, CameraType, Engine, Entity, XRManager } from "@galacean/engine";
+import { IXRDevice } from "@galacean/engine-design";
 import { XRFeature } from "./feature/XRFeature";
+import { XRFeatureType } from "./feature/XRFeatureType";
 import { XRCameraManager } from "./feature/camera/XRCameraManager";
 import { XRInputManager } from "./input/XRInputManager";
 import { XRSessionManager } from "./session/XRSessionManager";
 import { XRSessionMode } from "./session/XRSessionMode";
-export interface IXRListener {
-    fn: (...args: any[]) => any;
-    destroyed?: boolean;
+/**
+ * @internal
+ */
+export declare class XRManagerExtended extends XRManager {
+    /** @internal */
+    static _featureMap: Map<TFeatureConstructor<XRFeature>, XRFeatureType>;
+    inputManager: XRInputManager;
+    sessionManager: XRSessionManager;
+    cameraManager: XRCameraManager;
+    /** @internal */
+    _platformDevice: IXRDevice;
+    private _features;
+    private _origin;
+    get features(): XRFeature[];
+    get origin(): Entity;
+    set origin(value: Entity);
+    isSupportedFeature<T extends XRFeature>(feature: TFeatureConstructor<T>): boolean;
+    addFeature<T extends new (xrManager: XRManagerExtended, ...args: any[]) => XRFeature>(type: T, ...args: TFeatureConstructorArguments<T>): InstanceType<T> | null;
+    getFeature<T extends XRFeature>(type: TFeatureConstructor<T>): T | undefined;
+    enterXR(sessionMode: XRSessionMode, autoRun?: boolean): Promise<void>;
+    exitXR(): Promise<void>;
+    _initialize(engine: Engine, xrDevice: IXRDevice): void;
+    _update(): void;
+    _destroy(): void;
+    _getRequestAnimationFrame(): (callback: FrameRequestCallback) => number;
+    _getCancelAnimationFrame(): (id: number) => void;
+    _getCameraIgnoreClearFlags(type: CameraType): CameraClearFlags;
+    /**
+     * @internal
+     */
+    _onSessionStop(): void;
+    /**
+     * @internal
+     */
+    _onSessionInit(): void;
+    /**
+     * @internal
+     */
+    _onSessionStart(): void;
+    /**
+     * @internal
+     */
+    _onSessionExit(): void;
 }
+/**
+ * @internal
+ */
+export declare function registerXRFeature<T extends XRFeature>(type: XRFeatureType): (feature: TFeatureConstructor<T>) => void;
 type TFeatureConstructor<T extends XRFeature> = new (xrManager: XRManagerExtended, ...args: any[]) => T;
 type TFeatureConstructorArguments<T extends new (xrManager: XRManagerExtended, ...args: any[]) => XRFeature> = T extends new (xrManager: XRManagerExtended, ...args: infer P) => XRFeature ? P : never;
 declare module "@galacean/engine" {
@@ -44,7 +90,7 @@ declare module "@galacean/engine" {
          * @param type - The type of the feature
          * @returns	The feature which match type
          */
-        getFeature<T extends XRFeature>(type: TFeatureConstructor<T>): T | null;
+        getFeature<T extends XRFeature>(type: TFeatureConstructor<T>): T | undefined;
         /**
          * Enter XR immersive mode, when you call this method, it will initialize and display the XR virtual world.
          * @param sessionMode - The mode of the session
@@ -57,6 +103,30 @@ declare module "@galacean/engine" {
          * @returns A promise that resolves if the XR virtual world is destroyed, otherwise rejects
          */
         exitXR(): Promise<void>;
+        /**
+         * @internal
+         */
+        _initialize(engine: Engine, xrDevice: IXRDevice): void;
+        /**
+         * @internal
+         */
+        _getRequestAnimationFrame(): (callback: FrameRequestCallback) => number;
+        /**
+         * @internal
+         */
+        _getCancelAnimationFrame(): (id: number) => void;
+        /**
+         * @internal
+         */
+        _getCameraIgnoreClearFlags(type: CameraType): CameraClearFlags;
+        /**
+         * @internal
+         */
+        _update(): void;
+        /**
+         * @internal
+         */
+        _destroy(): void;
     }
 }
 export {};

package/types/feature/XRFeature.d.ts

@@ -7,10 +7,48 @@ import { XRFeatureType } from "./XRFeatureType";
 export declare abstract class XRFeature<T extends IXRPlatformFeature = IXRPlatformFeature> {
     protected _xrManager: XRManagerExtended;
     protected _type: XRFeatureType;
+    /** @internal */
+    _platformFeature: T;
     protected _enabled: boolean;
     /**
      * Returns whether the feature is enabled.
      */
     get enabled(): boolean;
     set enabled(value: boolean);
+    /**
+     * @internal
+     */
+    constructor(_xrManager: XRManagerExtended, _type: XRFeatureType, ...args: any[]);
+    /**
+     * @internal
+     */
+    _onEnable(): void;
+    /**
+     * @internal
+     */
+    _onDisable(): void;
+    /**
+     * @internal
+     */
+    _onUpdate(): void;
+    /**
+     * @internal
+     */
+    _onSessionInit(): void;
+    /**
+     * @internal
+     */
+    _onSessionStart(): void;
+    /**
+     * @internal
+     */
+    _onSessionStop(): void;
+    /**
+     * @internal
+     */
+    _onSessionExit(): void;
+    /**
+     * @internal
+     */
+    _onDestroy(): void;
 }

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

@@ -1,4 +1,5 @@
-import { Camera } from "@galacean/engine";
+import { Camera, CameraClearFlags, CameraType } from "@galacean/engine";
+import { XRManagerExtended } from "../../XRManagerExtended";
 import { XRTrackedInputDevice } from "../../input/XRTrackedInputDevice";
 /**
  * The manager of XR camera.
@@ -6,10 +7,14 @@ import { XRTrackedInputDevice } from "../../input/XRTrackedInputDevice";
 export declare class XRCameraManager {
     private _xrManager;
     /**
-     * The fixed foveation of the camera.
+     * Fixed foveation, or `undefined` if unsupported by the active session.
      */
-    get fixedFoveation(): number;
+    get fixedFoveation(): number | undefined;
     set fixedFoveation(value: number);
+    /**
+     * @internal
+     */
+    constructor(_xrManager: XRManagerExtended);
     /**
      * Attach the camera to the specified input type(Camera, LeftCamera or RightCamera).
      * The camera entity need to be moved to the XROrigin entity.
@@ -22,5 +27,25 @@ export declare class XRCameraManager {
      * @param type - The input type
      * @returns The camera that was detached
      */
-    detachCamera(type: XRTrackedInputDevice.Camera | XRTrackedInputDevice.LeftCamera | XRTrackedInputDevice.RightCamera): Camera;
+    detachCamera(type: XRTrackedInputDevice.Camera | XRTrackedInputDevice.LeftCamera | XRTrackedInputDevice.RightCamera): Camera | null;
+    /**
+     * @internal
+     */
+    _onSessionStart(): void;
+    /**
+     * @internal
+     */
+    _onUpdate(): void;
+    /**
+     * @internal
+     */
+    _onSessionExit(): void;
+    /**
+     * @internal
+     */
+    _getIgnoreClearFlags(cameraType: CameraType): CameraClearFlags;
+    /**
+     * @internal
+     */
+    _onDestroy(): void;
 }

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

@@ -1 +1,11 @@
-export {};
+import { XRRequestTrackingState } from "./XRRequestTrackingState";
+import { XRTracked } from "./XRTracked";
+/**
+ * @internal
+ */
+export declare abstract class XRRequestTracking<T extends XRTracked> {
+    /** The status of the current request tracking. */
+    state: XRRequestTrackingState;
+    /** Tracked instances, make up from the tracking data returned by Session. */
+    tracked: T[];
+}

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

@@ -1,3 +1,4 @@
+import { Signal } from "@galacean/engine";
 import { IXRTrackablePlatformFeature } from "@galacean/engine-design";
 import { XRTrackingState } from "../../input/XRTrackingState";
 import { XRFeature } from "../XRFeature";
@@ -8,28 +9,29 @@ import { XRTracked } from "./XRTracked";
  */
 export declare abstract class XRTrackableFeature<T extends XRTracked = XRTracked, K extends XRRequestTracking<T> = XRRequestTracking<T>> extends XRFeature<IXRTrackablePlatformFeature<T, K>> {
     protected static _uuid: number;
+    /** Signal emitted when tracked objects change. */
+    readonly onChanged: Signal<[readonly T[], readonly T[], readonly T[]]>;
     protected _requestTrackings: K[];
     protected _tracked: T[];
     protected _added: T[];
     protected _updated: T[];
     protected _removed: T[];
     protected _statusSnapshot: Record<number, XRTrackingState>;
-    private _listeners;
+    _onUpdate(): void;
+    _onSessionStop(): void;
+    _onSessionExit(): void;
+    protected _addRequestTracking(requestTracking: K): void;
+    protected _removeRequestTracking(requestTracking: K): void;
+    protected _removeAllRequestTrackings(): void;
+    protected abstract _generateTracked(): T;
     /**
      * Add a listening function for tracked object changes.
-     * @param listener - The listening function
+     * @deprecated Use `onChanged.on(listener)` instead.
      */
     addChangedListener(listener: (added: readonly T[], updated: readonly T[], removed: readonly T[]) => void): void;
     /**
      * Remove a listening function of tracked object changes.
-     * @param listener - The listening function
+     * @deprecated Use `onChanged.off(listener)` instead.
      */
     removeChangedListener(listener: (added: readonly T[], updated: readonly T[], removed: readonly T[]) => void): void;
-    _onUpdate(): void;
-    _onSessionStop(): void;
-    _onSessionExit(): void;
-    protected _addRequestTracking(requestTracking: K): void;
-    protected _removeRequestTracking(requestTracking: K): void;
-    protected _removeAllRequestTrackings(): void;
-    protected abstract _generateTracked(): T;
 }

package/types/input/XRCamera.d.ts

@@ -1,5 +1,5 @@
 import { IXRCamera } from "@galacean/engine-design";
-import { Matrix, Rect } from "@galacean/engine";
+import { Matrix, Rect, Camera } from "@galacean/engine";
 import { XRPose } from "../XRPose";
 import { XRInput } from "./XRInput";
 /**
@@ -12,4 +12,6 @@ export declare class XRCamera extends XRInput implements IXRCamera {
     viewport: Rect;
     /** The projection matrix of the camera. */
     projectionMatrix: Matrix;
+    /** @internal */
+    _camera: Camera | null;
 }

package/types/input/XRInput.d.ts

@@ -5,4 +5,8 @@ export declare class XRInput implements IXRInput {
     type: XRTrackedInputDevice;
     /** The tracking state of xr input. */
     trackingState: XRTrackingState;
+    /**
+     * @internal
+     */
+    constructor(type: XRTrackedInputDevice);
 }

package/types/input/XRInputManager.d.ts

@@ -1,3 +1,7 @@
+import { Engine, Signal } from "@galacean/engine";
+import { XRManagerExtended } from "../XRManagerExtended";
+import { XRCamera } from "./XRCamera";
+import { XRController } from "./XRController";
 import { XRInput } from "./XRInput";
 import { XRTrackedInputDevice } from "./XRTrackedInputDevice";
 /**
@@ -6,27 +10,44 @@ import { XRTrackedInputDevice } from "./XRTrackedInputDevice";
 export declare class XRInputManager {
     private _xrManager;
     private _engine;
+    /** Signal emitted when tracked devices change. */
+    readonly onTrackedDeviceChanged: Signal<[readonly XRInput[], readonly XRInput[]]>;
+    /** @internal */
+    _cameras: XRCamera[];
+    /** @internal */
+    _controllers: XRController[];
     private _added;
     private _removed;
     private _trackedDevices;
     private _statusSnapshot;
-    private _listeners;
+    /**
+     * @internal
+     */
+    constructor(_xrManager: XRManagerExtended, _engine: Engine);
     /**
      * Returns the tracked device instance.
      * @param type - The tracked input device type
      * @returns The input instance
      */
     getTrackedDevice<T extends XRInput>(type: XRTrackedInputDevice): T;
+    /**
+     * @internal
+     */
+    _onUpdate(): void;
+    /**
+     * @internal
+     */
+    _onDestroy(): void;
+    private _handleEvent;
+    private _makeUpPointerEvent;
     /**
      * Add a listener for tracked device changes.
-     * @param listener - The listener to add
+     * @deprecated Use `onTrackedDeviceChanged.on(listener)` instead.
      */
     addTrackedDeviceChangedListener(listener: (added: readonly XRInput[], removed: readonly XRInput[]) => void): void;
     /**
      * Remove a listener of tracked device changes.
-     * @param listener - The listener to remove
+     * @deprecated Use `onTrackedDeviceChanged.off(listener)` instead.
      */
     removeTrackedDeviceChangedListener(listener: (added: readonly XRInput[], removed: readonly XRInput[]) => void): void;
-    private _handleEvent;
-    private _makeUpPointerEvent;
 }

package/types/session/XRSessionManager.d.ts

@@ -1,3 +1,7 @@
+import { Engine, Signal } from "@galacean/engine";
+import { IXRSession } from "@galacean/engine-design";
+import { XRManagerExtended } from "../XRManagerExtended";
+import { XRFeature } from "../feature/XRFeature";
 import { XRSessionMode } from "./XRSessionMode";
 import { XRSessionState } from "./XRSessionState";
 /**
@@ -6,12 +10,15 @@ import { XRSessionState } from "./XRSessionState";
 export declare class XRSessionManager {
     private _xrManager;
     private _engine;
+    /** Signal emitted when session state changes. */
+    readonly onStateChanged: Signal<[XRSessionState]>;
+    /** @internal */
+    _platformSession: IXRSession | null;
     private _mode;
     private _state;
     private _rhi;
     private _raf;
     private _caf;
-    private _listeners;
     /**
      * The current session mode( AR or VR ).
      */
@@ -21,13 +28,17 @@ export declare class XRSessionManager {
      */
     get state(): XRSessionState;
     /**
-     * Return a list of supported frame rates.(only available in-session)
+     * Supported frame rates, or `undefined` if unsupported. Only available in-session.
      */
-    get supportedFrameRate(): Float32Array;
+    get supportedFrameRate(): Float32Array | undefined;
     /**
-     * Return the current frame rate as reported by the device.
+     * Current frame rate, or `undefined` if unsupported. Only available in-session.
      */
-    get frameRate(): number;
+    get frameRate(): number | undefined;
+    /**
+     * @internal
+     */
+    constructor(_xrManager: XRManagerExtended, _engine: Engine);
     /**
      * Check if the specified mode is supported.
      * @param mode - The mode to check
@@ -42,15 +53,43 @@ export declare class XRSessionManager {
      * Stop the session.
      */
     stop(): void;
+    /**
+     * @internal
+     */
+    _setState(value: XRSessionState): void;
+    /**
+     * @internal
+     */
+    _initialize(mode: XRSessionMode, features: XRFeature[]): Promise<void>;
+    /**
+     * @internal
+     */
+    _onUpdate(): void;
+    /**
+     * @internal
+     */
+    _getRequestAnimationFrame(): (callback: FrameRequestCallback) => number;
+    /**
+     * @internal
+     */
+    _getCancelAnimationFrame(): (id: number) => void;
+    /**
+     * @internal
+     */
+    _exit(): Promise<void>;
+    private _onSessionExit;
+    /**
+     * @internal
+     */
+    _onDestroy(): void;
     /**
      * Add a listening function for session state changes.
-     * @param listener - The listening function
+     * @deprecated Use `onStateChanged.on(listener)` instead.
      */
     addStateChangedListener(listener: (state: XRSessionState) => void): void;
     /**
      * Remove a listening function of session state changes.
-     * @param listener - The listening function
+     * @deprecated Use `onStateChanged.off(listener)` instead.
      */
     removeStateChangedListener(listener: (state: XRSessionState) => void): void;
-    private _onSessionExit;
 }