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

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

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

@@ -0,0 +1,58 @@
+import { IXRInput, IXRSession } from "@galacean/engine-design";
+import { Engine } from "../../Engine";
+import { XRController } from "./XRController";
+import { XRInputType } from "./XRInputType";
+import { UpdateFlagManager } from "../../UpdateFlagManager";
+import { XRTrackingState } from "./XRTrackingState";
+import { XRTrackedUpdateFlag } from "./XRTrackedUpdateFlag";
+/**
+ * The manager of XR input.
+ */
+export declare class XRInputManager {
+    protected _engine: Engine;
+    protected _session: IXRSession;
+    protected _inputs: IXRInput[];
+    protected _controllers: XRController[];
+    protected _added: IXRInput[];
+    protected _updated: IXRInput[];
+    protected _removed: IXRInput[];
+    protected _statusSnapshot: XRTrackingState[];
+    protected _trackingUpdate: UpdateFlagManager;
+    /**
+     * Returns the input instance.
+     * @param type - The input type
+     * @returns The input instance
+     */
+    getInput<T extends IXRInput>(type: XRInputType): T;
+    /**
+     * Add a listener to the input update event.
+     * @param listener - The listener to add
+     */
+    addListener(listener: (type: XRTrackedUpdateFlag, param: readonly IXRInput[]) => any): void;
+    /**
+     * Remove a listener from the input update event.
+     * @param listener - The listener to remove
+     */
+    removeListener(listener: (type: XRTrackedUpdateFlag, param: readonly IXRInput[]) => any): void;
+    /**
+     * Returns whether the button is pressed.
+     * @param button - The button to check
+     * @returns Whether the button is pressed
+     */
+    isButtonDown(button: number, out: XRController[]): XRController[];
+    /**
+     * Returns whether the button is lifted.
+     * @param button - The button to check
+     * @returns Whether the button is lifted
+     */
+    isButtonUp(button: number, out: XRController[]): XRController[];
+    /**
+     * Returns whether the button is held down.
+     * @param button - The button to check
+     * @returns Whether the button is held down
+     */
+    isButtonHeldDown(button: number, out: XRController[]): XRController[];
+    constructor(engine: Engine);
+    private _handleEvent;
+    private _makeUpPointerEvent;
+}

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

@@ -0,0 +1,23 @@
+/**
+ * Enum for XR input type.
+ */
+export declare enum XRInputType {
+    /** Controller */
+    Controller = 0,
+    /** Left controller */
+    LeftController = 1,
+    /** Right controller */
+    RightController = 2,
+    /** Camera */
+    Camera = 3,
+    /** Left camera */
+    LeftCamera = 4,
+    /** Right camera */
+    RightCamera = 5,
+    /** Head */
+    LeftHand = 6,
+    /** Right hand */
+    RightHand = 7,
+    /** Length of input type */
+    Length = 8
+}

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

@@ -0,0 +1,12 @@
+/**
+ *  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.
+ */
+export declare enum XRTargetRayMode {
+    /** Eye */
+    Gaze = 0,
+    /** Controller */
+    TrackedPointer = 1,
+    /** Game pad */
+    Screen = 2
+}

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

@@ -0,0 +1,76 @@
+import { IXRFrame, IXRSession, IXRFeatureDescriptor } from "@galacean/engine-design";
+import { Engine } from "../../Engine";
+import { XRSessionType } from "./XRSessionType";
+import { XRSessionState } from "./XRSessionState";
+type TXRSessionStateChangeListener = (from: XRSessionState, to: XRSessionState) => void;
+export declare class XRSessionManager {
+    protected _engine: Engine;
+    protected _session: IXRSession;
+    protected _frame: IXRFrame;
+    protected _state: XRSessionState;
+    private _rhi;
+    private _listeners;
+    /**
+     * Return the current session state.
+     */
+    get state(): XRSessionState;
+    /**
+     * Return the current session.
+     */
+    get session(): IXRSession;
+    /**
+     * Return a list of supported frame rates.(only available in-session)
+     */
+    get supportedFrameRate(): Float32Array;
+    /**
+     * Return the current frame rate as reported by the device.
+     */
+    get frameRate(): number;
+    /**
+     * Returns requestAnimationFrame in XR.
+     */
+    get requestAnimationFrame(): (callback: FrameRequestCallback) => number;
+    /**
+     * Returns cancelAnimationFrame in XR.
+     */
+    get cancelAnimationFrame(): (id: number) => void;
+    /**
+     * Initialize the session.
+     * @param mode - The mode of the session
+     * @param requestFeatures - The requested features
+     * @returns The promise of the session
+     */
+    initialize(mode: XRSessionType, requestFeatures: IXRFeatureDescriptor[]): Promise<IXRSession>;
+    /**
+     * Start the session.
+     * @returns The promise of the session
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the session.
+     * @returns The promise of the session
+     */
+    stop(): Promise<void>;
+    /**
+     * Destroy the session.
+     * @returns The promise of the session
+     */
+    destroy(): Promise<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);
+    private _dispatchSessionStateChange;
+}
+export {};

package/types/xr/session/XRSessionState.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The state of an XRSession.
+ */
+export declare enum XRSessionState {
+    /** Not initialized. */
+    None = 0,
+    /** Initialized but not started. */
+    Initialized = 1,
+    /** Running. */
+    Running = 2,
+    /** Paused. */
+    Paused = 3
+}

package/types/xr/session/XRSessionType.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The type of XR session.
+ */
+export declare enum XRSessionType {
+    AR = 0,
+    VR = 1
+}