@shopware-ag/dive 1.16.25 → 1.16.26-beta.0

package/build/dive.js

@@ -94,7 +94,11 @@ var init_findInterface = __esm({
 });
 
 // src/toolbox/BaseTool.ts
-import { Raycaster, Vector2, Vector3 } from "three";
+import {
+  Raycaster,
+  Vector2,
+  Vector3
+} from "three";
 var DIVEBaseTool;
 var init_BaseTool = __esm({
   "src/toolbox/BaseTool.ts"() {
@@ -314,7 +318,7 @@ var init_BaseTool = __esm({
 });
 
 // src/toolbox/transform/TransformTool.ts
-import { TransformControls } from "three/examples/jsm/Addons";
+import { TransformControls } from "three/examples/jsm/controls/TransformControls";
 var DIVETransformTool;
 var init_TransformTool = __esm({
   "src/toolbox/transform/TransformTool.ts"() {
@@ -360,7 +364,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() {
       }
@@ -625,6 +629,1405 @@ 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
+import { Object3D as Object3D2 } from "three";
+import { USDZExporter } from "three/examples/jsm/exporters/USDZExporter";
+var DIVEARQuickLook;
+var init_ARQuickLook = __esm({
+  "src/ar/arquicklook/ARQuickLook.ts"() {
+    "use strict";
+    DIVEARQuickLook = class {
+      static Launch(scene) {
+        const quickLookScene = new Object3D2();
+        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 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
+import { Mesh, MeshBasicMaterial, Object3D as Object3D3, RingGeometry } from "three";
+var DIVEWebXRCrosshair;
+var init_WebXRCrosshair = __esm({
+  "src/ar/webxr/crosshair/WebXRCrosshair.ts"() {
+    "use strict";
+    DIVEWebXRCrosshair = class extends Object3D3 {
+      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 RingGeometry(0.08, 0.1, 32).rotateX(-Math.PI / 2);
+        const material = new MeshBasicMaterial();
+        this.mesh = new Mesh(geometry, material);
+      }
+      UpdateFromPose(pose) {
+        this.matrix.fromArray(pose.transform.matrix);
+      }
+    };
+  }
+});
+
+// src/ar/webxr/raycaster/ar/WebXRRaycasterAR.ts
+import { Matrix4, Vector3 as Vector32 } from "three";
+var DIVEWebXRRaycasterAR;
+var init_WebXRRaycasterAR = __esm({
+  "src/ar/webxr/raycaster/ar/WebXRRaycasterAR.ts"() {
+    "use strict";
+    DIVEWebXRRaycasterAR = class {
+      constructor(session, renderer) {
+        this._referenceSpaceBuffer = null;
+        this._requesting = false;
+        this._initialized = false;
+        this._session = session;
+        this._renderer = renderer;
+        this._hitMatrixBuffer = new 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 Vector32().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
+import {
+  Raycaster as Raycaster2
+} from "three";
+var DIVEWebXRRaycasterTHREE;
+var init_WebXRRaycasterTHREE = __esm({
+  "src/ar/webxr/raycaster/three/WebXRRaycasterTHREE.ts"() {
+    "use strict";
+    DIVEWebXRRaycasterTHREE = class {
+      constructor(renderer, scene) {
+        // internal raycaster
+        this._raycaster = new Raycaster2();
+        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
+import { Matrix4 as Matrix42, Quaternion, Vector3 as Vector33 } from "three";
+var DIVEWebXROrigin;
+var init_WebXROrigin = __esm({
+  "src/ar/webxr/origin/WebXROrigin.ts"() {
+    "use strict";
+    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 Matrix42();
+        this._position = new Vector33();
+        this._quaternion = new Quaternion();
+        this._scale = new Vector33();
+        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 Matrix42();
+        this._position = new Vector33();
+        this._quaternion = new Quaternion();
+        this._scale = new Vector33();
+      }
+      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
+import { Vector2 as Vector22 } from "three";
+var DIVEWebXRTouchscreenControls;
+var init_WebXRTouchscreenControls = __esm({
+  "src/ar/webxr/touchscreencontrols/WebXRTouchscreenControls.ts"() {
+    "use strict";
+    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 Vector22(),
+            current: new Vector22(),
+            delta: new Vector22()
+          },
+          {
+            start: new Vector22(),
+            current: new Vector22(),
+            delta: new Vector22()
+          }
+        ];
+        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
+import {
+  Mesh as Mesh2,
+  Object3D as Object3D4,
+  Quaternion as Quaternion2,
+  Vector3 as Vector34
+} from "three";
+var DIVEWebXRController;
+var init_WebXRController = __esm({
+  "src/ar/webxr/controller/WebXRController.ts"() {
+    "use strict";
+    init_WebXRCrosshair();
+    init_WebXRRaycaster();
+    init_WebXROrigin();
+    init_WebXRTouchscreenControls();
+    init_findInterface();
+    DIVEWebXRController = class extends Object3D4 {
+      constructor(session, renderer, scene) {
+        super();
+        this._frameBuffer = null;
+        this._handNodeInitialPosition = new Vector34();
+        this._placed = false;
+        // grabbing
+        this._grabbedObject = null;
+        this._arHitPosition = new Vector34();
+        this._arHitQuaternion = new Quaternion2();
+        this._arHitScale = new Vector34(1, 1, 1);
+        // grabbing position
+        this._initialObjectPosition = null;
+        this._initialRaycastHit = null;
+        this._deltaRaycastHit = new Vector34();
+        // grabbing rotation
+        this._touchQuaterion = new Quaternion2();
+        // grabbing scale
+        this._touchScale = 1;
+        this._scaleThreshold = 0.1;
+        this._startTouchQuaternion = new Quaternion2();
+        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 Vector34(
+            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 Vector34(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 Mesh2) {
+              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.2?${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/renderer/Renderer.ts
 import {
   MathUtils,
@@ -669,8 +2072,8 @@ var DIVERenderer = class extends 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;
   }
@@ -744,14 +2147,14 @@ var DIVERenderer = class extends 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;
   }
@@ -761,7 +2164,7 @@ var DIVERenderer = class extends WebGLRenderer {
 import { Color as Color7, Scene as Scene2 } from "three";
 
 // src/scene/root/Root.ts
-import { Box3 as Box32, Color as Color5, Object3D as Object3D6 } from "three";
+import { Box3 as Box32, Color as Color5, Object3D as Object3D8 } from "three";
 
 // src/light/AmbientLight.ts
 init_VisibilityLayerMask();
@@ -791,10 +2194,10 @@ var DIVEAmbientLight = class extends Object3D {
 import {
   PointLight,
   SphereGeometry,
-  MeshBasicMaterial,
-  Mesh,
+  MeshBasicMaterial as MeshBasicMaterial2,
+  Mesh as Mesh3,
   FrontSide,
-  Object3D as Object3D3
+  Object3D as Object3D5
 } from "three";
 
 // src/com/Communication.ts
@@ -813,6 +2216,7 @@ var _DIVECommunication = class _DIVECommunication {
     this.toolbox = toolbox;
     this._mediaGenerator = null;
     this._io = null;
+    this._ar = null;
     _DIVECommunication.__instances.push(this);
   }
   static get(id) {
@@ -847,6 +2251,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
@@ -1014,6 +2425,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}`
@@ -1297,7 +2713,7 @@ var DIVECommunication = _DIVECommunication;
 
 // src/light/PointLight.ts
 init_VisibilityLayerMask();
-var DIVEPointLight = class extends Object3D3 {
+var DIVEPointLight = class extends Object3D5 {
   constructor() {
     super();
     this.isDIVELight = true;
@@ -1318,13 +2734,13 @@ var DIVEPointLight = class extends Object3D3 {
       geoSize * 320,
       geoSize * 320
     );
-    const material = new MeshBasicMaterial({
+    const material = new MeshBasicMaterial2({
       color: this.light.color,
       transparent: true,
       opacity: 0.8,
       side: FrontSide
     });
-    this.mesh = new Mesh(geometry, material);
+    this.mesh = new Mesh3(geometry, material);
     this.mesh.layers.mask = UI_LAYER_MASK;
     this.add(this.mesh);
   }
@@ -1364,8 +2780,8 @@ var DIVEPointLight = class extends Object3D3 {
 
 // src/light/SceneLight.ts
 init_VisibilityLayerMask();
-import { DirectionalLight, HemisphereLight, Object3D as Object3D4 } from "three";
-var DIVESceneLight = class extends Object3D4 {
+import { DirectionalLight, HemisphereLight, Object3D as Object3D6 } from "three";
+var DIVESceneLight = class extends Object3D6 {
   constructor() {
     super();
     this.isDIVELight = true;
@@ -1406,7 +2822,7 @@ var DIVESceneLight = class extends Object3D4 {
 
 // src/model/Model.ts
 init_VisibilityLayerMask();
-import { MeshStandardMaterial, Raycaster as Raycaster2, Vector3 as Vector33 } from "three";
+import { MeshStandardMaterial, Raycaster as Raycaster3, Vector3 as Vector36 } from "three";
 
 // src/helper/findSceneRecursive/findSceneRecursive.ts
 var findSceneRecursive = (object) => {
@@ -1418,8 +2834,8 @@ var findSceneRecursive = (object) => {
 
 // src/node/Node.ts
 init_VisibilityLayerMask();
-import { Box3, Object3D as Object3D5, Vector3 as Vector32 } from "three";
-var DIVENode = class extends Object3D5 {
+import { Box3, Object3D as Object3D7, Vector3 as Vector35 } from "three";
+var DIVENode = class extends Object3D7 {
   constructor() {
     super();
     this.isDIVENode = true;
@@ -1427,7 +2843,7 @@ var DIVENode = class extends Object3D5 {
     this.isMovable = true;
     this.gizmo = null;
     this.layers.mask = PRODUCT_LAYER_MASK;
-    this._positionWorldBuffer = new Vector32();
+    this._positionWorldBuffer = new Vector35();
     this._boundingBox = new Box3();
   }
   SetPosition(position) {
@@ -1435,7 +2851,7 @@ var DIVENode = class extends Object3D5 {
       this.position.set(position.x, position.y, position.z);
       return;
     }
-    const newPosition = new Vector32(position.x, position.y, position.z);
+    const newPosition = new Vector35(position.x, position.y, position.z);
     this.position.copy(this.parent.worldToLocal(newPosition));
     if ("isDIVEGroup" in this.parent) {
       this.parent.UpdateLineTo(this);
@@ -1585,10 +3001,10 @@ var DIVEModel = class extends DIVENode {
     }
     const bottomY = this._boundingBox.min.y * this.scale.y;
     const bbBottomCenter = this.localToWorld(
-      this._boundingBox.getCenter(new Vector33()).multiply(this.scale)
+      this._boundingBox.getCenter(new Vector36()).multiply(this.scale)
     );
     bbBottomCenter.y = bottomY + this.position.y;
-    const raycaster = new Raycaster2(bbBottomCenter, new Vector33(0, -1, 0));
+    const raycaster = new Raycaster3(bbBottomCenter, new Vector36(0, -1, 0));
     raycaster.layers.mask = PRODUCT_LAYER_MASK;
     const intersections = raycaster.intersectObjects(
       findSceneRecursive(this).Root.children,
@@ -1600,7 +3016,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 Vector33(0, bottomY, 0));
+      const newPos = this.position.clone().setY(worldPos.y).sub(new Vector36(0, bottomY, 0));
       this.position.copy(newPos);
       if (this.position.y === oldPos.y) return;
       this.onMove();
@@ -1651,17 +3067,17 @@ import {
   Color as Color4,
   ConeGeometry,
   CylinderGeometry,
-  Mesh as Mesh3,
+  Mesh as Mesh5,
   MeshStandardMaterial as MeshStandardMaterial2,
-  Raycaster as Raycaster3,
+  Raycaster as Raycaster4,
   SphereGeometry as SphereGeometry2,
-  Vector3 as Vector34
+  Vector3 as Vector37
 } from "three";
 var DIVEPrimitive = class extends DIVENode {
   constructor() {
     super();
     this.isDIVEPrimitive = true;
-    this._mesh = new Mesh3();
+    this._mesh = new Mesh5();
     this._mesh.layers.mask = PRODUCT_LAYER_MASK;
     this._mesh.castShadow = true;
     this._mesh.receiveShadow = true;
@@ -1734,10 +3150,10 @@ var DIVEPrimitive = class extends DIVENode {
     }
     const bottomY = this._boundingBox.min.y * this.scale.y;
     const bbBottomCenter = this.localToWorld(
-      this._boundingBox.getCenter(new Vector34()).multiply(this.scale)
+      this._boundingBox.getCenter(new Vector37()).multiply(this.scale)
     );
     bbBottomCenter.y = bottomY + this.position.y;
-    const raycaster = new Raycaster3(bbBottomCenter, new Vector34(0, -1, 0));
+    const raycaster = new Raycaster4(bbBottomCenter, new Vector37(0, -1, 0));
     raycaster.layers.mask = PRODUCT_LAYER_MASK;
     const intersections = raycaster.intersectObjects(
       findSceneRecursive(this).Root.children,
@@ -1749,7 +3165,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 Vector34(0, bottomY, 0));
+      const newPos = this.position.clone().setY(worldPos.y).sub(new Vector37(0, bottomY, 0));
       this.position.copy(newPos);
       if (this.position.y === oldPos.y) return;
       this.onMove();
@@ -1890,7 +3306,7 @@ import {
   BufferGeometry as BufferGeometry2,
   Line,
   LineDashedMaterial,
-  Vector3 as Vector35
+  Vector3 as Vector38
 } from "three";
 var DIVEGroup = class extends DIVENode {
   // lines to children
@@ -1968,7 +3384,7 @@ var DIVEGroup = class extends DIVENode {
    */
   updateLineTo(line, object) {
     line.geometry.setFromPoints([
-      new Vector35(0, 0, 0),
+      new Vector38(0, 0, 0),
       object.position.clone()
     ]);
     line.computeLineDistances();
@@ -2023,7 +3439,7 @@ var DIVEGroup = class extends DIVENode {
 };
 
 // src/scene/root/Root.ts
-var DIVERoot = class extends Object3D6 {
+var DIVERoot = class extends Object3D8 {
   constructor() {
     super();
     this.isDIVERoot = true;
@@ -2208,6 +3624,7 @@ var DIVERoot = class extends Object3D6 {
       const created = new DIVEModel();
       sceneObject = created;
       sceneObject.userData.id = model.id;
+      sceneObject.userData.uri = model.uri;
       this.add(sceneObject);
     }
     if (model.uri !== void 0) {
@@ -2366,8 +3783,8 @@ var GRID_SIDE_LINE_COLOR = "#dddddd";
 
 // src/grid/Grid.ts
 init_VisibilityLayerMask();
-import { GridHelper, Object3D as Object3D7 } from "three";
-var DIVEGrid = class extends Object3D7 {
+import { GridHelper, Object3D as Object3D9 } from "three";
+var DIVEGrid = class extends Object3D9 {
   constructor() {
     super();
     this.name = "Grid";
@@ -2390,11 +3807,11 @@ var DIVEGrid = class extends Object3D7 {
 init_VisibilityLayerMask();
 import {
   Color as Color6,
-  Mesh as Mesh4,
+  Mesh as Mesh6,
   MeshStandardMaterial as MeshStandardMaterial3,
   PlaneGeometry
 } from "three";
-var DIVEFloor = class extends Mesh4 {
+var DIVEFloor = class extends Mesh6 {
   constructor() {
     super(
       new PlaneGeometry(1e4, 1e4),
@@ -2416,26 +3833,141 @@ var DIVEFloor = class extends Mesh4 {
   }
 };
 
+// src/scene/xrroot/XRRoot.ts
+import { Mesh as Mesh7, Object3D as Object3D11, PlaneGeometry as PlaneGeometry2, ShadowMaterial } from "three";
+
+// src/scene/xrroot/xrlightroot/XRLightRoot.ts
+init_VisibilityLayerMask();
+import { XREstimatedLight } from "three/examples/jsm/webxr/XREstimatedLight";
+import { Object3D as Object3D10 } from "three";
+var DIVEXRLightRoot = class extends Object3D10 {
+  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 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 Object3D11 {
+  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 Mesh7(
+      new PlaneGeometry2(100, 100),
+      new 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 Object3D11();
+    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 Scene2 {
   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 Color7(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._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 Color7(color);
@@ -2465,7 +3997,7 @@ init_PerspectiveCamera();
 
 // src/controls/OrbitControls.ts
 import { OrbitControls } from "three/examples/jsm/controls/OrbitControls";
-import { MathUtils as MathUtils2, Vector3 as Vector36 } from "three";
+import { MathUtils as MathUtils2, Vector3 as Vector39 } from "three";
 import { Easing } from "@tweenjs/tween.js";
 var DIVEOrbitControlsDefaultSettings = {
   enableDamping: true,
@@ -2507,8 +4039,8 @@ var _DIVEOrbitControls = class _DIVEOrbitControls extends OrbitControls {
     this.dispose();
   }
   ComputeEncompassingView(bb) {
-    const center = bb.getCenter(new Vector36());
-    const size = bb.getSize(new Vector36());
+    const center = bb.getCenter(new Vector39());
+    const size = bb.getSize(new Vector39());
     const distance = Math.max(size.x, size.y, size.z) * 1.25;
     const direction = this.object.position.clone().normalize();
     return {
@@ -2718,7 +4250,7 @@ init_VisibilityLayerMask();
 import {
   AxesHelper,
   Color as Color8,
-  Matrix4,
+  Matrix4 as Matrix44,
   OrthographicCamera,
   Vector4
 } from "three";
@@ -2782,7 +4314,7 @@ var DIVEAxisCamera = class extends OrthographicCamera {
   }
   SetFromCameraMatrix(matrix) {
     this.axesHelper.rotation.setFromRotationMatrix(
-      new Matrix4().extractRotation(matrix).invert()
+      new Matrix44().extractRotation(matrix).invert()
     );
   }
 };
@@ -2854,109 +4386,13 @@ var getObjectDelta = (a, b) => {
 };
 
 // src/dive.ts
+init_Info();
 import { generateUUID as generateUUID2 } from "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;
-
 // package.json
 var package_default = {
   name: "@shopware-ag/dive",
-  version: "1.16.25",
+  version: "1.16.26-beta.0",
   description: "Shopware Spatial Framework",
   type: "module",
   main: "./build/dive.cjs",
@@ -3108,8 +4544,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 }
@@ -3128,9 +4564,6 @@ var DIVE = class _DIVE {
     const modelid = generateUUID2();
     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",
         {}
@@ -3253,9 +4686,36 @@ 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.padStart(7, " ") + " "}---------------------------------%@
+       @%:::.......:::::::-------------------${false ? " DEV MODE " : "--------------"}------------------------------------#@
+      @*:::.....:::::-----------------------------------------------------------------------*@
+     @%::::::.::::---------------------------------------------------------------------------@@
+    @@-:::::::::-----------------------------------------------------------------------------=@
+    @%::::::::--------------------------------------------------------------------------------%@
+    @+::::::::--------------------------------=@@@@@%-----------------------------------------%@
+    @=:::::::--------------------------------*@@    @@+---------------------------------------#@
+    @+:::::::-------------------------------*@        @*--------------------------------------%@
+    @#::::::::-----------------------------=@@        @@=-------------------------------------%@
+    @@-::::::::----------------------------@@          @@------------------------------------=@
+     @%:::::::::--------------------------*@            @*-----------------------------------@@
+      @*:::::::::-------------------------@@            @@----------------------------------%@
+       @#::::::::::----------------------%@              @%--------------------------------%@
+        @#:::::::::::-------------------=@@              @@=------------------------------%@
+         @@-::::::::::::----------------%@                @%----------------------------=@@
+          @@#::::::::::::::------------*@                  @*--------------------------#@@
+            @@+::::::::::::::::--------@@                  @@------------------------+@@
+              @@*:::::::::::::::::----@@                    @@---------------------+@@
+                @@@-:::::::::::::::--#@                      @#-----------------=%@@
+                   @@%-::::::::::::-%@                        @%-------------=%@@
+                      @@@@+:::::::#@@                          @@*-------*@@@@
+                           @@@@@@@                                @@@@@@
+
+        `);
   }
   Dispose() {
     var _a;