iwer 1.1.0 → 2.0.0

package/build/iwer.module.js

@@ -1904,12 +1904,16 @@ class XRController extends XRTrackedInput {
         const inputSource = new XRInputSource(handedness, XRTargetRayMode.TrackedPointer, profiles, targetRaySpace, new Gamepad(controllerConfig.layout[handedness].gamepad), gripSpace);
         super(inputSource);
         this[P_CONTROLLER] = {
+            profileId: controllerConfig.profileId,
             gamepadConfig: controllerConfig.layout[handedness].gamepad,
         };
     }
     get gamepadConfig() {
         return this[P_CONTROLLER].gamepadConfig;
     }
+    get profileId() {
+        return this[P_CONTROLLER].profileId;
+    }
     updateButtonValue(id, value) {
         if (value > 1 || value < 0) {
             console.warn(`Out-of-range value ${value} provided for button ${id}.`);
@@ -2914,6 +2918,17 @@ class XRSession extends EventTarget {
                     perspective(this[P_SESSION].projectionMatrices[XREye.None], this[P_SESSION].renderState.inlineVerticalFieldOfView, aspect, depthNear, depthFar);
                 }
                 const frame = new XRFrame(this, this[P_SESSION].frameHandle, true, true, performance.now());
+                const time = performance.now();
+                const devui = this[P_SESSION].device[P_DEVICE].devui;
+                if (devui) {
+                    devui.render(time);
+                }
+                if (this[P_SESSION].mode === 'immersive-ar') {
+                    const sem = this[P_SESSION].device[P_DEVICE].sem;
+                    if (sem) {
+                        sem.render(time);
+                    }
+                }
                 if (this[P_SESSION].enabledFeatures.includes('anchors')) {
                     this[P_SESSION].updateTrackedAnchors();
                 }
@@ -3002,15 +3017,21 @@ class XRSession extends EventTarget {
             },
             trackedPlanes: new Map(),
             updateTrackedPlanes: (frame) => {
-                const sem = this[P_SESSION].device[P_DEVICE].syntheticEnvironmentModule;
+                const sem = this[P_SESSION].device[P_DEVICE].sem;
                 if (!sem) {
                     return;
                 }
+                const trackedPlanes = Array.from(this[P_SESSION].trackedPlanes.keys());
+                trackedPlanes.forEach((plane) => {
+                    if (!sem.trackedPlanes.has(plane)) {
+                        this[P_SESSION].trackedPlanes.delete(plane);
+                    }
+                });
                 sem.trackedPlanes.forEach((plane) => {
                     let xrPlane = this[P_SESSION].trackedPlanes.get(plane);
                     if (!xrPlane) {
                         const planeSpace = new XRSpace(this[P_SESSION].device[P_DEVICE].globalSpace, plane.transform.matrix);
-                        xrPlane = new XRPlane(plane, planeSpace, plane.polygon);
+                        xrPlane = new XRPlane(plane, planeSpace, plane.polygon, plane.semanticLabel);
                         this[P_SESSION].trackedPlanes.set(plane, xrPlane);
                     }
                     xrPlane[P_PLANE].lastChangedTime = frame.predictedDisplayTime;
@@ -3020,15 +3041,21 @@ class XRSession extends EventTarget {
             },
             trackedMeshes: new Map(),
             updateTrackedMeshes: (frame) => {
-                const sem = this[P_SESSION].device[P_DEVICE].syntheticEnvironmentModule;
+                const sem = this[P_SESSION].device[P_DEVICE].sem;
                 if (!sem) {
                     return;
                 }
+                const trackedMeshes = Array.from(this[P_SESSION].trackedMeshes.keys());
+                trackedMeshes.forEach((mesh) => {
+                    if (!sem.trackedMeshes.has(mesh)) {
+                        this[P_SESSION].trackedMeshes.delete(mesh);
+                    }
+                });
                 sem.trackedMeshes.forEach((mesh) => {
                     let xrMesh = this[P_SESSION].trackedMeshes.get(mesh);
                     if (!xrMesh) {
                         const meshSpace = new XRSpace(this[P_SESSION].device[P_DEVICE].globalSpace, mesh.transform.matrix);
-                        xrMesh = new XRMesh(mesh, meshSpace, mesh.vertices, mesh.indices);
+                        xrMesh = new XRMesh(mesh, meshSpace, mesh.vertices, mesh.indices, mesh.semanticLabel);
                         this[P_SESSION].trackedMeshes.set(mesh, xrMesh);
                     }
                     xrMesh[P_MESH].lastChangedTime = frame.predictedDisplayTime;
@@ -3038,7 +3065,7 @@ class XRSession extends EventTarget {
             },
             hitTestSources: new Set(),
             computeHitTestResults: (frame) => {
-                const sem = this[P_SESSION].device[P_DEVICE].syntheticEnvironmentModule;
+                const sem = this[P_SESSION].device[P_DEVICE].sem;
                 if (!sem)
                     return;
                 const globalSpace = this[P_SESSION].device[P_DEVICE].globalSpace;
@@ -3272,7 +3299,7 @@ class XRSession extends EventTarget {
             else if (this[P_SESSION].ended) {
                 reject(new DOMException('XRSession has already ended.', 'InvalidStateError'));
             }
-            else if (!this[P_SESSION].device[P_DEVICE].syntheticEnvironmentModule) {
+            else if (!this[P_SESSION].device[P_DEVICE].sem) {
                 reject(new DOMException('Synthethic Environment Module required for emulating hit-test', 'OperationError'));
             }
             else {
@@ -4587,7 +4614,7 @@ class ActionPlayer {
     }
 }
 
-const VERSION = "1.1.0";
+const VERSION = "2.0.0";
 
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
@@ -4615,28 +4642,9 @@ class XRReferenceSpaceEvent extends Event {
 class XRSystem extends EventTarget {
     constructor(device) {
         super();
-        this[P_SYSTEM] = { device };
-        // Initialize device change monitoring here if applicable
-    }
-    isSessionSupported(mode) {
-        return new Promise((resolve, _reject) => {
-            if (mode === 'inline') {
-                resolve(true);
-            }
-            else {
-                // Check for spatial tracking permission if necessary
-                resolve(this[P_SYSTEM].device.supportedSessionModes.includes(mode));
-            }
-        });
-    }
-    requestSession(mode, options = {}) {
-        return new Promise((resolve, reject) => {
-            this.isSessionSupported(mode)
-                .then((isSupported) => {
-                if (!isSupported) {
-                    reject(new DOMException('The requested XRSession mode is not supported.', 'NotSupportedError'));
-                    return;
-                }
+        this[P_SYSTEM] = {
+            device,
+            grantSession: ({ resolve, reject, mode, options }) => {
                 // Check for active sessions and other constraints here
                 if (this[P_SYSTEM].activeSession) {
                     reject(new DOMException('An active XRSession already exists.', 'InvalidStateError'));
@@ -4668,6 +4676,54 @@ class XRSystem extends EventTarget {
                     this[P_SYSTEM].activeSession = undefined;
                 });
                 resolve(session);
+            },
+        };
+        // Initialize device change monitoring here if applicable
+    }
+    isSessionSupported(mode) {
+        return new Promise((resolve, _reject) => {
+            if (mode === 'inline') {
+                resolve(true);
+            }
+            else {
+                // Check for spatial tracking permission if necessary
+                resolve(this[P_SYSTEM].device.supportedSessionModes.includes(mode));
+            }
+        });
+    }
+    requestSession(mode, options = {}) {
+        return new Promise((resolve, reject) => {
+            this.isSessionSupported(mode)
+                .then((isSupported) => {
+                if (!isSupported) {
+                    reject(new DOMException('The requested XRSession mode is not supported.', 'NotSupportedError'));
+                    return;
+                }
+                const sessionGrantConfig = {
+                    resolve,
+                    reject,
+                    mode,
+                    options,
+                };
+                this[P_SYSTEM].grantSession(sessionGrantConfig);
+            })
+                .catch(reject);
+        });
+    }
+    offerSession(mode, options = {}) {
+        return new Promise((resolve, reject) => {
+            this.isSessionSupported(mode)
+                .then((isSupported) => {
+                if (!isSupported) {
+                    reject(new DOMException('The requested XRSession mode is not supported.', 'NotSupportedError'));
+                    return;
+                }
+                this[P_SYSTEM].offeredSessionConfig = {
+                    resolve,
+                    reject,
+                    mode,
+                    options,
+                };
             })
                 .catch(reject);
         });
@@ -4711,6 +4767,10 @@ const DEFAULTS = {
     headsetQuaternion: new Quaternion(),
     stereoEnabled: false,
 };
+const Z_INDEX_SEM_CANVAS = 1;
+const Z_INDEX_APP_CANVAS = 2;
+const Z_INDEX_DEVUI_CANVAS = 3;
+const Z_INDEX_DEVUI_CONTAINER = 4;
 /**
  * XRDevice is not a standard API class outlined in the WebXR Device API Specifications
  * Instead, it serves as an user-facing interface to control the emulated XR Device
@@ -4718,6 +4778,7 @@ const DEFAULTS = {
 class XRDevice {
     constructor(deviceConfig, deviceOptions = {}) {
         var _a, _b, _c, _d, _e, _f;
+        this.version = VERSION;
         const globalSpace = new GlobalSpace();
         const viewerSpace = new XRReferenceSpace(XRReferenceSpaceType.Viewer, globalSpace);
         const viewSpaces = {
@@ -4803,12 +4864,27 @@ class XRDevice {
                 // backup canvas data
                 const canvas = baseLayer.context.canvas;
                 if (canvas.parentElement !== this[P_DEVICE].canvasContainer) {
+                    const devui = this[P_DEVICE].devui;
+                    if (devui) {
+                        const { devUICanvas, devUIContainer } = devui;
+                        devUICanvas.style.zIndex = Z_INDEX_DEVUI_CANVAS.toString();
+                        devUIContainer.style.zIndex = Z_INDEX_DEVUI_CONTAINER.toString();
+                        this[P_DEVICE].canvasContainer.appendChild(devui.devUICanvas);
+                        this[P_DEVICE].canvasContainer.appendChild(devui.devUIContainer);
+                    }
+                    const sem = this[P_DEVICE].sem;
+                    if (sem) {
+                        sem.environmentCanvas.style.zIndex = Z_INDEX_SEM_CANVAS.toString();
+                        this[P_DEVICE].canvasContainer.appendChild(sem.environmentCanvas);
+                    }
                     this[P_DEVICE].canvasData = {
                         canvas,
                         parent: canvas.parentElement,
                         width: canvas.width,
                         height: canvas.height,
+                        zIndex: canvas.style.zIndex,
                     };
+                    canvas.style.zIndex = Z_INDEX_APP_CANVAS.toString();
                     this[P_DEVICE].canvasContainer.appendChild(canvas);
                     document.body.appendChild(this[P_DEVICE].canvasContainer);
                 }
@@ -4817,16 +4893,27 @@ class XRDevice {
             },
             onSessionEnd: () => {
                 if (this[P_DEVICE].canvasData) {
-                    const { canvas, parent, width, height } = this[P_DEVICE].canvasData;
+                    const { canvas, parent, width, height, zIndex } = this[P_DEVICE].canvasData;
                     canvas.width = width;
                     canvas.height = height;
+                    canvas.style.zIndex = zIndex;
                     if (parent) {
                         parent.appendChild(canvas);
                     }
                     else {
                         this[P_DEVICE].canvasContainer.removeChild(canvas);
                     }
+                    const devui = this[P_DEVICE].devui;
+                    if (devui) {
+                        this[P_DEVICE].canvasContainer.removeChild(devui.devUICanvas);
+                        this[P_DEVICE].canvasContainer.removeChild(devui.devUIContainer);
+                    }
+                    const sem = this[P_DEVICE].sem;
+                    if (sem) {
+                        this[P_DEVICE].canvasContainer.removeChild(sem.environmentCanvas);
+                    }
                     document.body.removeChild(this[P_DEVICE].canvasContainer);
+                    this[P_DEVICE].canvasData = undefined;
                     window.dispatchEvent(new Event('resize'));
                 }
             },
@@ -4911,8 +4998,11 @@ class XRDevice {
         globalObject['XRInputSourcesChangeEvent'] = XRInputSourcesChangeEvent;
         globalObject['XRReferenceSpaceEvent'] = XRReferenceSpaceEvent;
     }
-    installSyntheticEnvironmentModule(sem) {
-        this[P_DEVICE].syntheticEnvironmentModule = sem;
+    installDevUI(devUIConstructor) {
+        this[P_DEVICE].devui = new devUIConstructor(this);
+    }
+    installSEM(semConstructor) {
+        this[P_DEVICE].sem = new semConstructor(this);
     }
     get supportedSessionModes() {
         return this[P_DEVICE].supportedSessionModes;
@@ -5008,10 +5098,32 @@ class XRDevice {
     get canvasContainer() {
         return this[P_DEVICE].canvasContainer;
     }
+    get canvasDimensions() {
+        if (this[P_DEVICE].canvasData) {
+            const { width, height } = this[P_DEVICE].canvasData.canvas;
+            return { width, height };
+        }
+        return;
+    }
     get activeSession() {
         var _a;
         return (_a = this[P_DEVICE].xrSystem) === null || _a === void 0 ? void 0 : _a[P_SYSTEM].activeSession;
     }
+    get sessionOffered() {
+        var _a;
+        return Boolean((_a = this[P_DEVICE].xrSystem) === null || _a === void 0 ? void 0 : _a[P_SYSTEM].offeredSessionConfig);
+    }
+    get name() {
+        return this[P_DEVICE].name;
+    }
+    grantOfferedSession() {
+        var _a;
+        const pSystem = (_a = this[P_DEVICE].xrSystem) === null || _a === void 0 ? void 0 : _a[P_SYSTEM];
+        if (pSystem && pSystem.offeredSessionConfig) {
+            pSystem.grantSession(pSystem.offeredSessionConfig);
+            pSystem.offeredSessionConfig = undefined;
+        }
+    }
     recenter() {
         const deltaVec = new Vector3(-this.position.x, 0, -this.position.z);
         const forward = new Vector3(0, 0, -1).applyQuaternion(this.quaternion);
@@ -5047,6 +5159,12 @@ class XRDevice {
         this[P_DEVICE].actionPlayer = new ActionPlayer(refSpace, recording, this[P_DEVICE].ipd);
         return this[P_DEVICE].actionPlayer;
     }
+    get devui() {
+        return this[P_DEVICE].devui;
+    }
+    get sem() {
+        return this[P_DEVICE].sem;
+    }
 }
 
 /**