@galacean/engine-xr-webxr 0.0.0-experimental-shaderlab.2

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@galacean/engine-xr-webxr",
+  "version": "0.0.0-experimental-shaderlab.2",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "license": "MIT",
+  "main": "dist/main.js",
+  "module": "dist/module.js",
+  "debug": "src/index.ts",
+  "browser": "dist/browser.js",
+  "types": "types/index.d.ts",
+  "umd": {
+    "name": "Galacean.WebXR",
+    "globals": {
+      "@galacean/engine": "Galacean"
+    }
+  },
+  "files": [
+    "dist/**/*",
+    "libs/**/*",
+    "types/**/*"
+  ],
+  "dependencies": {
+    "@galacean/engine-xr": "0.0.0-experimental-shaderlab.2"
+  },
+  "devDependencies": {
+    "@galacean/engine-math": "0.0.0-experimental-shaderlab.2",
+    "@galacean/engine-design": "0.0.0-experimental-shaderlab.2"
+  },
+  "peerDependencies": {},
+  "scripts": {
+    "b:types": "tsc"
+  }
+}

package/types/Util.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="webxr" />
+import { XRTrackedInputDevice } from "@galacean/engine-xr";
+export declare function parseXRMode(mode: number): XRSessionMode | null;
+export declare function getInputSource(inputSource: XRInputSource): XRTrackedInputDevice;
+export declare function viewToCamera(type: XREye): XRTrackedInputDevice;

package/types/WebXRDevice.d.ts

@@ -0,0 +1,13 @@
+import { IHardwareRenderer, IXRDevice } from "@galacean/engine-design";
+import { XRFeatureType, XRSessionMode } from "@galacean/engine-xr";
+import { WebXRSession } from "./WebXRSession";
+import { WebXRFeature } from "./feature/WebXRFeature";
+export declare class WebXRDevice implements IXRDevice {
+    isSupportedSessionMode(mode: XRSessionMode): Promise<void>;
+    isSupportedFeature(type: XRFeatureType): boolean;
+    createPlatformFeature(type: XRFeatureType, ...args: any[]): WebXRFeature;
+    requestSession(rhi: IHardwareRenderer, mode: XRSessionMode, platformFeatures: WebXRFeature[]): Promise<WebXRSession>;
+}
+type PlatformFeatureConstructor = new (...args: any[]) => WebXRFeature;
+export declare function registerXRPlatformFeature(type: XRFeatureType): (platformFeatureConstructor: PlatformFeatureConstructor) => void;
+export {};

package/types/WebXRFrame.d.ts

@@ -0,0 +1,9 @@
+import { IXRFrame, IXRInput } from "@galacean/engine-design";
+import { WebXRSession } from "./WebXRSession";
+export declare class WebXRFrame implements IXRFrame {
+    private _session;
+    updateInputs(inputs: IXRInput[]): void;
+    private _updateController;
+    private _updateCamera;
+    constructor(session: WebXRSession);
+}

package/types/WebXRSession.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="webxr" />
+import { IXRInputEvent, IXRSession } from "@galacean/engine-design";
+import { WebXRFrame } from "./WebXRFrame";
+export declare class WebXRSession implements IXRSession {
+    requestAnimationFrame: (callback: FrameRequestCallback) => number;
+    cancelAnimationFrame: (id: number) => void;
+    private _frame;
+    private _events;
+    private _screenPointers;
+    private _inputEventTypeMap;
+    private _targetRayModeMap;
+    get frame(): WebXRFrame;
+    get framebuffer(): WebGLFramebuffer;
+    get framebufferWidth(): number;
+    get framebufferHeight(): number;
+    get frameRate(): number;
+    get supportedFrameRates(): Float32Array;
+    get events(): IXRInputEvent[];
+    constructor(session: XRSession, layer: XRWebGLLayer, referenceSpace: XRReferenceSpace);
+    getFixedFoveation(): number;
+    setFixedFoveation(value: number): void;
+    start(): void;
+    stop(): void;
+    end(): Promise<void>;
+    setSessionExitCallBack(onSessionExitCallBack: () => void): void;
+    addEventListener(): void;
+    removeEventListener(): void;
+    resetEvents(): void;
+    private _onSessionExit;
+    private _onSessionEvent;
+}

package/types/feature/WebXRAnchorTracking.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="webxr" />
+import { IXRRequestAnchor, IXRTracked } from "@galacean/engine-design";
+import { WebXRFrame } from "../WebXRFrame";
+import { WebXRSession } from "../WebXRSession";
+import { WebXRTrackableFeature } from "./WebXRTrackableFeature";
+/**
+ * WebXR implementation of XRPlatformAnchorTracking.
+ */
+export declare class WebXRAnchorTracking extends WebXRTrackableFeature<IXRTracked, IWebXRRequestTrackingAnchor> {
+    checkAvailable(session: WebXRSession, frame: WebXRFrame, requestTrackings: IWebXRRequestTrackingAnchor[]): boolean;
+    getTrackedResult(session: WebXRSession, frame: WebXRFrame, requestTrackings: IWebXRRequestTrackingAnchor[]): void;
+    get canModifyRequestTrackingAfterInit(): boolean;
+    onDelRequestTracking(requestTracking: IWebXRRequestTrackingAnchor): void;
+    private _addAnchor;
+    private _updateTrackedAnchor;
+}
+interface IWebXRRequestTrackingAnchor extends IXRRequestAnchor {
+    xrAnchor: XRAnchor;
+}
+export {};

package/types/feature/WebXRFeature.d.ts

@@ -0,0 +1 @@
+export {};

package/types/feature/WebXRImageTracking.d.ts

@@ -0,0 +1,23 @@
+import { IXRReferenceImage, IXRRequestImage, IXRTrackedImage } from "@galacean/engine-design";
+import { WebXRFrame } from "../WebXRFrame";
+import { WebXRSession } from "../WebXRSession";
+import { WebXRTrackableFeature } from "./WebXRTrackableFeature";
+/**
+ * WebXR implementation of XRPlatformImageTracking.
+ * Note: each tracked image can appear at most once in the tracking results.
+ * If multiple copies of the same image exist in the user’s environment,
+ * the device can choose an arbitrary instance to report a pose,
+ * and this choice can change for future XRFrames.
+ */
+export declare class WebXRImageTracking extends WebXRTrackableFeature<IXRTrackedImage, IXRRequestImage> {
+    private _images;
+    private _trackingScoreStatus;
+    private _tempIdx;
+    private _tempArr;
+    constructor(images: IXRReferenceImage[]);
+    checkAvailable(session: WebXRSession, frame: WebXRFrame, requestTrackings: IXRRequestImage[]): boolean;
+    getTrackedResult(session: WebXRSession, frame: WebXRFrame, requestTrackings: IXRRequestImage[], generateTracked: () => IXRTrackedImage): void;
+    onAddRequestTracking(requestTracking: IXRRequestImage): void;
+    private _requestTrackingScore;
+    private _updateTrackedImage;
+}

package/types/feature/WebXRPlaneTracking.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="webxr" />
+import { IXRRequestPlane, IXRTrackedPlane } from "@galacean/engine-design";
+import { WebXRFrame } from "../WebXRFrame";
+import { WebXRSession } from "../WebXRSession";
+import { WebXRTrackableFeature } from "./WebXRTrackableFeature";
+/**
+ *  WebXR implementation of XRPlatformPlaneTracking.
+ */
+export declare class WebXRPlaneTracking extends WebXRTrackableFeature<IWebXRTrackedPlane, IXRRequestPlane> {
+    private _lastDetectedPlanes;
+    constructor(detectedMode: number);
+    checkAvailable(session: WebXRSession, frame: WebXRFrame, requestTrackings: IXRRequestPlane[]): boolean;
+    getTrackedResult(session: WebXRSession, frame: WebXRFrame, requestTrackings: IXRRequestPlane[], generateTracked: () => IWebXRTrackedPlane): void;
+    onAddRequestTracking(requestTracking: IXRRequestPlane): void;
+    private _updatePlane;
+}
+interface IWebXRTrackedPlane extends IXRTrackedPlane {
+    xrPlane?: XRPlane;
+    lastChangedTime?: number;
+}
+export {};

package/types/feature/WebXRTrackableFeature.d.ts

@@ -0,0 +1 @@
+export {};

package/types/index.d.ts

@@ -0,0 +1,4 @@
+import "./feature/WebXRAnchorTracking";
+import "./feature/WebXRImageTracking";
+import "./feature/WebXRPlaneTracking";
+export { WebXRDevice } from "./WebXRDevice";