iwer 1.1.0 → 2.0.0

package/build/iwer.js

@@ -1910,12 +1910,16 @@
           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}.`);
@@ -2920,6 +2924,17 @@
                       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();
                   }
@@ -3008,15 +3023,21 @@
               },
               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;
@@ -3026,15 +3047,21 @@
               },
               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;
@@ -3044,7 +3071,7 @@
               },
               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;
@@ -3278,7 +3305,7 @@
               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 {
@@ -4593,7 +4620,7 @@
       }
   }
 
-  const VERSION = "1.1.0";
+  const VERSION = "2.0.0";
 
   /**
    * Copyright (c) Meta Platforms, Inc. and affiliates.
@@ -4621,28 +4648,9 @@
   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'));
@@ -4674,6 +4682,54 @@
                       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);
           });
@@ -4717,6 +4773,10 @@
       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
@@ -4724,6 +4784,7 @@
   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 = {
@@ -4809,12 +4870,27 @@
                   // 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);
                   }
@@ -4823,16 +4899,27 @@
               },
               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'));
                   }
               },
@@ -4917,8 +5004,11 @@
           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;
@@ -5014,10 +5104,32 @@
       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);
@@ -5053,6 +5165,12 @@
           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;
+      }
   }
 
   /**