@shopware-ag/dive 1.16.24 → 1.16.25-beta.1

package/build/dive.cjs

@@ -325,19 +325,19 @@ var init_BaseTool = __esm({
 });
 
 // src/toolbox/transform/TransformTool.ts
-var import_Addons, DIVETransformTool;
+var import_TransformControls, DIVETransformTool;
 var init_TransformTool = __esm({
   "src/toolbox/transform/TransformTool.ts"() {
     "use strict";
     init_BaseTool();
-    import_Addons = require("three/examples/jsm/Addons");
+    import_TransformControls = require("three/examples/jsm/controls/TransformControls");
     init_implementsInterface();
     DIVETransformTool = class extends DIVEBaseTool {
       constructor(scene, controller) {
         super(scene, controller);
         this.isTransformTool = true;
         this.name = "DIVETransformTool";
-        this._gizmo = new import_Addons.TransformControls(
+        this._gizmo = new import_TransformControls.TransformControls(
           this._controller.object,
           this._controller.domElement
         );
@@ -371,7 +371,7 @@ var init_TransformTool = __esm({
           if (!this._gizmo.object.onMoveEnd) return;
           this._gizmo.object.onMoveEnd();
         });
-        scene.add(this._gizmo);
+        this._scene.add(this._gizmo);
       }
       Activate() {
       }
@@ -636,6 +636,1398 @@ var init_IO = __esm({
   }
 });
 
+// src/info/Info.ts
+var WebXRUnsupportedReason, DIVEInfo;
+var init_Info = __esm({
+  "src/info/Info.ts"() {
+    "use strict";
+    WebXRUnsupportedReason = /* @__PURE__ */ ((WebXRUnsupportedReason2) => {
+      WebXRUnsupportedReason2[WebXRUnsupportedReason2["UNKNWON_ERROR"] = 0] = "UNKNWON_ERROR";
+      WebXRUnsupportedReason2[WebXRUnsupportedReason2["NO_HTTPS"] = 1] = "NO_HTTPS";
+      WebXRUnsupportedReason2[WebXRUnsupportedReason2["IMMERSIVE_AR_NOT_SUPPORTED_BY_DEVICE"] = 2] = "IMMERSIVE_AR_NOT_SUPPORTED_BY_DEVICE";
+      WebXRUnsupportedReason2[WebXRUnsupportedReason2["AR_SESSION_NOT_ALLOWED"] = 3] = "AR_SESSION_NOT_ALLOWED";
+      return WebXRUnsupportedReason2;
+    })(WebXRUnsupportedReason || {});
+    DIVEInfo = class {
+      /**
+       *
+       * @returns The system the user is using. Possible values are "Android", "iOS", "Windows", "MacOS", "Linux" or "Unknown".
+       */
+      static GetSystem() {
+        const platform = navigator.platform;
+        if (/Android/.test(navigator.userAgent)) {
+          return "Android";
+        } else if (/iPhone|iPad|iPod/.test(navigator.userAgent)) {
+          return "iOS";
+        } else if (platform.startsWith("Win")) {
+          return "Windows";
+        } else if (platform.startsWith("Mac")) {
+          return "MacOS";
+        } else if (platform.startsWith("Linux")) {
+          return "Linux";
+        } else {
+          return "Unknown";
+        }
+      }
+      /**
+       * @returns A promise that resolves to a boolean indicating whether the user's device supports WebXR.
+       */
+      static GetSupportsWebXR() {
+        return __async(this, null, function* () {
+          if (this._supportsWebXR !== null) {
+            return this._supportsWebXR;
+          }
+          if (!navigator.xr) {
+            this._supportsWebXR = false;
+            if (window.isSecureContext === false) {
+              this._webXRUnsupportedReason = 1 /* NO_HTTPS */;
+            } else {
+              this._webXRUnsupportedReason = 0 /* UNKNWON_ERROR */;
+            }
+            return this._supportsWebXR;
+          }
+          try {
+            const supported = yield navigator.xr.isSessionSupported("immersive-ar");
+            if (!supported) {
+              this._webXRUnsupportedReason = 2 /* IMMERSIVE_AR_NOT_SUPPORTED_BY_DEVICE */;
+            }
+            this._supportsWebXR = supported;
+          } catch (error) {
+            this._supportsWebXR = false;
+            this._webXRUnsupportedReason = 3 /* AR_SESSION_NOT_ALLOWED */;
+          }
+          return this._supportsWebXR;
+        });
+      }
+      /**
+       * @returns The reason why WebXR is not supported on the user's device. Returns null if WebXR is supported nor not has been checked yet.
+       */
+      static GetWebXRUnsupportedReason() {
+        if (this._supportsWebXR === null) {
+          console.log("WebXR support has not been checked yet.");
+          return null;
+        }
+        return this._webXRUnsupportedReason;
+      }
+      /**
+       * @returns A boolean indicating whether the user's device supports AR Quick Look.
+       */
+      static GetSupportsARQuickLook() {
+        const a = document.createElement("a");
+        if (a.relList.supports("ar")) {
+          return true;
+        }
+        const userAgent = navigator.userAgent;
+        const isIOS = /iPad|iPhone|iPod/.test(userAgent) && !window.MSStream;
+        if (!isIOS) {
+          return false;
+        }
+        const match = userAgent.match(/OS (\d+)_/);
+        if (!match || match.length < 2) {
+          return false;
+        }
+        const iOSVersion = parseInt(match[1], 10);
+        const minQuickLookVersion = 12;
+        if (iOSVersion < minQuickLookVersion) {
+          return false;
+        }
+        const isSupportedBrowser = /^((?!chrome|android).)*safari|CriOS|FxiOS/i.test(userAgent);
+        if (isSupportedBrowser) {
+          return true;
+        }
+        return false;
+      }
+      /**
+       * @returns A boolean indicating whether the user's device is a mobile device.
+       */
+      static get isMobile() {
+        return this.GetSystem() === "Android" || this.GetSystem() === "iOS";
+      }
+      /**
+       * @returns A boolean indicating whether the user's device is a desktop device.
+       */
+      static get isDesktop() {
+        return !this.isMobile;
+      }
+      /**
+       * @returns A promise that resolves to a boolean indicating whether the user's device is capable of AR.
+       */
+      static GetIsARCapable() {
+        return __async(this, null, function* () {
+          if (this.GetSupportsARQuickLook()) {
+            return true;
+          }
+          return yield this.GetSupportsWebXR();
+        });
+      }
+    };
+    DIVEInfo._supportsWebXR = null;
+    DIVEInfo._webXRUnsupportedReason = null;
+  }
+});
+
+// src/ar/arquicklook/ARQuickLook.ts
+var import_three5, import_USDZExporter, DIVEARQuickLook;
+var init_ARQuickLook = __esm({
+  "src/ar/arquicklook/ARQuickLook.ts"() {
+    "use strict";
+    import_three5 = require("three");
+    import_USDZExporter = require("three/examples/jsm/exporters/USDZExporter");
+    DIVEARQuickLook = class {
+      static Launch(scene) {
+        const quickLookScene = new import_three5.Object3D();
+        quickLookScene.add(...this.extractModels(scene));
+        return this.launchARFromNode(quickLookScene);
+      }
+      static extractModels(scene) {
+        return scene.Root.children;
+      }
+      static launchARFromNode(node) {
+        return this._usdzExporter.parse(node, { quickLookCompatible: true }).then((usdz) => {
+          const blob = new Blob([usdz], { type: "model/vnd.usdz+zip" });
+          const url = URL.createObjectURL(blob);
+          const a = document.createElement("a");
+          a.innerHTML = "<picture></picture>";
+          a.rel = "ar";
+          a.href = url;
+          a.download = "scene.usdz";
+          a.click();
+        });
+      }
+    };
+    DIVEARQuickLook._usdzExporter = new import_USDZExporter.USDZExporter();
+  }
+});
+
+// src/ar/webxr/overlay/Overlay.ts
+var Overlay;
+var init_Overlay = __esm({
+  "src/ar/webxr/overlay/Overlay.ts"() {
+    "use strict";
+    Overlay = class {
+      get Element() {
+        return this._element;
+      }
+      get CloseButton() {
+        return this._closeButton;
+      }
+      constructor() {
+        this._element = document.createElement("div");
+        this._closeButton = this.createCloseButton();
+        this._element.appendChild(this._closeButton);
+        document.body.appendChild(this._element);
+      }
+      createCloseButton() {
+        const path = document.createElementNS(
+          "http://www.w3.org/2000/svg",
+          "path"
+        );
+        path.setAttribute("d", "M 12,12 L 28,28 M 28,12 12,28");
+        path.setAttribute("stroke", "#fff");
+        path.setAttribute("stroke-width", "2");
+        const svg = document.createElementNS(
+          "http://www.w3.org/2000/svg",
+          "svg"
+        );
+        svg.setAttribute("width", "38");
+        svg.setAttribute("height", "38");
+        svg.style.position = "absolute";
+        svg.style.right = "20px";
+        svg.style.top = "20px";
+        svg.appendChild(path);
+        return svg;
+      }
+    };
+  }
+});
+
+// src/ar/webxr/crosshair/WebXRCrosshair.ts
+var import_three6, DIVEWebXRCrosshair;
+var init_WebXRCrosshair = __esm({
+  "src/ar/webxr/crosshair/WebXRCrosshair.ts"() {
+    "use strict";
+    import_three6 = require("three");
+    DIVEWebXRCrosshair = class extends import_three6.Object3D {
+      set mesh(mesh) {
+        this.clear();
+        if (mesh) {
+          this.add(mesh);
+        }
+      }
+      constructor(mesh) {
+        super();
+        if (mesh) {
+          this.mesh = mesh;
+        } else {
+          this.UseDefaultMesh();
+        }
+        this.matrixAutoUpdate = false;
+        return this;
+      }
+      UseDefaultMesh() {
+        const geometry = new import_three6.RingGeometry(0.08, 0.1, 32).rotateX(-Math.PI / 2);
+        const material = new import_three6.MeshBasicMaterial();
+        this.mesh = new import_three6.Mesh(geometry, material);
+      }
+      UpdateFromPose(pose) {
+        this.matrix.fromArray(pose.transform.matrix);
+      }
+    };
+  }
+});
+
+// src/ar/webxr/raycaster/ar/WebXRRaycasterAR.ts
+var import_three7, DIVEWebXRRaycasterAR;
+var init_WebXRRaycasterAR = __esm({
+  "src/ar/webxr/raycaster/ar/WebXRRaycasterAR.ts"() {
+    "use strict";
+    import_three7 = require("three");
+    DIVEWebXRRaycasterAR = class {
+      constructor(session, renderer) {
+        this._referenceSpaceBuffer = null;
+        this._requesting = false;
+        this._initialized = false;
+        this._session = session;
+        this._renderer = renderer;
+        this._hitMatrixBuffer = new import_three7.Matrix4();
+      }
+      Dispose() {
+        var _a;
+        (_a = this._transientHitTestSource) == null ? void 0 : _a.cancel();
+        this._transientHitTestSource = void 0;
+        this._initialized = false;
+      }
+      Init() {
+        return __async(this, null, function* () {
+          if (!this._session) {
+            console.error(
+              "DIVEWebXRRaycaster: No session set in Init()! Aborting initialization..."
+            );
+            return Promise.reject();
+          }
+          if (this._requesting) {
+            console.error(
+              "DIVEWebXRRaycaster: Currently initializing! Aborting initialization..."
+            );
+            return Promise.reject();
+          }
+          if (this._initialized) {
+            console.error(
+              "DIVEWebXRRaycaster: Already initialized! Aborting initialization..."
+            );
+            return Promise.reject();
+          }
+          this._requesting = true;
+          this._transientHitTestSource = yield this._session.requestHitTestSourceForTransientInput({
+            profile: "generic-touchscreen"
+          });
+          this._referenceSpaceBuffer = this._renderer.xr.getReferenceSpace();
+          this._requesting = false;
+          if (!this._transientHitTestSource) {
+            return Promise.reject();
+          }
+          this._initialized = true;
+          console.log("DIVEWebXRRaycasterAR: Initialized");
+          return Promise.resolve(this);
+        });
+      }
+      GetIntersections(frame) {
+        if (!this._transientHitTestSource) return [];
+        const touches = frame.getHitTestResultsForTransientInput(
+          this._transientHitTestSource
+        );
+        if (touches.length === 0) return [];
+        const hits = touches.map((touch) => {
+          if (!this._referenceSpaceBuffer) return void 0;
+          if (!touch.results[0]) return void 0;
+          if (!touch.results[0].getPose) return void 0;
+          const pose = touch.results[0].getPose(this._referenceSpaceBuffer);
+          if (!pose) return void 0;
+          this._hitMatrixBuffer.fromArray(pose.transform.matrix);
+          const position = new import_three7.Vector3().setFromMatrixPosition(
+            this._hitMatrixBuffer
+          );
+          return {
+            point: position,
+            matrix: this._hitMatrixBuffer,
+            object: void 0
+          };
+        });
+        return hits.filter((hit) => hit !== void 0);
+      }
+    };
+  }
+});
+
+// src/ar/webxr/raycaster/three/WebXRRaycasterTHREE.ts
+var import_three8, DIVEWebXRRaycasterTHREE;
+var init_WebXRRaycasterTHREE = __esm({
+  "src/ar/webxr/raycaster/three/WebXRRaycasterTHREE.ts"() {
+    "use strict";
+    import_three8 = require("three");
+    DIVEWebXRRaycasterTHREE = class {
+      constructor(renderer, scene) {
+        // internal raycaster
+        this._raycaster = new import_three8.Raycaster();
+        this._renderer = renderer;
+        this._scene = scene;
+        this._controller = this._renderer.xr.getController(0);
+      }
+      Init() {
+        return __async(this, null, function* () {
+          console.log("DIVEWebXRRaycasterTHREE: Initialized");
+          return Promise.resolve(this);
+        });
+      }
+      GetIntersections() {
+        this._controller.updateMatrixWorld();
+        this._raycaster.setFromXRController(this._controller);
+        const intersections = this._raycaster.intersectObjects(
+          this._scene.XRRoot.XRModelRoot.children
+        );
+        if (intersections.length === 0) return [];
+        return intersections.map((intersection) => {
+          return {
+            point: intersection.point,
+            matrix: intersection.object.matrixWorld,
+            object: intersection.object
+          };
+        });
+      }
+    };
+  }
+});
+
+// src/events/EventExecutor.ts
+var DIVEEventExecutor;
+var init_EventExecutor = __esm({
+  "src/events/EventExecutor.ts"() {
+    "use strict";
+    DIVEEventExecutor = class {
+      constructor() {
+        this._listeners = /* @__PURE__ */ new Map();
+      }
+      Subscribe(type, listener) {
+        if (!this._listeners.get(type)) this._listeners.set(type, []);
+        this._listeners.get(type).push(listener);
+        return () => {
+          const listenerArray = this._listeners.get(type);
+          if (!listenerArray) return false;
+          const existingIndex = listenerArray.findIndex(
+            (entry) => entry === listener
+          );
+          if (existingIndex === -1) return false;
+          listenerArray.splice(existingIndex, 1);
+          return true;
+        };
+      }
+      dispatch(type, payload) {
+        const listenerArray = this._listeners.get(type);
+        if (!listenerArray) return;
+        listenerArray.forEach((listener) => listener(payload));
+      }
+    };
+  }
+});
+
+// src/ar/webxr/raycaster/WebXRRaycaster.ts
+var DIVEWebXRRaycaster;
+var init_WebXRRaycaster = __esm({
+  "src/ar/webxr/raycaster/WebXRRaycaster.ts"() {
+    "use strict";
+    init_WebXRRaycasterAR();
+    init_WebXRRaycasterTHREE();
+    init_EventExecutor();
+    DIVEWebXRRaycaster = class extends DIVEEventExecutor {
+      constructor(session, renderer, scene) {
+        super();
+        this._initialized = false;
+        this._arHitResultBuffer = [];
+        this._sceneHitResultBuffer = [];
+        // buffers
+        this._hasHit = false;
+        this._session = session;
+        this._threeRaycaster = new DIVEWebXRRaycasterTHREE(renderer, scene);
+        this._arRaycaster = new DIVEWebXRRaycasterAR(session, renderer);
+      }
+      Dispose() {
+        this._initialized = false;
+      }
+      Init() {
+        return __async(this, null, function* () {
+          if (!this._session) {
+            console.error(
+              "DIVEWebXRRaycaster: No session set in Init()! Aborting initialization..."
+            );
+            return Promise.reject();
+          }
+          if (this._initialized) {
+            console.error(
+              "DIVEWebXRRaycaster: Already initialized! Aborting initialization..."
+            );
+            return Promise.reject();
+          }
+          yield this._threeRaycaster.Init();
+          yield this._arRaycaster.Init();
+          console.log("DIVEWebXRRaycaster: Initialized");
+          this._initialized = true;
+          return Promise.resolve(this);
+        });
+      }
+      GetARIntersections(frame) {
+        this._arHitResultBuffer = this._arRaycaster.GetIntersections(frame);
+        if (this._arHitResultBuffer.length > 0) {
+          this.onARHitFound(this._arHitResultBuffer[0]);
+        } else {
+          this.onARHitLost();
+        }
+        return this._arHitResultBuffer;
+      }
+      GetSceneIntersections() {
+        this._sceneHitResultBuffer = this._threeRaycaster.GetIntersections();
+        if (this._sceneHitResultBuffer.length > 0) {
+          this.onSceneHitFound(this._sceneHitResultBuffer[0]);
+        } else {
+          this.onSceneHitLost();
+        }
+        return this._sceneHitResultBuffer;
+      }
+      onARHitFound(hit) {
+        this._hasHit = true;
+        this.dispatch("AR_HIT_FOUND", { hit });
+      }
+      onARHitLost() {
+        if (!this._hasHit) return;
+        this._hasHit = false;
+        this.dispatch("AR_HIT_LOST");
+      }
+      onSceneHitFound(hit) {
+        this._hasHit = true;
+        this.dispatch("SCENE_HIT_FOUND", { hit });
+      }
+      onSceneHitLost() {
+        if (!this._hasHit) return;
+        this._hasHit = false;
+        this.dispatch("SCENE_HIT_LOST");
+      }
+    };
+  }
+});
+
+// src/ar/webxr/origin/WebXROrigin.ts
+var import_three9, DIVEWebXROrigin;
+var init_WebXROrigin = __esm({
+  "src/ar/webxr/origin/WebXROrigin.ts"() {
+    "use strict";
+    import_three9 = require("three");
+    DIVEWebXROrigin = class {
+      constructor(session, renderer, entityTypes) {
+        this._raycastHitCounter = 0;
+        this._originSetResolve = () => {
+        };
+        this._renderer = renderer;
+        this._session = session;
+        this._originSet = new Promise((resolve) => {
+          this._originSetResolve = resolve;
+        });
+        this._requesting = false;
+        this._initialized = false;
+        this._referenceSpaceBuffer = null;
+        this._hitTestSource = null;
+        this._entityTypes = entityTypes || ["plane"];
+        this._hitTestResultBuffer = [];
+        this._matrix = new import_three9.Matrix4();
+        this._position = new import_three9.Vector3();
+        this._quaternion = new import_three9.Quaternion();
+        this._scale = new import_three9.Vector3();
+        this._originSet.then(() => {
+          this._matrix.decompose(
+            this._position,
+            this._quaternion,
+            this._scale
+          );
+        });
+      }
+      get originSet() {
+        return this._originSet;
+      }
+      get matrix() {
+        return this._matrix;
+      }
+      set matrix(value) {
+        this._matrix = value;
+        this._matrix.decompose(this._position, this._quaternion, this._scale);
+      }
+      get position() {
+        return this._position;
+      }
+      get quaternion() {
+        return this._quaternion;
+      }
+      get scale() {
+        return this._scale;
+      }
+      Init() {
+        return __async(this, null, function* () {
+          if (this._initialized) {
+            return Promise.resolve(this);
+          }
+          if (!this._session) {
+            console.error(
+              "DIVEWebXROrigin: No session set in Init()! Aborting initialization..."
+            );
+            return Promise.reject();
+          }
+          if (this._requesting) {
+            console.error(
+              "DIVEWebXROrigin: Currently initializing! Aborting initialization..."
+            );
+            return Promise.reject();
+          }
+          this._requesting = true;
+          const referenceSpace = yield this._session.requestReferenceSpace("viewer");
+          this._hitTestSource = (yield this._session.requestHitTestSource({
+            space: referenceSpace,
+            entityTypes: this._entityTypes
+          })) || null;
+          this._requesting = false;
+          if (!this._hitTestSource) {
+            return Promise.reject();
+          }
+          this._initialized = true;
+          return Promise.resolve(this);
+        });
+      }
+      Dispose() {
+        var _a;
+        this._initialized = false;
+        this._requesting = false;
+        (_a = this._hitTestSource) == null ? void 0 : _a.cancel();
+        this._hitTestSource = null;
+        this._hitTestResultBuffer = [];
+        this._matrix = new import_three9.Matrix4();
+        this._position = new import_three9.Vector3();
+        this._quaternion = new import_three9.Quaternion();
+        this._scale = new import_three9.Vector3();
+      }
+      Update(frame) {
+        if (!this._initialized) return;
+        if (!this._hitTestSource) {
+          throw new Error(
+            "DIVEWebXRRaycaster: Critical Error: HitTestSource not available but WebXROrigin is initialized!"
+          );
+        }
+        this._hitTestResultBuffer = frame.getHitTestResults(
+          this._hitTestSource
+        );
+        if (this._hitTestResultBuffer.length > 0) {
+          this._referenceSpaceBuffer = this._renderer.xr.getReferenceSpace();
+          if (!this._referenceSpaceBuffer) {
+            this.onHitLost();
+            return;
+          }
+          const pose = this._hitTestResultBuffer[0].getPose(
+            this._referenceSpaceBuffer
+          );
+          if (!pose) {
+            this.onHitLost();
+            return;
+          }
+          this.onHitFound(pose);
+        } else {
+          this.onHitLost();
+        }
+      }
+      onHitFound(pose) {
+        this._raycastHitCounter++;
+        this.matrix.fromArray(pose.transform.matrix);
+        if (this._raycastHitCounter > 50) {
+          this._originSetResolve();
+        }
+      }
+      onHitLost() {
+        this._raycastHitCounter = 0;
+      }
+    };
+  }
+});
+
+// src/ar/webxr/touchscreencontrols/WebXRTouchscreenControls.ts
+var import_three10, DIVEWebXRTouchscreenControls;
+var init_WebXRTouchscreenControls = __esm({
+  "src/ar/webxr/touchscreencontrols/WebXRTouchscreenControls.ts"() {
+    "use strict";
+    import_three10 = require("three");
+    init_EventExecutor();
+    DIVEWebXRTouchscreenControls = class extends DIVEEventExecutor {
+      constructor(session) {
+        super();
+        // touch members
+        this._touchCount = 0;
+        this._touches = [];
+        // rotate members
+        this._handleRotateStarted = false;
+        this._handleRotateMoved = false;
+        this._handleRotateEnded = false;
+        this._startAngle = 0;
+        this._lastAngle = 0;
+        this._angleDelta = 0;
+        // scale members
+        this._handlePinchStarted = false;
+        this._handlePinchMoved = false;
+        this._handlePinchEnded = false;
+        this._scaleDistanceStart = 0;
+        this._currentDistance = 1;
+        this._deltaDistance = 0;
+        this._session = session;
+        this._touches = [
+          {
+            start: new import_three10.Vector2(),
+            current: new import_three10.Vector2(),
+            delta: new import_three10.Vector2()
+          },
+          {
+            start: new import_three10.Vector2(),
+            current: new import_three10.Vector2(),
+            delta: new import_three10.Vector2()
+          }
+        ];
+        this._handleRotateStarted = false;
+        window.addEventListener(
+          "touchstart",
+          (e) => this.onTouchStart(e)
+        );
+        window.addEventListener(
+          "touchmove",
+          (e) => this.onTouchMove(e)
+        );
+        window.addEventListener(
+          "touchend",
+          (e) => this.onTouchEnd(e)
+        );
+        this._session.addEventListener(
+          "selectstart",
+          () => this.onSessionSelectStart()
+        );
+        this._session.addEventListener(
+          "selectend",
+          () => this.onSessionSelectEnd()
+        );
+      }
+      Dispose() {
+        window.removeEventListener(
+          "touchstart",
+          (e) => this.onTouchStart(e)
+        );
+        window.removeEventListener(
+          "touchmove",
+          (e) => this.onTouchMove(e)
+        );
+        window.removeEventListener(
+          "touchend",
+          (e) => this.onTouchEnd(e)
+        );
+        this._session.removeEventListener(
+          "selectstart",
+          () => this.onSessionSelectStart()
+        );
+        this._session.removeEventListener(
+          "selectend",
+          () => this.onSessionSelectEnd()
+        );
+      }
+      onTouchStart(event) {
+        this._touchCount = event.touches.length;
+        this._touches[0].start.set(
+          event.touches[0].clientX,
+          event.touches[0].clientY
+        );
+        this._touches[0].current.set(
+          event.touches[0].clientX,
+          event.touches[0].clientY
+        );
+        this._touches[0].delta.set(0, 0);
+        if (this._touchCount > 1) {
+          this._touches[1].start.set(
+            event.touches[1].clientX,
+            event.touches[1].clientY
+          );
+          this._touches[1].current.set(
+            event.touches[1].clientX,
+            event.touches[1].clientY
+          );
+          this._touches[1].delta.set(0, 0);
+        }
+        if (this._touchCount === 2) {
+          this.handleRotateStart();
+          this.handlePinchStart();
+        }
+        if (this._handleRotateStarted) {
+          this.dispatch("ROTATE_START", {
+            current: 0
+          });
+          this._handleRotateStarted = false;
+        }
+        if (this._handlePinchStarted) {
+          this.dispatch("PINCH_START", {
+            current: 0
+          });
+          this._handlePinchStarted = false;
+        }
+      }
+      onTouchMove(event) {
+        this._touchCount = event.touches.length;
+        this._touches[0].start.set(
+          event.touches[0].clientX,
+          event.touches[0].clientY
+        );
+        this._touches[0].current.set(
+          event.touches[0].clientX,
+          event.touches[0].clientY
+        );
+        this._touches[0].delta.copy(
+          this._touches[0].current.clone().sub(this._touches[0].start)
+        );
+        if (this._touchCount > 1) {
+          this._touches[1].start.set(
+            event.touches[1].clientX,
+            event.touches[1].clientY
+          );
+          this._touches[1].current.set(
+            event.touches[1].clientX,
+            event.touches[1].clientY
+          );
+          this._touches[1].delta.copy(
+            this._touches[1].current.clone().sub(this._touches[1].start)
+          );
+        }
+        if (this._touchCount === 2) {
+          this.handleRotateMoved();
+          this.handlePinchMoved();
+        }
+        if (this._touchCount === 1) {
+          this.dispatch("TOUCH_MOVE", {
+            touches: [
+              {
+                current: this._touches[0].current.clone(),
+                delta: this._touches[0].delta.clone()
+              },
+              {
+                current: this._touches[1].current.clone(),
+                delta: this._touches[1].delta.clone()
+              }
+            ],
+            touchCount: this._touchCount
+          });
+        }
+        if (this._touchCount === 2) {
+          if (this._handleRotateMoved) {
+            this.dispatch("ROTATE_MOVE", {
+              current: this._lastAngle,
+              delta: this._angleDelta
+            });
+            this._handleRotateMoved = false;
+          }
+          if (this._handlePinchMoved) {
+            this.dispatch("PINCH_MOVE", {
+              current: this._currentDistance,
+              delta: this._deltaDistance
+            });
+            this._handlePinchMoved = false;
+          }
+        }
+      }
+      onTouchEnd(event) {
+        this._touchCount = event.touches.length;
+        if (this._touchCount === 0) {
+          this._touches[0].start.set(0, 0);
+          this._touches[0].current.set(0, 0);
+          this._touches[0].delta.set(0, 0);
+        }
+        if (this._touchCount === 1) {
+          this.handleRotateEnded();
+          this.handlePinchEnded();
+          this._touches[1].start.set(0, 0);
+          this._touches[1].current.set(0, 0);
+          this._touches[1].delta.set(0, 0);
+        }
+        if (this._handleRotateEnded) {
+          this.dispatch("ROTATE_END", {
+            current: this._lastAngle
+          });
+          this._handleRotateEnded = false;
+        }
+        if (this._handlePinchEnded) {
+          this.dispatch("PINCH_END", {
+            current: this._currentDistance
+          });
+          this._handlePinchEnded = false;
+        }
+      }
+      onSessionSelectStart() {
+        this.dispatch("TOUCH_START", {
+          touches: [
+            {
+              current: this._touches[0].current.clone()
+            },
+            {
+              current: this._touches[1].current.clone()
+            }
+          ],
+          touchCount: this._touchCount
+        });
+      }
+      onSessionSelectEnd() {
+        this.dispatch("TOUCH_END", {
+          touches: [
+            {
+              current: this._touches[0].current.clone()
+            },
+            {
+              current: this._touches[1].current.clone()
+            }
+          ],
+          touchCount: this._touchCount
+        });
+      }
+      // rotation handler
+      handleRotateStart() {
+        this._handleRotateStarted = true;
+        this._startAngle = this._touches[1].start.clone().sub(this._touches[0].current).angle();
+      }
+      handleRotateMoved() {
+        this._handleRotateMoved = true;
+        const currentAngle = this._touches[1].current.clone().sub(this._touches[0].current).angle();
+        this._angleDelta = currentAngle - this._startAngle;
+        this._lastAngle = this._angleDelta * -1;
+      }
+      handleRotateEnded() {
+        this._handleRotateEnded = true;
+      }
+      // pinch handler
+      handlePinchStart() {
+        this._handlePinchStarted = true;
+        this._scaleDistanceStart = this._touches[1].start.distanceTo(
+          this._touches[0].current
+        );
+      }
+      handlePinchMoved() {
+        this._handlePinchMoved = true;
+        const beforeDistance = this._currentDistance;
+        const distance = this._touches[1].current.distanceTo(
+          this._touches[0].current
+        );
+        this._currentDistance = distance / this._scaleDistanceStart;
+        this._deltaDistance = this._currentDistance - beforeDistance;
+      }
+      handlePinchEnded() {
+        this._handlePinchEnded = true;
+      }
+    };
+  }
+});
+
+// src/ar/webxr/controller/WebXRController.ts
+var import_three11, DIVEWebXRController;
+var init_WebXRController = __esm({
+  "src/ar/webxr/controller/WebXRController.ts"() {
+    "use strict";
+    import_three11 = require("three");
+    init_WebXRCrosshair();
+    init_WebXRRaycaster();
+    init_WebXROrigin();
+    init_WebXRTouchscreenControls();
+    init_findInterface();
+    DIVEWebXRController = class extends import_three11.Object3D {
+      constructor(session, renderer, scene) {
+        super();
+        this._frameBuffer = null;
+        this._handNodeInitialPosition = new import_three11.Vector3();
+        this._placed = false;
+        // grabbing
+        this._grabbedObject = null;
+        this._arHitPosition = new import_three11.Vector3();
+        this._arHitQuaternion = new import_three11.Quaternion();
+        this._arHitScale = new import_three11.Vector3(1, 1, 1);
+        // grabbing position
+        this._initialObjectPosition = null;
+        this._initialRaycastHit = null;
+        this._deltaRaycastHit = new import_three11.Vector3();
+        // grabbing rotation
+        this._touchQuaterion = new import_three11.Quaternion();
+        // grabbing scale
+        this._touchScale = 1;
+        this._scaleThreshold = 0.1;
+        this._startTouchQuaternion = new import_three11.Quaternion();
+        this._startTouchScale = 1;
+        this._renderer = renderer;
+        this._scene = scene;
+        this._session = session;
+        this._xrRaycaster = new DIVEWebXRRaycaster(session, renderer, scene);
+        this._origin = new DIVEWebXROrigin(this._session, this._renderer, [
+          "plane"
+        ]);
+        this._crosshair = new DIVEWebXRCrosshair();
+        this._crosshair.visible = false;
+        this._xrCamera = this._renderer.xr.getCamera();
+        this._scene.XRRoot.XRHandNode.position.set(0, -0.05, -0.25);
+        this._handNodeInitialPosition = this._scene.XRRoot.XRHandNode.position.clone();
+        this._touchscreenControls = new DIVEWebXRTouchscreenControls(
+          this._session
+        );
+        this._touchscreenControls.Subscribe(
+          "TOUCH_START",
+          () => this.onTouchStart()
+        );
+        this._touchscreenControls.Subscribe(
+          "TOUCH_MOVE",
+          () => this.onTouchMove()
+        );
+        this._touchscreenControls.Subscribe(
+          "TOUCH_END",
+          (p) => this.onTouchEnd(p)
+        );
+        this._touchscreenControls.Subscribe(
+          "ROTATE_START",
+          () => this.onRotateStart()
+        );
+        this._touchscreenControls.Subscribe(
+          "ROTATE_MOVE",
+          (p) => this.onRotateMove(p)
+        );
+        this._touchscreenControls.Subscribe(
+          "PINCH_START",
+          () => this.onPinchStart()
+        );
+        this._touchscreenControls.Subscribe(
+          "PINCH_MOVE",
+          (p) => this.onPinchMove(p)
+        );
+      }
+      Init() {
+        return __async(this, null, function* () {
+          this.prepareScene();
+          yield this.initOrigin();
+          yield this.initRaycaster();
+          return Promise.resolve(this);
+        });
+      }
+      Dispose() {
+        this.restoreScene();
+        this._origin.Dispose();
+        this._xrRaycaster.Dispose();
+        this._placed = false;
+      }
+      Update(frame) {
+        this._frameBuffer = frame;
+        if (!this._placed) {
+          this._xrCamera.updateMatrixWorld();
+          this._scene.XRRoot.XRHandNode.position.copy(
+            this._handNodeInitialPosition.clone().applyMatrix4(this._xrCamera.matrixWorld)
+          );
+          this._scene.XRRoot.XRHandNode.quaternion.setFromRotationMatrix(
+            this._xrCamera.matrixWorld
+          );
+          if (this._origin) {
+            this._origin.Update(frame);
+          }
+        }
+      }
+      // placement
+      initOrigin() {
+        return __async(this, null, function* () {
+          this._origin = yield this._origin.Init();
+          this._origin.originSet.then(() => {
+            this.placeObjects(this._origin.matrix);
+          });
+        });
+      }
+      placeObjects(matrix) {
+        this._scene.XRRoot.XRModelRoot.matrix.copy(matrix);
+        [...this._scene.XRRoot.XRHandNode.children].forEach((child) => {
+          this._scene.XRRoot.XRModelRoot.add(child);
+        });
+        this._placed = true;
+      }
+      // grabbing
+      updateObject() {
+        if (!this._grabbedObject) return;
+        this._grabbedObject.position.copy(this._arHitPosition);
+        this._grabbedObject.quaternion.copy(
+          this._arHitQuaternion.clone().multiply(this._touchQuaterion)
+        );
+        this._grabbedObject.scale.copy(
+          new import_three11.Vector3(
+            this._touchScale,
+            this._touchScale,
+            this._touchScale
+          ).multiply(this._arHitScale)
+        );
+      }
+      onTouchStart() {
+        const sceneHits = this._xrRaycaster.GetSceneIntersections();
+        console.log("sceneHits", sceneHits);
+        if (sceneHits.length === 0) return;
+        if (!sceneHits[0].object) return;
+        const moveable = findInterface(
+          sceneHits[0].object,
+          "isMovable"
+        );
+        if (!moveable) return;
+        this._grabbedObject = moveable;
+      }
+      onTouchMove() {
+        if (!this._frameBuffer) return;
+        if (!this._grabbedObject) return;
+        const intersections = this._xrRaycaster.GetARIntersections(
+          this._frameBuffer
+        );
+        if (intersections.length === 0) {
+          this._crosshair.visible = false;
+          return;
+        }
+        const hit = intersections[0];
+        this._crosshair.visible = true;
+        this._crosshair.matrix.copy(hit.matrix);
+        if (!this._grabbedObject) return;
+        if (!this._initialObjectPosition || !this._initialRaycastHit) {
+          this._initialObjectPosition = this._grabbedObject.position.clone();
+          this._initialRaycastHit = hit.point.clone();
+        }
+        hit.matrix.decompose(
+          this._arHitPosition,
+          this._arHitQuaternion,
+          this._arHitScale
+        );
+        this._deltaRaycastHit.copy(
+          hit.point.clone().sub(this._initialRaycastHit)
+        );
+        this._arHitPosition.copy(
+          this._initialObjectPosition.clone().add(this._deltaRaycastHit)
+        );
+        console.log("arHitPosition", this._arHitPosition);
+        this.updateObject();
+      }
+      onTouchEnd(payload) {
+        if (payload.touchCount === 0) {
+          this._crosshair.visible = false;
+          this._initialObjectPosition = null;
+          this._initialRaycastHit = null;
+          this._grabbedObject = null;
+        }
+      }
+      onRotateStart() {
+        this._startTouchQuaternion = this._touchQuaterion.clone();
+      }
+      onRotateMove(payload) {
+        this._touchQuaterion.setFromAxisAngle(
+          new import_three11.Vector3(0, -1, 0),
+          payload.delta * 3
+        );
+        this._touchQuaterion.multiply(this._startTouchQuaternion);
+        this.updateObject();
+      }
+      onPinchStart() {
+        this._startTouchScale = this._touchScale;
+      }
+      onPinchMove(payload) {
+        this._touchScale = this._startTouchScale * payload.current;
+        this.updateObject();
+      }
+      // prepare & cleanup scene
+      prepareScene() {
+        this._scene.XRRoot.XRModelRoot.matrixAutoUpdate = false;
+        this._scene.add(this._crosshair);
+        const children = [];
+        this._scene.Root.children.forEach((child) => {
+          const clone = child.clone();
+          clone.layers.enableAll();
+          clone.traverse((obj) => {
+            obj.layers.enableAll();
+            if (obj instanceof import_three11.Mesh) {
+              obj.scale.set(0.1, 0.1, 0.1);
+            }
+          });
+          clone.position.set(0, 0, 0);
+          children.push(clone);
+        });
+        this._scene.XRRoot.XRHandNode.add(...children);
+      }
+      restoreScene() {
+        this._scene.remove(this._crosshair);
+        this._scene.XRRoot.XRHandNode.clear();
+        this._scene.XRRoot.XRModelRoot.clear();
+        this._scene.XRRoot.XRModelRoot.matrixAutoUpdate = true;
+      }
+      // raycast
+      initRaycaster() {
+        return __async(this, null, function* () {
+          yield this._xrRaycaster.Init();
+          if (!this._xrRaycaster) {
+            console.error(
+              "Raycaster not initialized successfully. Aborting WebXR..."
+            );
+            this.Dispose();
+            return Promise.reject();
+          }
+        });
+      }
+    };
+  }
+});
+
+// src/ar/webxr/WebXR.ts
+var _DIVEWebXR, DIVEWebXR;
+var init_WebXR = __esm({
+  "src/ar/webxr/WebXR.ts"() {
+    "use strict";
+    init_Overlay();
+    init_WebXRController();
+    _DIVEWebXR = class _DIVEWebXR {
+      static Launch(renderer, scene, controller) {
+        return __async(this, null, function* () {
+          this._renderer = renderer;
+          this._scene = scene;
+          this._controller = controller;
+          this._cameraPosition = this._controller.object.position.clone();
+          this._cameraTarget = this._controller.target.clone();
+          if (!navigator.xr) {
+            console.error("WebXR not supported");
+            return Promise.reject();
+          }
+          this._renderer.xr.enabled = true;
+          this._scene.InitXR(renderer);
+          if (!_DIVEWebXR._overlay) {
+            const overlay = new Overlay();
+            _DIVEWebXR._overlay = overlay;
+          }
+          _DIVEWebXR._options.domOverlay = { root: _DIVEWebXR._overlay.Element };
+          const session = yield navigator.xr.requestSession(
+            "immersive-ar",
+            this._options
+          );
+          session.addEventListener("end", () => {
+            this._onSessionEnded();
+          });
+          renderer.xr.setReferenceSpaceType(this._referenceSpaceType);
+          yield renderer.xr.setSession(session);
+          _DIVEWebXR._overlay.Element.style.display = "";
+          this._session = session;
+          _DIVEWebXR._overlay.CloseButton.addEventListener(
+            "click",
+            () => this.End()
+          );
+          yield this._onSessionStarted();
+          return Promise.resolve();
+        });
+      }
+      static Update(_time, frame) {
+        if (!this._session) return;
+        if (this._xrController) {
+          this._xrController.Update(frame);
+        }
+      }
+      static End() {
+        if (!this._session) return;
+        this._session.end();
+      }
+      static _onSessionStarted() {
+        return __async(this, null, function* () {
+          if (!this._session) return;
+          this._renderCallbackId = this._renderer.AddPreRenderCallback(
+            (time, frame) => {
+              this.Update(time, frame);
+            }
+          );
+          this._xrController = new DIVEWebXRController(
+            this._session,
+            this._renderer,
+            this._scene
+          );
+          yield this._xrController.Init().catch(() => {
+            this.End();
+          });
+          return Promise.resolve();
+        });
+      }
+      static _onSessionEnded() {
+        if (!this._session) return;
+        if (this._xrController) {
+          this._xrController.Dispose();
+        }
+        if (this._renderCallbackId) {
+          this._renderer.RemovePreRenderCallback(this._renderCallbackId);
+          this._renderCallbackId = null;
+        }
+        this._renderer.xr.enabled = false;
+        const canvasWrapper = this._renderer.domElement.parentElement;
+        if (canvasWrapper) {
+          const { clientWidth, clientHeight } = canvasWrapper;
+          this._renderer.OnResize(clientWidth, clientHeight);
+          this._controller.object.OnResize(clientWidth, clientHeight);
+        }
+        this._controller.object.position.copy(this._cameraPosition);
+        this._controller.target.copy(this._cameraTarget);
+        this._cameraPosition.set(0, 0, 0);
+        this._cameraTarget.set(0, 0, 0);
+        this._scene.DisposeXR();
+        this._session.removeEventListener("end", this._onSessionEnded);
+        _DIVEWebXR._overlay.Element.style.display = "none";
+        this._session = null;
+      }
+    };
+    // render loop members
+    _DIVEWebXR._renderCallbackId = null;
+    // setup members
+    _DIVEWebXR._session = null;
+    _DIVEWebXR._referenceSpaceType = "local";
+    _DIVEWebXR._overlay = null;
+    _DIVEWebXR._options = {
+      requiredFeatures: [
+        "local",
+        "hit-test"
+      ],
+      optionalFeatures: [
+        "light-estimation",
+        "local-floor",
+        "dom-overlay",
+        "depth-sensing"
+      ],
+      depthSensing: {
+        usagePreference: ["gpu-optimized"],
+        dataFormatPreference: []
+      },
+      domOverlay: { root: {} }
+    };
+    _DIVEWebXR._xrController = null;
+    DIVEWebXR = _DIVEWebXR;
+  }
+});
+
+// src/ar/AR.ts
+var AR_exports = {};
+__export(AR_exports, {
+  DIVEAR: () => DIVEAR
+});
+var DIVEAR;
+var init_AR = __esm({
+  "src/ar/AR.ts"() {
+    "use strict";
+    init_Info();
+    init_ARQuickLook();
+    init_WebXR();
+    DIVEAR = class {
+      constructor(renderer, scene, controller) {
+        this.arPlacement = "floor";
+        this.arScale = "auto";
+        this._renderer = renderer;
+        this._scene = scene;
+        this._controller = controller;
+      }
+      Launch() {
+        return __async(this, null, function* () {
+          const system = DIVEInfo.GetSystem();
+          if (system === "iOS") {
+            const support = DIVEInfo.GetSupportsARQuickLook();
+            if (!support) {
+              console.log("ARQuickLook not supported");
+              return Promise.reject();
+            }
+            console.log("Launching AR on iOS");
+            yield DIVEARQuickLook.Launch(this._scene);
+            return Promise.resolve();
+          }
+          if (system === "Android") {
+            this.openSceneViewer();
+            return;
+            const support = yield DIVEInfo.GetSupportsWebXR();
+            if (!support) {
+              console.log(
+                "WebXR not supported. Reason: " + WebXRUnsupportedReason[DIVEInfo.GetWebXRUnsupportedReason()]
+              );
+              return Promise.reject();
+            }
+            console.log("Launching AR on Android");
+            yield DIVEWebXR.Launch(
+              this._renderer,
+              this._scene,
+              this._controller
+            );
+            return Promise.resolve();
+          }
+          console.log(
+            "AR not supported. Not a mobile system. (System is " + system + ")"
+          );
+        });
+      }
+      openSceneViewer() {
+        const src = this.createSceneViewerSrc();
+        const anchor = document.createElement("a");
+        const noArViewerSigil = "#model-viewer-no-ar-fallback";
+        const location = self.location.toString();
+        const locationUrl = new URL(location);
+        const modelUrl = new URL(src, location);
+        if (modelUrl.hash) modelUrl.hash = "";
+        const params = new URLSearchParams(modelUrl.search);
+        locationUrl.hash = noArViewerSigil;
+        params.set("mode", "ar_preferred");
+        if (!params.has("disable_occlusion")) {
+          params.set("disable_occlusion", "true");
+        }
+        if (this.arScale === "fixed") {
+          params.set("resizable", "false");
+        }
+        if (this.arPlacement === "wall") {
+          params.set("enable_vertical_placement", "true");
+        }
+        if (params.has("sound")) {
+          const soundUrl = new URL(params.get("sound"), location);
+          params.set("sound", soundUrl.toString());
+        }
+        if (params.has("link")) {
+          const linkUrl = new URL(params.get("link"), location);
+          params.set("link", linkUrl.toString());
+        }
+        console.log("modelUrl.toString()", modelUrl.toString());
+        console.log(
+          "encodeURIComponent(modelUrl.toString())",
+          encodeURIComponent(modelUrl.toString())
+        );
+        const intent = `intent://arvr.google.com/scene-viewer/1.0?${params.toString() + "&file=" + modelUrl.toString()}#Intent;scheme=https;package=com.google.android.googlequicksearchbox;action=android.intent.action.VIEW;S.browser_fallback_url=${encodeURIComponent(
+          locationUrl.toString()
+        )};end;`;
+        console.log({ intent });
+        const undoHashChange = () => {
+          if (self.location.hash === noArViewerSigil) {
+            self.history.back();
+            console.warn(
+              "Error while trying to present in AR with Scene Viewer"
+            );
+            console.warn("Falling back to next ar-mode");
+          }
+        };
+        self.addEventListener("hashchange", undoHashChange, { once: true });
+        anchor.setAttribute("href", intent);
+        console.log("Attempting to present in AR with Scene Viewer...");
+        anchor.click();
+      }
+      createSceneViewerSrc() {
+        let uri = null;
+        this._scene.traverse((object) => {
+          if (uri) return;
+          if (object.userData.uri) {
+            uri = object.userData.uri;
+          }
+        });
+        if (!uri) {
+          throw new Error("No model found in scene");
+        }
+        return uri;
+      }
+    };
+  }
+});
+
 // src/dive.ts
 var dive_exports = {};
 __export(dive_exports, {
@@ -686,8 +2078,8 @@ var DIVERenderer = class extends import_three.WebGLRenderer {
   }
   // Starts the renderer with the given scene and camera.
   StartRenderer(scene, cam) {
-    this.setAnimationLoop(() => {
-      this.internal_render(scene, cam);
+    this.setAnimationLoop((time, frame) => {
+      this.internal_render(scene, cam, time, frame);
     });
     this.running = true;
   }
@@ -761,24 +2153,24 @@ var DIVERenderer = class extends import_three.WebGLRenderer {
    * @param scene Scene to render.
    * @param cam Camera to render with.
    */
-  internal_render(scene, cam) {
+  internal_render(scene, cam, time, frame) {
     if ((this.paused || !this.running) && !this.force) return;
     this.preRenderCallbacks.forEach((callback) => {
-      callback();
+      callback(time, frame);
     });
     this.render(scene, cam);
     this.postRenderCallbacks.forEach((callback) => {
-      callback();
+      callback(time, frame);
     });
     this.force = false;
   }
 };
 
 // src/scene/Scene.ts
-var import_three14 = require("three");
+var import_three23 = require("three");
 
 // src/scene/root/Root.ts
-var import_three11 = require("three");
+var import_three18 = require("three");
 
 // src/light/AmbientLight.ts
 var import_three2 = require("three");
@@ -805,7 +2197,7 @@ var DIVEAmbientLight = class extends import_three2.Object3D {
 };
 
 // src/light/PointLight.ts
-var import_three5 = require("three");
+var import_three12 = require("three");
 
 // src/com/Communication.ts
 var import_MathUtils = require("three/src/math/MathUtils");
@@ -823,6 +2215,7 @@ var _DIVECommunication = class _DIVECommunication {
     this.toolbox = toolbox;
     this._mediaGenerator = null;
     this._io = null;
+    this._ar = null;
     _DIVECommunication.__instances.push(this);
   }
   static get(id) {
@@ -857,6 +2250,13 @@ var _DIVECommunication = class _DIVECommunication {
     }
     return this._io;
   }
+  get ar() {
+    if (!this._ar) {
+      const DIVEAR2 = (init_AR(), __toCommonJS(AR_exports)).DIVEAR;
+      this._ar = new DIVEAR2(this.renderer, this.scene, this.controller);
+    }
+    return this._ar;
+  }
   DestroyInstance() {
     const existingIndex = _DIVECommunication.__instances.findIndex(
       (entry) => entry.id === this.id
@@ -1024,6 +2424,11 @@ var _DIVECommunication = class _DIVECommunication {
         );
         break;
       }
+      case "LAUNCH_AR": {
+        this.ar.Launch();
+        returnValue = true;
+        break;
+      }
       default: {
         console.warn(
           `DIVECommunication.PerformAction: has been executed with unknown Action type ${action}`
@@ -1307,7 +2712,7 @@ var DIVECommunication = _DIVECommunication;
 
 // src/light/PointLight.ts
 init_VisibilityLayerMask();
-var DIVEPointLight = class extends import_three5.Object3D {
+var DIVEPointLight = class extends import_three12.Object3D {
   constructor() {
     super();
     this.isDIVELight = true;
@@ -1316,25 +2721,25 @@ var DIVEPointLight = class extends import_three5.Object3D {
     this.isSelectable = true;
     this.gizmo = null;
     this.name = "DIVEPointLight";
-    this.light = new import_three5.PointLight(16777215, 1);
+    this.light = new import_three12.PointLight(16777215, 1);
     this.light.layers.mask = PRODUCT_LAYER_MASK;
     this.light.castShadow = true;
     this.light.shadow.mapSize.width = 512;
     this.light.shadow.mapSize.height = 512;
     this.add(this.light);
     const geoSize = 0.1;
-    const geometry = new import_three5.SphereGeometry(
+    const geometry = new import_three12.SphereGeometry(
       geoSize,
       geoSize * 320,
       geoSize * 320
     );
-    const material = new import_three5.MeshBasicMaterial({
+    const material = new import_three12.MeshBasicMaterial({
       color: this.light.color,
       transparent: true,
       opacity: 0.8,
-      side: import_three5.FrontSide
+      side: import_three12.FrontSide
     });
-    this.mesh = new import_three5.Mesh(geometry, material);
+    this.mesh = new import_three12.Mesh(geometry, material);
     this.mesh.layers.mask = UI_LAYER_MASK;
     this.add(this.mesh);
   }
@@ -1374,18 +2779,18 @@ var DIVEPointLight = class extends import_three5.Object3D {
 
 // src/light/SceneLight.ts
 init_VisibilityLayerMask();
-var import_three6 = require("three");
-var DIVESceneLight = class extends import_three6.Object3D {
+var import_three13 = require("three");
+var DIVESceneLight = class extends import_three13.Object3D {
   constructor() {
     super();
     this.isDIVELight = true;
     this.isDIVESceneLight = true;
     this.name = "DIVESceneLight";
-    this._hemiLight = new import_three6.HemisphereLight(16777215, 16777215, 2);
+    this._hemiLight = new import_three13.HemisphereLight(16777215, 16777215, 2);
     this._hemiLight.layers.mask = PRODUCT_LAYER_MASK;
     this._hemiLight.position.set(0, 50, 0);
     this.add(this._hemiLight);
-    this._dirLight = new import_three6.DirectionalLight(16777215, 3);
+    this._dirLight = new import_three13.DirectionalLight(16777215, 3);
     this._dirLight.layers.mask = PRODUCT_LAYER_MASK;
     this._dirLight.position.set(1, 1.75, 1);
     this._dirLight.position.multiplyScalar(30);
@@ -1415,7 +2820,7 @@ var DIVESceneLight = class extends import_three6.Object3D {
 };
 
 // src/model/Model.ts
-var import_three8 = require("three");
+var import_three15 = require("three");
 init_VisibilityLayerMask();
 
 // src/helper/findSceneRecursive/findSceneRecursive.ts
@@ -1427,9 +2832,9 @@ var findSceneRecursive = (object) => {
 };
 
 // src/node/Node.ts
-var import_three7 = require("three");
+var import_three14 = require("three");
 init_VisibilityLayerMask();
-var DIVENode = class extends import_three7.Object3D {
+var DIVENode = class extends import_three14.Object3D {
   constructor() {
     super();
     this.isDIVENode = true;
@@ -1437,15 +2842,15 @@ var DIVENode = class extends import_three7.Object3D {
     this.isMovable = true;
     this.gizmo = null;
     this.layers.mask = PRODUCT_LAYER_MASK;
-    this._positionWorldBuffer = new import_three7.Vector3();
-    this._boundingBox = new import_three7.Box3();
+    this._positionWorldBuffer = new import_three14.Vector3();
+    this._boundingBox = new import_three14.Box3();
   }
   SetPosition(position) {
     if (!this.parent) {
       this.position.set(position.x, position.y, position.z);
       return;
     }
-    const newPosition = new import_three7.Vector3(position.x, position.y, position.z);
+    const newPosition = new import_three14.Vector3(position.x, position.y, position.z);
     this.position.copy(this.parent.worldToLocal(newPosition));
     if ("isDIVEGroup" in this.parent) {
       this.parent.UpdateLineTo(this);
@@ -1533,7 +2938,7 @@ var DIVEModel = class extends DIVENode {
   }
   SetMaterial(material) {
     if (!this._material) {
-      this._material = new import_three8.MeshStandardMaterial();
+      this._material = new import_three15.MeshStandardMaterial();
     }
     if (material.vertexColors !== void 0) {
       this._material.vertexColors = material.vertexColors;
@@ -1595,10 +3000,10 @@ var DIVEModel = class extends DIVENode {
     }
     const bottomY = this._boundingBox.min.y * this.scale.y;
     const bbBottomCenter = this.localToWorld(
-      this._boundingBox.getCenter(new import_three8.Vector3()).multiply(this.scale)
+      this._boundingBox.getCenter(new import_three15.Vector3()).multiply(this.scale)
     );
     bbBottomCenter.y = bottomY + this.position.y;
-    const raycaster = new import_three8.Raycaster(bbBottomCenter, new import_three8.Vector3(0, -1, 0));
+    const raycaster = new import_three15.Raycaster(bbBottomCenter, new import_three15.Vector3(0, -1, 0));
     raycaster.layers.mask = PRODUCT_LAYER_MASK;
     const intersections = raycaster.intersectObjects(
       findSceneRecursive(this).Root.children,
@@ -1610,7 +3015,7 @@ var DIVEModel = class extends DIVENode {
       const meshBB = mesh.geometry.boundingBox;
       const worldPos = mesh.localToWorld(meshBB.max.clone());
       const oldPos = this.position.clone();
-      const newPos = this.position.clone().setY(worldPos.y).sub(new import_three8.Vector3(0, bottomY, 0));
+      const newPos = this.position.clone().setY(worldPos.y).sub(new import_three15.Vector3(0, bottomY, 0));
       this.position.copy(newPos);
       if (this.position.y === oldPos.y) return;
       this.onMove();
@@ -1619,13 +3024,13 @@ var DIVEModel = class extends DIVENode {
 };
 
 // src/loadingmanager/LoadingManager.ts
-var import_Addons2 = require("three/examples/jsm/Addons.js");
+var import_Addons = require("three/examples/jsm/Addons.js");
 var DIVELoadingManager = class {
   // ... maybe extend with other loaders later
   constructor() {
     this.progress = /* @__PURE__ */ new Map();
-    this.gltfloader = new import_Addons2.GLTFLoader();
-    this.dracoloader = new import_Addons2.DRACOLoader();
+    this.gltfloader = new import_Addons.GLTFLoader();
+    this.dracoloader = new import_Addons.DRACOLoader();
     this.dracoloader.setDecoderPath(
       "https://www.gstatic.com/draco/v1/decoders/"
     );
@@ -1653,17 +3058,17 @@ var DIVELoadingManager = class {
 };
 
 // src/primitive/Primitive.ts
-var import_three9 = require("three");
+var import_three16 = require("three");
 init_VisibilityLayerMask();
 var DIVEPrimitive = class extends DIVENode {
   constructor() {
     super();
     this.isDIVEPrimitive = true;
-    this._mesh = new import_three9.Mesh();
+    this._mesh = new import_three16.Mesh();
     this._mesh.layers.mask = PRODUCT_LAYER_MASK;
     this._mesh.castShadow = true;
     this._mesh.receiveShadow = true;
-    this._mesh.material = new import_three9.MeshStandardMaterial();
+    this._mesh.material = new import_three16.MeshStandardMaterial();
     this.add(this._mesh);
   }
   SetGeometry(geometry) {
@@ -1678,7 +3083,7 @@ var DIVEPrimitive = class extends DIVENode {
       primitiveMaterial.vertexColors = material.vertexColors;
     }
     if (material.color !== void 0) {
-      primitiveMaterial.color = new import_three9.Color(material.color);
+      primitiveMaterial.color = new import_three16.Color(material.color);
     }
     if (material.map !== void 0) {
       primitiveMaterial.map = material.map;
@@ -1732,10 +3137,10 @@ var DIVEPrimitive = class extends DIVENode {
     }
     const bottomY = this._boundingBox.min.y * this.scale.y;
     const bbBottomCenter = this.localToWorld(
-      this._boundingBox.getCenter(new import_three9.Vector3()).multiply(this.scale)
+      this._boundingBox.getCenter(new import_three16.Vector3()).multiply(this.scale)
     );
     bbBottomCenter.y = bottomY + this.position.y;
-    const raycaster = new import_three9.Raycaster(bbBottomCenter, new import_three9.Vector3(0, -1, 0));
+    const raycaster = new import_three16.Raycaster(bbBottomCenter, new import_three16.Vector3(0, -1, 0));
     raycaster.layers.mask = PRODUCT_LAYER_MASK;
     const intersections = raycaster.intersectObjects(
       findSceneRecursive(this).Root.children,
@@ -1747,7 +3152,7 @@ var DIVEPrimitive = class extends DIVENode {
       const meshBB = mesh.geometry.boundingBox;
       const worldPos = mesh.localToWorld(meshBB.max.clone());
       const oldPos = this.position.clone();
-      const newPos = this.position.clone().setY(worldPos.y).sub(new import_three9.Vector3(0, bottomY, 0));
+      const newPos = this.position.clone().setY(worldPos.y).sub(new import_three16.Vector3(0, bottomY, 0));
       this.position.copy(newPos);
       if (this.position.y === oldPos.y) return;
       this.onMove();
@@ -1782,7 +3187,7 @@ var DIVEPrimitive = class extends DIVENode {
     }
   }
   createCylinderGeometry(geometry) {
-    const geo = new import_three9.CylinderGeometry(
+    const geo = new import_three16.CylinderGeometry(
       geometry.width / 2,
       geometry.width / 2,
       geometry.height,
@@ -1792,7 +3197,7 @@ var DIVEPrimitive = class extends DIVENode {
     return geo;
   }
   createSphereGeometry(geometry) {
-    const geo = new import_three9.SphereGeometry(geometry.width / 2, 256, 256);
+    const geo = new import_three16.SphereGeometry(geometry.width / 2, 256, 256);
     return geo;
   }
   createPyramidGeometry(geometry) {
@@ -1837,19 +3242,19 @@ var DIVEPrimitive = class extends DIVENode {
       4,
       0
     ]);
-    const geometryBuffer = new import_three9.BufferGeometry();
+    const geometryBuffer = new import_three16.BufferGeometry();
     geometryBuffer.setAttribute(
       "position",
-      new import_three9.BufferAttribute(vertices, 3)
+      new import_three16.BufferAttribute(vertices, 3)
     );
-    geometryBuffer.setIndex(new import_three9.BufferAttribute(indices, 1));
+    geometryBuffer.setIndex(new import_three16.BufferAttribute(indices, 1));
     geometryBuffer.computeVertexNormals();
     geometryBuffer.computeBoundingBox();
     geometryBuffer.computeBoundingSphere();
     return geometryBuffer;
   }
   createBoxGeometry(geometry) {
-    const geo = new import_three9.BoxGeometry(
+    const geo = new import_three16.BoxGeometry(
       geometry.width,
       geometry.height,
       geometry.depth
@@ -1858,12 +3263,12 @@ var DIVEPrimitive = class extends DIVENode {
     return geo;
   }
   createConeGeometry(geometry) {
-    const geo = new import_three9.ConeGeometry(geometry.width / 2, geometry.height, 256);
+    const geo = new import_three16.ConeGeometry(geometry.width / 2, geometry.height, 256);
     geo.translate(0, geometry.height / 2, 0);
     return geo;
   }
   createWallGeometry(geometry) {
-    const geo = new import_three9.BoxGeometry(
+    const geo = new import_three16.BoxGeometry(
       geometry.width,
       geometry.height,
       geometry.depth || 0.05,
@@ -1873,7 +3278,7 @@ var DIVEPrimitive = class extends DIVENode {
     return geo;
   }
   createPlaneGeometry(geometry) {
-    const geo = new import_three9.BoxGeometry(
+    const geo = new import_three16.BoxGeometry(
       geometry.width,
       geometry.height,
       geometry.depth
@@ -1884,7 +3289,7 @@ var DIVEPrimitive = class extends DIVENode {
 };
 
 // src/group/Group.ts
-var import_three10 = require("three");
+var import_three17 = require("three");
 var DIVEGroup = class extends DIVENode {
   // lines to children
   constructor() {
@@ -1946,13 +3351,13 @@ var DIVEGroup = class extends DIVENode {
    * Adds a line to this grouo as last child.
    */
   createLine() {
-    const geo = new import_three10.BufferGeometry();
-    const mat = new import_three10.LineDashedMaterial({
+    const geo = new import_three17.BufferGeometry();
+    const mat = new import_three17.LineDashedMaterial({
       color: 6710886,
       dashSize: 0.05,
       gapSize: 0.025
     });
-    const line = new import_three10.Line(geo, mat);
+    const line = new import_three17.Line(geo, mat);
     line.visible = false;
     return line;
   }
@@ -1961,7 +3366,7 @@ var DIVEGroup = class extends DIVENode {
    */
   updateLineTo(line, object) {
     line.geometry.setFromPoints([
-      new import_three10.Vector3(0, 0, 0),
+      new import_three17.Vector3(0, 0, 0),
       object.position.clone()
     ]);
     line.computeLineDistances();
@@ -2016,7 +3421,7 @@ var DIVEGroup = class extends DIVENode {
 };
 
 // src/scene/root/Root.ts
-var DIVERoot = class extends import_three11.Object3D {
+var DIVERoot = class extends import_three18.Object3D {
   constructor() {
     super();
     this.isDIVERoot = true;
@@ -2024,7 +3429,7 @@ var DIVERoot = class extends import_three11.Object3D {
     this.loadingManager = new DIVELoadingManager();
   }
   ComputeSceneBB() {
-    const bb = new import_three11.Box3();
+    const bb = new import_three18.Box3();
     this.traverse((object) => {
       if ("isObject3D" in object) {
         bb.expandByObject(object);
@@ -2188,7 +3593,7 @@ var DIVERoot = class extends import_three11.Object3D {
       );
     if (light.color !== void 0 && light.color !== null)
       sceneObject.SetColor(
-        new import_three11.Color(light.color)
+        new import_three18.Color(light.color)
       );
     if (light.visible !== void 0 && light.visible !== null)
       sceneObject.visible = light.visible;
@@ -2201,6 +3606,7 @@ var DIVERoot = class extends import_three11.Object3D {
       const created = new DIVEModel();
       sceneObject = created;
       sceneObject.userData.id = model.id;
+      sceneObject.userData.uri = model.uri;
       this.add(sceneObject);
     }
     if (model.uri !== void 0) {
@@ -2359,12 +3765,12 @@ var GRID_SIDE_LINE_COLOR = "#dddddd";
 
 // src/grid/Grid.ts
 init_VisibilityLayerMask();
-var import_three12 = require("three");
-var DIVEGrid = class extends import_three12.Object3D {
+var import_three19 = require("three");
+var DIVEGrid = class extends import_three19.Object3D {
   constructor() {
     super();
     this.name = "Grid";
-    const grid = new import_three12.GridHelper(
+    const grid = new import_three19.GridHelper(
       100,
       100,
       GRID_CENTER_LINE_COLOR,
@@ -2380,14 +3786,14 @@ var DIVEGrid = class extends import_three12.Object3D {
 };
 
 // src/primitive/floor/Floor.ts
-var import_three13 = require("three");
+var import_three20 = require("three");
 init_VisibilityLayerMask();
-var DIVEFloor = class extends import_three13.Mesh {
+var DIVEFloor = class extends import_three20.Mesh {
   constructor() {
     super(
-      new import_three13.PlaneGeometry(1e4, 1e4),
-      new import_three13.MeshStandardMaterial({
-        color: new import_three13.Color(150 / 255, 150 / 255, 150 / 255)
+      new import_three20.PlaneGeometry(1e4, 1e4),
+      new import_three20.MeshStandardMaterial({
+        color: new import_three20.Color(150 / 255, 150 / 255, 150 / 255)
       })
     );
     this.isFloor = true;
@@ -2400,33 +3806,148 @@ var DIVEFloor = class extends import_three13.Mesh {
     this.visible = visible;
   }
   SetColor(color) {
-    this.material.color = new import_three13.Color(color);
+    this.material.color = new import_three20.Color(color);
+  }
+};
+
+// src/scene/xrroot/XRRoot.ts
+var import_three22 = require("three");
+
+// src/scene/xrroot/xrlightroot/XRLightRoot.ts
+var import_XREstimatedLight = require("three/examples/jsm/webxr/XREstimatedLight");
+var import_three21 = require("three");
+init_VisibilityLayerMask();
+var DIVEXRLightRoot = class extends import_three21.Object3D {
+  constructor(scene) {
+    super();
+    this.name = "XRLightRoot";
+    this._scene = scene;
+    this._xrLight = null;
+    this._lightRoot = new DIVERoot();
+    this._lightRoot.UpdateSceneObject({
+      id: "XRSceneLight",
+      entityType: "light",
+      name: "XRSceneLight",
+      type: "scene",
+      color: 16777215,
+      intensity: 1,
+      enabled: true,
+      visible: true
+    });
+    this.add(this._lightRoot);
+  }
+  InitLightEstimation(renderer) {
+    if (!this._xrLight) {
+      this._xrLight = new import_XREstimatedLight.XREstimatedLight(renderer, true);
+      this._xrLight.layers.mask = PRODUCT_LAYER_MASK;
+      this.add(this._xrLight);
+    }
+    this._xrLight.addEventListener("estimationstart", () => {
+      this.onEstimationStart();
+    });
+    this._xrLight.addEventListener("estimationend", () => {
+      this.onEstimationEnd();
+    });
+  }
+  DisposeLightEstimation() {
+    if (!this._xrLight) return;
+    this._xrLight.removeEventListener("estimationstart", () => {
+      this.onEstimationStart();
+    });
+    this._xrLight.removeEventListener("estimationend", () => {
+      this.onEstimationEnd();
+    });
+  }
+  onEstimationStart() {
+    this._lightRoot.visible = false;
+    if (!this._xrLight) return;
+    if (this._xrLight.environment) {
+      this._scene.environment = this._xrLight.environment;
+    }
+  }
+  onEstimationEnd() {
+    this._lightRoot.visible = true;
+    this._scene.environment = null;
+    if (!this._xrLight) return;
+  }
+};
+
+// src/scene/xrroot/XRRoot.ts
+var DIVEXRRoot = class extends import_three22.Object3D {
+  get XRModelRoot() {
+    return this._xrModelRoot;
+  }
+  get XRLightRoot() {
+    return this._xrLightRoot;
+  }
+  get XRHandNode() {
+    return this._xrHandNode;
+  }
+  constructor(scene) {
+    super();
+    this.name = "XRRoot";
+    this._xrModelRoot = new DIVERoot();
+    this._xrModelRoot.name = "XRModelRoot";
+    this.add(this._xrModelRoot);
+    this._xrShadowPlane = new import_three22.Mesh(
+      new import_three22.PlaneGeometry(100, 100),
+      new import_three22.ShadowMaterial({ opacity: 1, transparent: true })
+    );
+    this._xrModelRoot.add(this._xrShadowPlane);
+    this._xrLightRoot = new DIVEXRLightRoot(scene);
+    this._xrLightRoot.name = "XRLightRoot";
+    this.add(this._xrLightRoot);
+    this._xrHandNode = new import_three22.Object3D();
+    this._xrHandNode.name = "XRHandNode";
+    this.add(this._xrHandNode);
+  }
+  InitLightEstimation(renderer) {
+    this._xrLightRoot.InitLightEstimation(renderer);
+  }
+  DisposeLightEstimation() {
+    this._xrLightRoot.DisposeLightEstimation();
   }
 };
 
 // src/scene/Scene.ts
-var DIVEScene = class extends import_three14.Scene {
+var DIVEScene = class extends import_three23.Scene {
   get Root() {
-    return this.root;
+    return this._root;
+  }
+  get XRRoot() {
+    return this._xrRoot;
   }
   get Floor() {
-    return this.floor;
+    return this._floor;
   }
   get Grid() {
-    return this.grid;
+    return this._grid;
   }
   constructor() {
     super();
-    this.background = new import_three14.Color(16777215);
-    this.root = new DIVERoot();
-    this.add(this.root);
-    this.floor = new DIVEFloor();
-    this.add(this.floor);
-    this.grid = new DIVEGrid();
-    this.add(this.grid);
+    this.background = new import_three23.Color(16777215);
+    this._root = new DIVERoot();
+    this.add(this._root);
+    this._floor = new DIVEFloor();
+    this.add(this._floor);
+    this._grid = new DIVEGrid();
+    this.add(this._grid);
+    this._xrRoot = new DIVEXRRoot(this);
+    this._xrRoot.visible = false;
+    this.add(this._xrRoot);
+  }
+  InitXR(renderer) {
+    this._root.visible = false;
+    this._xrRoot.visible = true;
+    this._xrRoot.InitLightEstimation(renderer);
+  }
+  DisposeXR() {
+    this._root.visible = true;
+    this._xrRoot.visible = false;
+    this._xrRoot.DisposeLightEstimation();
   }
   SetBackground(color) {
-    this.background = new import_three14.Color(color);
+    this.background = new import_three23.Color(color);
   }
   ComputeSceneBB() {
     return this.Root.ComputeSceneBB();
@@ -2453,7 +3974,7 @@ init_PerspectiveCamera();
 
 // src/controls/OrbitControls.ts
 var import_OrbitControls = require("three/examples/jsm/controls/OrbitControls");
-var import_three15 = require("three");
+var import_three24 = require("three");
 var import_tween = require("@tweenjs/tween.js");
 var DIVEOrbitControlsDefaultSettings = {
   enableDamping: true,
@@ -2495,8 +4016,8 @@ var _DIVEOrbitControls = class _DIVEOrbitControls extends import_OrbitControls.O
     this.dispose();
   }
   ComputeEncompassingView(bb) {
-    const center = bb.getCenter(new import_three15.Vector3());
-    const size = bb.getSize(new import_three15.Vector3());
+    const center = bb.getCenter(new import_three24.Vector3());
+    const size = bb.getSize(new import_three24.Vector3());
     const distance = Math.max(size.x, size.y, size.z) * 1.25;
     const direction = this.object.position.clone().normalize();
     return {
@@ -2507,7 +4028,7 @@ var _DIVEOrbitControls = class _DIVEOrbitControls extends import_OrbitControls.O
   ZoomIn(by) {
     const zoomBy = by || _DIVEOrbitControls.DEFAULT_ZOOM_FACTOR;
     const { minDistance, maxDistance } = this;
-    this.minDistance = this.maxDistance = import_three15.MathUtils.clamp(
+    this.minDistance = this.maxDistance = import_three24.MathUtils.clamp(
       this.getDistance() - zoomBy,
       minDistance + zoomBy,
       maxDistance - zoomBy
@@ -2519,7 +4040,7 @@ var _DIVEOrbitControls = class _DIVEOrbitControls extends import_OrbitControls.O
   ZoomOut(by) {
     const zoomBy = by || _DIVEOrbitControls.DEFAULT_ZOOM_FACTOR;
     const { minDistance, maxDistance } = this;
-    this.minDistance = this.maxDistance = import_three15.MathUtils.clamp(
+    this.minDistance = this.maxDistance = import_three24.MathUtils.clamp(
       this.getDistance() + zoomBy,
       minDistance + zoomBy,
       maxDistance - zoomBy
@@ -2702,7 +4223,7 @@ var DIVEAnimationSystem = class {
 };
 
 // src/axiscamera/AxisCamera.ts
-var import_three16 = require("three");
+var import_three25 = require("three");
 var import_three_spritetext = __toESM(require("three-spritetext"), 1);
 init_VisibilityLayerMask();
 
@@ -2715,18 +4236,18 @@ var AxesColorGreen = AxesColorGreenLetter;
 var AxesColorBlue = AxesColorBlueLetter;
 
 // src/axiscamera/AxisCamera.ts
-var DIVEAxisCamera = class extends import_three16.OrthographicCamera {
+var DIVEAxisCamera = class extends import_three25.OrthographicCamera {
   constructor(renderer, scene, controls) {
     super(-1, 1, 1, -1, 0.1, 100);
     this.layers.mask = COORDINATE_LAYER_MASK;
-    this.axesHelper = new import_three16.AxesHelper(0.5);
+    this.axesHelper = new import_three25.AxesHelper(0.5);
     this.axesHelper.layers.mask = COORDINATE_LAYER_MASK;
     this.axesHelper.material.depthTest = false;
     this.axesHelper.position.set(0, 0, -1);
     this.axesHelper.setColors(
-      new import_three16.Color(AxesColorRed),
-      new import_three16.Color(AxesColorGreen),
-      new import_three16.Color(AxesColorBlue)
+      new import_three25.Color(AxesColorRed),
+      new import_three25.Color(AxesColorGreen),
+      new import_three25.Color(AxesColorBlue)
     );
     const x = new import_three_spritetext.default("X", 0.2, AxesColorRedLetter);
     const y = new import_three_spritetext.default("Y", 0.2, AxesColorGreenLetter);
@@ -2744,7 +4265,7 @@ var DIVEAxisCamera = class extends import_three16.OrthographicCamera {
     this._renderer = renderer;
     this._scene = scene;
     this._scene.add(this);
-    const restoreViewport = new import_three16.Vector4();
+    const restoreViewport = new import_three25.Vector4();
     this._renderCallbackId = renderer.AddPostRenderCallback(() => {
       const restoreBackground = scene.background;
       scene.background = null;
@@ -2764,7 +4285,7 @@ var DIVEAxisCamera = class extends import_three16.OrthographicCamera {
   }
   SetFromCameraMatrix(matrix) {
     this.axesHelper.rotation.setFromRotationMatrix(
-      new import_three16.Matrix4().extractRotation(matrix).invert()
+      new import_three25.Matrix4().extractRotation(matrix).invert()
     );
   }
 };
@@ -2837,108 +4358,12 @@ var getObjectDelta = (a, b) => {
 
 // src/dive.ts
 var import_MathUtils2 = require("three/src/math/MathUtils");
-
-// src/info/Info.ts
-var DIVEInfo = class {
-  /**
-   *
-   * @returns The system the user is using. Possible values are "Android", "iOS", "Windows", "MacOS", "Linux" or "Unknown".
-   */
-  static GetSystem() {
-    const platform = navigator.platform;
-    if (/Android/.test(navigator.userAgent)) {
-      return "Android";
-    } else if (/iPhone|iPad|iPod/.test(navigator.userAgent)) {
-      return "iOS";
-    } else if (platform.startsWith("Win")) {
-      return "Windows";
-    } else if (platform.startsWith("Mac")) {
-      return "MacOS";
-    } else if (platform.startsWith("Linux")) {
-      return "Linux";
-    } else {
-      return "Unknown";
-    }
-  }
-  /**
-   * @returns A promise that resolves to a boolean indicating whether the user's device supports WebXR.
-   */
-  static GetSupportsWebXR() {
-    return __async(this, null, function* () {
-      if (this._supportsWebXR !== null) {
-        return this._supportsWebXR;
-      }
-      if (!navigator.xr) {
-        this._supportsWebXR = false;
-        return this._supportsWebXR;
-      }
-      try {
-        const supported = yield navigator.xr.isSessionSupported("immersive-ar");
-        this._supportsWebXR = supported;
-      } catch (error) {
-        this._supportsWebXR = false;
-      }
-      return this._supportsWebXR;
-    });
-  }
-  /**
-   * @returns A boolean indicating whether the user's device supports AR Quick Look.
-   */
-  static GetSupportsARQuickLook() {
-    const a = document.createElement("a");
-    if (a.relList.supports("ar")) {
-      return true;
-    }
-    const userAgent = navigator.userAgent;
-    const isIOS = /iPad|iPhone|iPod/.test(userAgent) && !window.MSStream;
-    if (!isIOS) {
-      return false;
-    }
-    const match = userAgent.match(/OS (\d+)_/);
-    if (!match || match.length < 2) {
-      return false;
-    }
-    const iOSVersion = parseInt(match[1], 10);
-    const minQuickLookVersion = 12;
-    if (iOSVersion < minQuickLookVersion) {
-      return false;
-    }
-    const isSupportedBrowser = /^((?!chrome|android).)*safari|CriOS|FxiOS/i.test(userAgent);
-    if (isSupportedBrowser) {
-      return true;
-    }
-    return false;
-  }
-  /**
-   * @returns A boolean indicating whether the user's device is a mobile device.
-   */
-  static get isMobile() {
-    return this.GetSystem() === "Android" || this.GetSystem() === "iOS";
-  }
-  /**
-   * @returns A boolean indicating whether the user's device is a desktop device.
-   */
-  static get isDesktop() {
-    return !this.isMobile;
-  }
-  /**
-   * @returns A promise that resolves to a boolean indicating whether the user's device is capable of AR.
-   */
-  static GetIsARCapable() {
-    return __async(this, null, function* () {
-      if (this.GetSupportsARQuickLook()) {
-        return true;
-      }
-      return yield this.GetSupportsWebXR();
-    });
-  }
-};
-DIVEInfo._supportsWebXR = null;
+init_Info();
 
 // package.json
 var package_default = {
   name: "@shopware-ag/dive",
-  version: "1.16.24",
+  version: "1.16.25-beta.1",
   description: "Shopware Spatial Framework",
   type: "module",
   main: "./build/dive.cjs",
@@ -3057,15 +4482,15 @@ function truncateExp(number, decimals = 0) {
 }
 
 // src/math/radToDeg/radToDeg.ts
-var import_three17 = require("three");
+var import_three26 = require("three");
 function radToDeg(radians) {
-  return (import_three17.MathUtils.radToDeg(radians) + 360) % 360;
+  return (import_three26.MathUtils.radToDeg(radians) + 360) % 360;
 }
 
 // src/math/degToRad/degToRad.ts
-var import_three18 = require("three");
+var import_three27 = require("three");
 function degToRad(degrees) {
-  return import_three18.MathUtils.degToRad(degrees);
+  return import_three27.MathUtils.degToRad(degrees);
 }
 
 // src/math/index.ts
@@ -3090,8 +4515,8 @@ var DIVEDefaultSettings = {
 };
 var DIVE = class _DIVE {
   // static members
-  static QuickView(uri) {
-    const dive = new _DIVE();
+  static QuickView(uri, settings) {
+    const dive = new _DIVE(settings);
     dive.Communication.PerformAction("SET_CAMERA_TRANSFORM", {
       position: { x: 0, y: 2, z: 2 },
       target: { x: 0, y: 0.5, z: 0 }
@@ -3110,9 +4535,6 @@ var DIVE = class _DIVE {
     const modelid = (0, import_MathUtils2.generateUUID)();
     dive.Communication.Subscribe("MODEL_LOADED", (data) => {
       if (data.id !== modelid) return;
-      dive.Communication.PerformAction("PLACE_ON_FLOOR", {
-        id: modelid
-      });
       const transform = dive.Communication.PerformAction(
         "COMPUTE_ENCOMPASSING_VIEW",
         {}
@@ -3235,9 +4657,40 @@ var DIVE = class _DIVE {
         console.log(this.scene);
       }
     };
-    console.log(
-      `DIVE ${package_default.version} initialized ${false ? "in development mode" : ""}`
-    );
+    console.log(`DIVE ${package_default.version} initialized successfully!`);
+    if (false) {
+      console.log("DIVE is running in development mode.");
+    }
+    console.log(`
+                    @@@@@@@@@@@@@@@@@@@@@@@              @@@@@@@@@@@@@@@@@@@@@@@
+               @@@@+-:::::::---------------------==------------------------------=#@@@@
+            @@%=::::.......::---------------------------------------------------------+@@
+          @@+:::...........::-----------------------------------------------------------#@@
+        @@=:::.........::::::-------------------------------------------------------------%@
+       @%:::.......:::::::-----------------------------------------------------------------#@
+      @*:::.....:::::-----------------------------------------------------------------------*@
+     @%::::::.::::---------------------------------------------------------------------------@@
+    @@-:::::::::-----------------------------------------------------------------------------=@
+    @%::::::::--------------------------------------------------------------------------------%@
+    @+::::::::--------------------------------=@@@@@%-----------------------------------------%@
+    @=:::::::--------------------------------*@@    @@+---------------------------------------#@
+    @+:::::::-------------------------------*@        @*--------------------------------------%@
+    @#::::::::-----------------------------=@@        @@=-------------------------------------%@
+    @@-::::::::----------------------------@@          @@------------------------------------=@
+     @%:::::::::--------------------------*@            @*-----------------------------------@@
+      @*:::::::::-------------------------@@            @@----------------------------------%@
+       @#::::::::::----------------------%@              @%--------------------------------%@
+        @#:::::::::::-------------------=@@              @@=------------------------------%@
+         @@-::::::::::::----------------%@                @%----------------------------=@@
+          @@#::::::::::::::------------*@                  @*--------------------------#@@
+            @@+::::::::::::::::--------@@                  @@------------------------+@@
+              @@*:::::::::::::::::----@@                    @@---------------------+@@
+                @@@-:::::::::::::::--#@                      @#-----------------=%@@
+                   @@%-::::::::::::-%@                        @%-------------=%@@
+                      @@@@+:::::::#@@                          @@*-------*@@@@
+                           @@@@@@@                                @@@@@@
+
+        `);
   }
   Dispose() {
     var _a;