three-stdlib 2.22.7 → 2.22.8

package/dist/webxr/VRButton.mjs

@@ -0,0 +1,111 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const _VRButton = class {
+  static createButton(renderer, sessionInit = {}) {
+    const button = document.createElement("button");
+    function showEnterVR() {
+      let currentSession = null;
+      async function onSessionStarted(session) {
+        session.addEventListener("end", onSessionEnded);
+        await renderer.xr.setSession(session);
+        button.textContent = "EXIT VR";
+        currentSession = session;
+      }
+      function onSessionEnded() {
+        currentSession.removeEventListener("end", onSessionEnded);
+        button.textContent = "ENTER VR";
+        currentSession = null;
+      }
+      button.style.display = "";
+      button.style.cursor = "pointer";
+      button.style.left = "calc(50% - 50px)";
+      button.style.width = "100px";
+      button.textContent = "ENTER VR";
+      button.onmouseenter = () => {
+        button.style.opacity = "1.0";
+      };
+      button.onmouseleave = () => {
+        button.style.opacity = "0.5";
+      };
+      button.onclick = () => {
+        var _a;
+        if (currentSession === null) {
+          const optionalFeatures = [sessionInit.optionalFeatures, "local-floor", "bounded-floor", "hand-tracking"].flat().filter(Boolean);
+          (_a = navigator.xr) == null ? void 0 : _a.requestSession("immersive-vr", { ...sessionInit, optionalFeatures }).then(onSessionStarted);
+        } else {
+          currentSession.end();
+        }
+      };
+    }
+    function disableButton() {
+      button.style.display = "";
+      button.style.cursor = "auto";
+      button.style.left = "calc(50% - 75px)";
+      button.style.width = "150px";
+      button.onmouseenter = null;
+      button.onmouseleave = null;
+      button.onclick = null;
+    }
+    function showWebXRNotFound() {
+      disableButton();
+      button.textContent = "VR NOT SUPPORTED";
+    }
+    function stylizeElement(element) {
+      element.style.position = "absolute";
+      element.style.bottom = "20px";
+      element.style.padding = "12px 6px";
+      element.style.border = "1px solid #fff";
+      element.style.borderRadius = "4px";
+      element.style.background = "rgba(0,0,0,0.1)";
+      element.style.color = "#fff";
+      element.style.font = "normal 13px sans-serif";
+      element.style.textAlign = "center";
+      element.style.opacity = "0.5";
+      element.style.outline = "none";
+      element.style.zIndex = "999";
+    }
+    if ("xr" in navigator) {
+      stylizeElement(button);
+      button.id = "VRButton";
+      button.style.display = "none";
+      navigator.xr.isSessionSupported("immersive-vr").then((supported) => {
+        supported ? showEnterVR() : showWebXRNotFound();
+        if (supported && _VRButton.xrSessionIsGranted) {
+          button.click();
+        }
+      });
+      return button;
+    } else {
+      const message = document.createElement("a");
+      if (window.isSecureContext === false) {
+        message.href = document.location.href.replace(/^http:/, "https:");
+        message.innerHTML = "WEBXR NEEDS HTTPS";
+      } else {
+        message.href = "https://immersiveweb.dev/";
+        message.innerHTML = "WEBXR NOT AVAILABLE";
+      }
+      message.style.left = "calc(50% - 90px)";
+      message.style.width = "180px";
+      message.style.textDecoration = "none";
+      stylizeElement(message);
+      return message;
+    }
+  }
+  static registerSessionGrantedListener() {
+    if ("xr" in navigator) {
+      ;
+      navigator.xr.addEventListener("sessiongranted", () => {
+        _VRButton.xrSessionIsGranted = true;
+      });
+    }
+  }
+};
+let VRButton = _VRButton;
+__publicField(VRButton, "xrSessionIsGranted", false);
+export {
+  VRButton
+};

package/dist/webxr/XRControllerModelFactory.d.ts

@@ -0,0 +1,23 @@
+import { Object3D } from 'three';
+import type { Texture, Group } from 'three';
+import { GLTFLoader } from '../loaders/GLTFLoader';
+import { MotionController } from '../libs/MotionControllers';
+declare class XRControllerModel extends Object3D {
+    envMap: Texture | null;
+    motionController: MotionController | null;
+    constructor();
+    setEnvironmentMap(envMap: Texture): XRControllerModel;
+    /**
+     * Polls data from the XRInputSource and updates the model's components to match
+     * the real world data
+     */
+    updateMatrixWorld(force: boolean): void;
+}
+declare class XRControllerModelFactory {
+    gltfLoader: GLTFLoader;
+    path: string;
+    private _assetCache;
+    constructor(gltfLoader?: GLTFLoader);
+    createControllerModel(controller: Group): XRControllerModel;
+}
+export { XRControllerModelFactory };

package/dist/webxr/XRControllerModelFactory.js

@@ -0,0 +1,174 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+const GLTFLoader = require("../loaders/GLTFLoader.js");
+const MotionControllers = require("../libs/MotionControllers.js");
+const DEFAULT_PROFILES_PATH = "https://cdn.jsdelivr.net/npm/@webxr-input-profiles/assets@1.0/dist/profiles";
+const DEFAULT_PROFILE = "generic-trigger";
+const applyEnvironmentMap = (envMap, obj) => {
+  obj.traverse((child) => {
+    if (child instanceof THREE.Mesh && "envMap" in child.material) {
+      child.material.envMap = envMap;
+      child.material.needsUpdate = true;
+    }
+  });
+};
+class XRControllerModel extends THREE.Object3D {
+  constructor() {
+    super();
+    __publicField(this, "envMap");
+    __publicField(this, "motionController");
+    this.motionController = null;
+    this.envMap = null;
+  }
+  setEnvironmentMap(envMap) {
+    if (this.envMap == envMap) {
+      return this;
+    }
+    this.envMap = envMap;
+    applyEnvironmentMap(this.envMap, this);
+    return this;
+  }
+  /**
+   * Polls data from the XRInputSource and updates the model's components to match
+   * the real world data
+   */
+  updateMatrixWorld(force) {
+    super.updateMatrixWorld(force);
+    if (!this.motionController)
+      return;
+    this.motionController.updateFromGamepad();
+    Object.values(this.motionController.components).forEach((component) => {
+      Object.values(component.visualResponses).forEach((visualResponse) => {
+        const { valueNode, minNode, maxNode, value, valueNodeProperty } = visualResponse;
+        if (!valueNode)
+          return;
+        if (valueNodeProperty === MotionControllers.MotionControllerConstants.VisualResponseProperty.VISIBILITY && typeof value === "boolean") {
+          valueNode.visible = value;
+        } else if (valueNodeProperty === MotionControllers.MotionControllerConstants.VisualResponseProperty.TRANSFORM && minNode && maxNode && typeof value === "number") {
+          valueNode.quaternion.slerpQuaternions(minNode.quaternion, maxNode.quaternion, value);
+          valueNode.position.lerpVectors(minNode.position, maxNode.position, value);
+        }
+      });
+    });
+  }
+}
+function findNodes(motionController, scene) {
+  Object.values(motionController.components).forEach((component) => {
+    const { type, touchPointNodeName, visualResponses } = component;
+    if (type === MotionControllers.MotionControllerConstants.ComponentType.TOUCHPAD && touchPointNodeName) {
+      component.touchPointNode = scene.getObjectByName(touchPointNodeName);
+      if (component.touchPointNode) {
+        const sphereGeometry = new THREE.SphereGeometry(1e-3);
+        const material = new THREE.MeshBasicMaterial({ color: 255 });
+        const sphere = new THREE.Mesh(sphereGeometry, material);
+        component.touchPointNode.add(sphere);
+      } else {
+        console.warn(`Could not find touch dot, ${component.touchPointNodeName}, in touchpad component ${component.id}`);
+      }
+    }
+    Object.values(visualResponses).forEach((visualResponse) => {
+      const { valueNodeName, minNodeName, maxNodeName, valueNodeProperty } = visualResponse;
+      if (valueNodeProperty === MotionControllers.MotionControllerConstants.VisualResponseProperty.TRANSFORM && minNodeName && maxNodeName) {
+        visualResponse.minNode = scene.getObjectByName(minNodeName);
+        visualResponse.maxNode = scene.getObjectByName(maxNodeName);
+        if (!visualResponse.minNode) {
+          console.warn(`Could not find ${minNodeName} in the model`);
+          return;
+        }
+        if (!visualResponse.maxNode) {
+          console.warn(`Could not find ${maxNodeName} in the model`);
+          return;
+        }
+      }
+      visualResponse.valueNode = scene.getObjectByName(valueNodeName);
+      if (!visualResponse.valueNode) {
+        console.warn(`Could not find ${valueNodeName} in the model`);
+      }
+    });
+  });
+}
+function addAssetSceneToControllerModel(controllerModel, scene) {
+  findNodes(controllerModel.motionController, scene);
+  if (controllerModel.envMap) {
+    applyEnvironmentMap(controllerModel.envMap, scene);
+  }
+  controllerModel.add(scene);
+}
+class XRControllerModelFactory {
+  constructor(gltfLoader = null) {
+    __publicField(this, "gltfLoader");
+    __publicField(this, "path");
+    __publicField(this, "_assetCache");
+    this.gltfLoader = gltfLoader;
+    this.path = DEFAULT_PROFILES_PATH;
+    this._assetCache = {};
+    if (!this.gltfLoader) {
+      this.gltfLoader = new GLTFLoader.GLTFLoader();
+    }
+  }
+  createControllerModel(controller) {
+    const controllerModel = new XRControllerModel();
+    let scene = null;
+    const onConnected = (event) => {
+      const xrInputSource = event.data;
+      if (xrInputSource.targetRayMode !== "tracked-pointer" || !xrInputSource.gamepad)
+        return;
+      MotionControllers.fetchProfile(xrInputSource, this.path, DEFAULT_PROFILE).then(({ profile, assetPath }) => {
+        if (!assetPath) {
+          throw new Error("no asset path");
+        }
+        controllerModel.motionController = new MotionControllers.MotionController(xrInputSource, profile, assetPath);
+        const assetUrl = controllerModel.motionController.assetUrl;
+        const cachedAsset = this._assetCache[assetUrl];
+        if (cachedAsset) {
+          scene = cachedAsset.scene.clone();
+          addAssetSceneToControllerModel(controllerModel, scene);
+        } else {
+          if (!this.gltfLoader) {
+            throw new Error("GLTFLoader not set.");
+          }
+          this.gltfLoader.setPath("");
+          this.gltfLoader.load(
+            controllerModel.motionController.assetUrl,
+            (asset) => {
+              if (!controllerModel.motionController) {
+                console.warn("motionController gone while gltf load, bailing...");
+                return;
+              }
+              this._assetCache[assetUrl] = asset;
+              scene = asset.scene.clone();
+              addAssetSceneToControllerModel(controllerModel, scene);
+            },
+            () => {
+            },
+            () => {
+              throw new Error(`Asset ${assetUrl} missing or malformed.`);
+            }
+          );
+        }
+      }).catch((err) => {
+        console.warn(err);
+      });
+    };
+    controller.addEventListener("connected", onConnected);
+    const onDisconnected = () => {
+      controller.removeEventListener("connected", onConnected);
+      controller.removeEventListener("disconnected", onDisconnected);
+      controllerModel.motionController = null;
+      if (scene) {
+        controllerModel.remove(scene);
+      }
+      scene = null;
+    };
+    controller.addEventListener("disconnected", onDisconnected);
+    return controllerModel;
+  }
+}
+exports.XRControllerModelFactory = XRControllerModelFactory;

package/dist/webxr/XRControllerModelFactory.mjs

@@ -0,0 +1,174 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import { Mesh, Object3D, SphereGeometry, MeshBasicMaterial } from "three";
+import { GLTFLoader } from "../loaders/GLTFLoader.mjs";
+import { MotionControllerConstants, fetchProfile, MotionController } from "../libs/MotionControllers.mjs";
+const DEFAULT_PROFILES_PATH = "https://cdn.jsdelivr.net/npm/@webxr-input-profiles/assets@1.0/dist/profiles";
+const DEFAULT_PROFILE = "generic-trigger";
+const applyEnvironmentMap = (envMap, obj) => {
+  obj.traverse((child) => {
+    if (child instanceof Mesh && "envMap" in child.material) {
+      child.material.envMap = envMap;
+      child.material.needsUpdate = true;
+    }
+  });
+};
+class XRControllerModel extends Object3D {
+  constructor() {
+    super();
+    __publicField(this, "envMap");
+    __publicField(this, "motionController");
+    this.motionController = null;
+    this.envMap = null;
+  }
+  setEnvironmentMap(envMap) {
+    if (this.envMap == envMap) {
+      return this;
+    }
+    this.envMap = envMap;
+    applyEnvironmentMap(this.envMap, this);
+    return this;
+  }
+  /**
+   * Polls data from the XRInputSource and updates the model's components to match
+   * the real world data
+   */
+  updateMatrixWorld(force) {
+    super.updateMatrixWorld(force);
+    if (!this.motionController)
+      return;
+    this.motionController.updateFromGamepad();
+    Object.values(this.motionController.components).forEach((component) => {
+      Object.values(component.visualResponses).forEach((visualResponse) => {
+        const { valueNode, minNode, maxNode, value, valueNodeProperty } = visualResponse;
+        if (!valueNode)
+          return;
+        if (valueNodeProperty === MotionControllerConstants.VisualResponseProperty.VISIBILITY && typeof value === "boolean") {
+          valueNode.visible = value;
+        } else if (valueNodeProperty === MotionControllerConstants.VisualResponseProperty.TRANSFORM && minNode && maxNode && typeof value === "number") {
+          valueNode.quaternion.slerpQuaternions(minNode.quaternion, maxNode.quaternion, value);
+          valueNode.position.lerpVectors(minNode.position, maxNode.position, value);
+        }
+      });
+    });
+  }
+}
+function findNodes(motionController, scene) {
+  Object.values(motionController.components).forEach((component) => {
+    const { type, touchPointNodeName, visualResponses } = component;
+    if (type === MotionControllerConstants.ComponentType.TOUCHPAD && touchPointNodeName) {
+      component.touchPointNode = scene.getObjectByName(touchPointNodeName);
+      if (component.touchPointNode) {
+        const sphereGeometry = new SphereGeometry(1e-3);
+        const material = new MeshBasicMaterial({ color: 255 });
+        const sphere = new Mesh(sphereGeometry, material);
+        component.touchPointNode.add(sphere);
+      } else {
+        console.warn(`Could not find touch dot, ${component.touchPointNodeName}, in touchpad component ${component.id}`);
+      }
+    }
+    Object.values(visualResponses).forEach((visualResponse) => {
+      const { valueNodeName, minNodeName, maxNodeName, valueNodeProperty } = visualResponse;
+      if (valueNodeProperty === MotionControllerConstants.VisualResponseProperty.TRANSFORM && minNodeName && maxNodeName) {
+        visualResponse.minNode = scene.getObjectByName(minNodeName);
+        visualResponse.maxNode = scene.getObjectByName(maxNodeName);
+        if (!visualResponse.minNode) {
+          console.warn(`Could not find ${minNodeName} in the model`);
+          return;
+        }
+        if (!visualResponse.maxNode) {
+          console.warn(`Could not find ${maxNodeName} in the model`);
+          return;
+        }
+      }
+      visualResponse.valueNode = scene.getObjectByName(valueNodeName);
+      if (!visualResponse.valueNode) {
+        console.warn(`Could not find ${valueNodeName} in the model`);
+      }
+    });
+  });
+}
+function addAssetSceneToControllerModel(controllerModel, scene) {
+  findNodes(controllerModel.motionController, scene);
+  if (controllerModel.envMap) {
+    applyEnvironmentMap(controllerModel.envMap, scene);
+  }
+  controllerModel.add(scene);
+}
+class XRControllerModelFactory {
+  constructor(gltfLoader = null) {
+    __publicField(this, "gltfLoader");
+    __publicField(this, "path");
+    __publicField(this, "_assetCache");
+    this.gltfLoader = gltfLoader;
+    this.path = DEFAULT_PROFILES_PATH;
+    this._assetCache = {};
+    if (!this.gltfLoader) {
+      this.gltfLoader = new GLTFLoader();
+    }
+  }
+  createControllerModel(controller) {
+    const controllerModel = new XRControllerModel();
+    let scene = null;
+    const onConnected = (event) => {
+      const xrInputSource = event.data;
+      if (xrInputSource.targetRayMode !== "tracked-pointer" || !xrInputSource.gamepad)
+        return;
+      fetchProfile(xrInputSource, this.path, DEFAULT_PROFILE).then(({ profile, assetPath }) => {
+        if (!assetPath) {
+          throw new Error("no asset path");
+        }
+        controllerModel.motionController = new MotionController(xrInputSource, profile, assetPath);
+        const assetUrl = controllerModel.motionController.assetUrl;
+        const cachedAsset = this._assetCache[assetUrl];
+        if (cachedAsset) {
+          scene = cachedAsset.scene.clone();
+          addAssetSceneToControllerModel(controllerModel, scene);
+        } else {
+          if (!this.gltfLoader) {
+            throw new Error("GLTFLoader not set.");
+          }
+          this.gltfLoader.setPath("");
+          this.gltfLoader.load(
+            controllerModel.motionController.assetUrl,
+            (asset) => {
+              if (!controllerModel.motionController) {
+                console.warn("motionController gone while gltf load, bailing...");
+                return;
+              }
+              this._assetCache[assetUrl] = asset;
+              scene = asset.scene.clone();
+              addAssetSceneToControllerModel(controllerModel, scene);
+            },
+            () => {
+            },
+            () => {
+              throw new Error(`Asset ${assetUrl} missing or malformed.`);
+            }
+          );
+        }
+      }).catch((err) => {
+        console.warn(err);
+      });
+    };
+    controller.addEventListener("connected", onConnected);
+    const onDisconnected = () => {
+      controller.removeEventListener("connected", onConnected);
+      controller.removeEventListener("disconnected", onDisconnected);
+      controllerModel.motionController = null;
+      if (scene) {
+        controllerModel.remove(scene);
+      }
+      scene = null;
+    };
+    controller.addEventListener("disconnected", onDisconnected);
+    return controllerModel;
+  }
+}
+export {
+  XRControllerModelFactory
+};

package/dist/webxr/XREstimatedLight.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="webxr" />
+import { DirectionalLight, Group, LightProbe, WebGLRenderer, Texture } from 'three'
+
+export class SessionLightProbe {
+  xrLight: XREstimatedLight
+  renderer: WebGLRenderer
+  lightProbe: unknown
+  xrWebGLBinding: unknown | null
+  estimationStartCallback: () => void
+  frameCallback: (this: SessionLightProbe, time: number, xrFrame: XRFrame) => void
+
+  constructor(
+    xrLight: XREstimatedLight,
+    renderer: WebGLRenderer,
+    lightProbe: unknown,
+    environmentEstimation: boolean,
+    estimationStartCallback: () => void,
+  )
+
+  updateReflection: () => void
+
+  onXRFrame: (time: number, xrFrame: XRFrame) => void
+
+  dispose: () => void
+}
+
+export class XREstimatedLight extends Group {
+  lightProbe: LightProbe
+  directionalLight: DirectionalLight
+  environment: Texture
+
+  constructor(renderer: WebGLRenderer, environmentEstimation?: boolean)
+}

package/dist/webxr/XREstimatedLight.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+class SessionLightProbe {
+  constructor(xrLight, renderer, lightProbe, environmentEstimation, estimationStartCallback) {
+    this.xrLight = xrLight;
+    this.renderer = renderer;
+    this.lightProbe = lightProbe;
+    this.xrWebGLBinding = null;
+    this.estimationStartCallback = estimationStartCallback;
+    this.frameCallback = this.onXRFrame.bind(this);
+    const session = renderer.xr.getSession();
+    if (environmentEstimation && "XRWebGLBinding" in window) {
+      const cubeRenderTarget = new THREE.WebGLCubeRenderTarget(16);
+      xrLight.environment = cubeRenderTarget.texture;
+      const gl = renderer.getContext();
+      switch (session.preferredReflectionFormat) {
+        case "srgba8":
+          gl.getExtension("EXT_sRGB");
+          break;
+        case "rgba16f":
+          gl.getExtension("OES_texture_half_float");
+          break;
+      }
+      this.xrWebGLBinding = new XRWebGLBinding(session, gl);
+      this.lightProbe.addEventListener("reflectionchange", () => {
+        this.updateReflection();
+      });
+    }
+    session.requestAnimationFrame(this.frameCallback);
+  }
+  updateReflection() {
+    const textureProperties = this.renderer.properties.get(this.xrLight.environment);
+    if (textureProperties) {
+      const cubeMap = this.xrWebGLBinding.getReflectionCubeMap(this.lightProbe);
+      if (cubeMap) {
+        textureProperties.__webglTexture = cubeMap;
+        this.xrLight.environment.needsPMREMUpdate = true;
+      }
+    }
+  }
+  onXRFrame(time, xrFrame) {
+    if (!this.xrLight) {
+      return;
+    }
+    const session = xrFrame.session;
+    session.requestAnimationFrame(this.frameCallback);
+    const lightEstimate = xrFrame.getLightEstimate(this.lightProbe);
+    if (lightEstimate) {
+      this.xrLight.lightProbe.sh.fromArray(lightEstimate.sphericalHarmonicsCoefficients);
+      this.xrLight.lightProbe.intensity = 1;
+      const intensityScalar = Math.max(
+        1,
+        Math.max(
+          lightEstimate.primaryLightIntensity.x,
+          Math.max(lightEstimate.primaryLightIntensity.y, lightEstimate.primaryLightIntensity.z)
+        )
+      );
+      this.xrLight.directionalLight.color.setRGB(
+        lightEstimate.primaryLightIntensity.x / intensityScalar,
+        lightEstimate.primaryLightIntensity.y / intensityScalar,
+        lightEstimate.primaryLightIntensity.z / intensityScalar
+      );
+      this.xrLight.directionalLight.intensity = intensityScalar;
+      this.xrLight.directionalLight.position.copy(lightEstimate.primaryLightDirection);
+      if (this.estimationStartCallback) {
+        this.estimationStartCallback();
+        this.estimationStartCallback = null;
+      }
+    }
+  }
+  dispose() {
+    this.xrLight = null;
+    this.renderer = null;
+    this.lightProbe = null;
+    this.xrWebGLBinding = null;
+  }
+}
+class XREstimatedLight extends THREE.Group {
+  constructor(renderer, environmentEstimation = true) {
+    super();
+    this.lightProbe = new THREE.LightProbe();
+    this.lightProbe.intensity = 0;
+    this.add(this.lightProbe);
+    this.directionalLight = new THREE.DirectionalLight();
+    this.directionalLight.intensity = 0;
+    this.add(this.directionalLight);
+    this.environment = null;
+    let sessionLightProbe = null;
+    let estimationStarted = false;
+    renderer.xr.addEventListener("sessionstart", () => {
+      const session = renderer.xr.getSession();
+      if ("requestLightProbe" in session) {
+        session.requestLightProbe({
+          reflectionFormat: session.preferredReflectionFormat
+        }).then((probe) => {
+          sessionLightProbe = new SessionLightProbe(this, renderer, probe, environmentEstimation, () => {
+            estimationStarted = true;
+            this.dispatchEvent({ type: "estimationstart" });
+          });
+        });
+      }
+    });
+    renderer.xr.addEventListener("sessionend", () => {
+      if (sessionLightProbe) {
+        sessionLightProbe.dispose();
+        sessionLightProbe = null;
+      }
+      if (estimationStarted) {
+        this.dispatchEvent({ type: "estimationend" });
+      }
+    });
+    this.dispose = () => {
+      if (sessionLightProbe) {
+        sessionLightProbe.dispose();
+        sessionLightProbe = null;
+      }
+      this.remove(this.lightProbe);
+      this.lightProbe = null;
+      this.remove(this.directionalLight);
+      this.directionalLight = null;
+      this.environment = null;
+    };
+  }
+}
+exports.XREstimatedLight = XREstimatedLight;