@shopware-ag/dive 3.1.0 → 4.0.1

package/build/chunks/OrbitController-DxCbrQVB.mjs

@@ -0,0 +1,612 @@
+var T = Object.defineProperty;
+var A = (p, l, t) => l in p ? T(p, l, { enumerable: !0, configurable: !0, writable: !0, value: t }) : p[l] = t;
+var s = (p, l, t) => A(p, typeof l != "symbol" ? l + "" : l, t);
+import { TOUCH as c, MOUSE as r, Vector3 as n, EventDispatcher as O, MathUtils as L, Spherical as g, Vector2 as h, Quaternion as y } from "three/webgpu";
+import { B as R } from "./FileTypes-D3Dxr2dj.mjs";
+import "three/examples/jsm/loaders/HDRLoader.js";
+import "three/tsl";
+const Z = {
+  enableDamping: !0,
+  dampingFactor: 0.05,
+  enabled: !0,
+  target: new n(),
+  minDistance: 0,
+  maxDistance: 1 / 0,
+  minZoom: 0,
+  maxZoom: 1 / 0,
+  minPolarAngle: 0,
+  maxPolarAngle: Math.PI,
+  minAzimuthAngle: -1 / 0,
+  maxAzimuthAngle: 1 / 0,
+  enableZoom: !0,
+  zoomSpeed: 1,
+  enableRotate: !0,
+  rotateSpeed: 1,
+  enablePan: !0,
+  panSpeed: 1,
+  screenSpacePanning: !0,
+  keyPanSpeed: 7,
+  autoRotate: !1,
+  autoRotateSpeed: 2,
+  keys: {
+    LEFT: "ArrowLeft",
+    UP: "ArrowUp",
+    RIGHT: "ArrowRight",
+    BOTTOM: "ArrowDown"
+  },
+  mouseButtons: {
+    LEFT: r.ROTATE,
+    MIDDLE: r.DOLLY,
+    RIGHT: r.PAN
+  },
+  touches: {
+    ONE: c.ROTATE,
+    TWO: c.DOLLY_PAN
+  }
+}, u = class u extends O {
+  constructor(t, e, i) {
+    super();
+    // public API
+    /**
+     * The camera component this controller drives.
+     *
+     * The component rather than the camera: `setCameraLayer` and `onResize` live
+     * there, and handing out the bare camera meant every caller had to search its
+     * way back. What orbiting moves is `object.owner`, the node it sits on.
+     */
+    s(this, "object");
+    s(this, "domElements");
+    s(this, "enabled", !0);
+    s(this, "target", new n());
+    s(this, "minDistance", 0);
+    s(this, "maxDistance", 1 / 0);
+    s(this, "minZoom", 0);
+    s(this, "maxZoom", 1 / 0);
+    s(this, "minPolarAngle", 0);
+    // radians
+    s(this, "maxPolarAngle", Math.PI);
+    // radians
+    s(this, "minAzimuthAngle", -1 / 0);
+    // radians
+    s(this, "maxAzimuthAngle", 1 / 0);
+    // radians
+    s(this, "enableDamping", !0);
+    s(this, "dampingFactor", 0.05);
+    s(this, "enableZoom", !0);
+    s(this, "zoomSpeed", 1);
+    s(this, "enableRotate", !0);
+    s(this, "rotateSpeed", 1);
+    s(this, "enablePan", !0);
+    s(this, "panSpeed", 1);
+    s(this, "screenSpacePanning", !0);
+    s(this, "keyPanSpeed", 7);
+    s(this, "autoRotate", !1);
+    s(this, "autoRotateSpeed", 2);
+    s(this, "keys", {
+      LEFT: "ArrowLeft",
+      UP: "ArrowUp",
+      RIGHT: "ArrowRight",
+      BOTTOM: "ArrowDown"
+    });
+    s(this, "mouseButtons", {
+      LEFT: r.ROTATE,
+      MIDDLE: r.DOLLY,
+      RIGHT: r.PAN
+    });
+    s(this, "touches", { ONE: c.ROTATE, TWO: c.DOLLY_PAN });
+    s(this, "target0");
+    s(this, "position0");
+    s(this, "zoom0");
+    s(this, "uuid", L.generateUUID());
+    // private state
+    s(this, "state", -1);
+    s(this, "EPS", 1e-6);
+    s(this, "spherical", new g());
+    s(this, "sphericalDelta", new g());
+    s(this, "scale", 1);
+    s(this, "panOffset", new n());
+    s(this, "zoomChanged", !1);
+    s(this, "rotateStart", new h());
+    s(this, "rotateEnd", new h());
+    s(this, "rotateDelta", new h());
+    s(this, "panStart", new h());
+    s(this, "panEnd", new h());
+    s(this, "panDelta", new h());
+    s(this, "dollyStart", new h());
+    s(this, "dollyEnd", new h());
+    s(this, "dollyDelta", new h());
+    s(this, "pointers", []);
+    s(this, "pointerPositions", {});
+    // for update() function
+    s(this, "offset", new n());
+    s(this, "quat");
+    s(this, "quatInverse");
+    s(this, "lastPosition", new n());
+    s(this, "lastQuaternion", new y());
+    s(this, "lastTarget", new n());
+    s(this, "panLeft", (() => {
+      const t = new n();
+      return (e, i) => {
+        t.setFromMatrixColumn(i, 0), t.multiplyScalar(-e), this.panOffset.add(t);
+      };
+    })());
+    s(this, "panUp", (() => {
+      const t = new n();
+      return (e, i) => {
+        this.screenSpacePanning === !0 ? t.setFromMatrixColumn(i, 1) : (t.setFromMatrixColumn(i, 0), t.crossVectors(this.object.camera.up, t)), t.multiplyScalar(e), this.panOffset.add(t);
+      };
+    })());
+    s(this, "onMouseDown", (t) => {
+      let e;
+      switch (t.button) {
+        case 0:
+          e = this.mouseButtons.LEFT;
+          break;
+        case 1:
+          e = this.mouseButtons.MIDDLE;
+          break;
+        case 2:
+          e = this.mouseButtons.RIGHT;
+          break;
+        default:
+          e = -1;
+      }
+      switch (e) {
+        case r.DOLLY:
+          if (this.enableZoom === !1) return;
+          this.handleMouseDownDolly(t), this.state = 1;
+          break;
+        case r.ROTATE:
+          if (t.ctrlKey || t.metaKey || t.shiftKey) {
+            if (this.enablePan === !1) return;
+            this.handleMouseDownPan(t), this.state = 2;
+          } else {
+            if (this.enableRotate === !1) return;
+            this.handleMouseDownRotate(t), this.state = 0;
+          }
+          break;
+        case r.PAN:
+          if (t.ctrlKey || t.metaKey || t.shiftKey) {
+            if (this.enableRotate === !1) return;
+            this.handleMouseDownRotate(t), this.state = 0;
+          } else {
+            if (this.enablePan === !1) return;
+            this.handleMouseDownPan(t), this.state = 2;
+          }
+          break;
+        default:
+          this.state = -1;
+      }
+      this.state !== -1 && this.dispatchEvent({ type: "start" });
+    });
+    s(this, "onMouseMove", (t) => {
+      if (this.enabled !== !1)
+        switch (this.state) {
+          case 0:
+            if (this.enableRotate === !1) return;
+            this.handleMouseMoveRotate(t);
+            break;
+          case 1:
+            if (this.enableZoom === !1) return;
+            this.handleMouseMoveDolly(t);
+            break;
+          case 2:
+            if (this.enablePan === !1) return;
+            this.handleMouseMovePan(t);
+            break;
+        }
+    });
+    s(this, "onMouseWheel", (t) => {
+      this.enabled === !1 || this.enableZoom === !1 || this.state !== -1 || (t.preventDefault(), this.dispatchEvent({ type: "start" }), this.handleMouseWheel(t), this.dispatchEvent({ type: "end" }));
+    });
+    s(this, "onKeyDown", (t) => {
+      this.enabled === !1 || this.enablePan === !1 || this.handleKeyDown(t);
+    });
+    s(this, "onTouchStart", (t) => {
+      switch (this.trackPointer(t), this.pointers.length) {
+        case 1:
+          switch (this.touches.ONE) {
+            case c.ROTATE:
+              if (this.enableRotate === !1) return;
+              this.handleTouchStartRotate(t), this.state = 3;
+              break;
+            case c.PAN:
+              if (this.enablePan === !1) return;
+              this.handleTouchStartPan(t), this.state = 4;
+              break;
+            default:
+              this.state = -1;
+          }
+          break;
+        case 2:
+          switch (this.touches.TWO) {
+            case c.DOLLY_PAN:
+              if (this.enableZoom === !1 && this.enablePan === !1)
+                return;
+              this.handleTouchStartDollyPan(t), this.state = 5;
+              break;
+            case c.DOLLY_ROTATE:
+              if (this.enableZoom === !1 && this.enableRotate === !1)
+                return;
+              this.handleTouchStartDollyRotate(t), this.state = 6;
+              break;
+            default:
+              this.state = -1;
+          }
+          break;
+        default:
+          this.state = -1;
+      }
+      this.state !== -1 && this.dispatchEvent({ type: "start" });
+    });
+    s(this, "onTouchMove", (t) => {
+      switch (this.trackPointer(t), this.state) {
+        case 3:
+          if (this.enableRotate === !1) return;
+          this.handleTouchMoveRotate(t), this.update();
+          break;
+        case 4:
+          if (this.enablePan === !1) return;
+          this.handleTouchMovePan(t), this.update();
+          break;
+        case 5:
+          if (this.enableZoom === !1 && this.enablePan === !1)
+            return;
+          this.handleTouchMoveDollyPan(t), this.update();
+          break;
+        case 6:
+          if (this.enableZoom === !1 && this.enableRotate === !1)
+            return;
+          this.handleTouchMoveDollyRotate(t), this.update();
+          break;
+        default:
+          this.state = -1;
+      }
+    });
+    s(this, "onPointerDown", (t) => {
+      if (this.enabled !== !1) {
+        if (this.pointers.length === 0) {
+          const e = t.currentTarget;
+          e.setPointerCapture(t.pointerId), e.addEventListener("pointermove", this.onPointerMove), e.addEventListener("pointerup", this.onPointerUp);
+        }
+        this.isTrackingPointer(t) || (this.addPointer(t), t.pointerType === "touch" ? this.onTouchStart(t) : this.onMouseDown(t));
+      }
+    });
+    s(this, "onPointerMove", (t) => {
+      this.enabled !== !1 && (t.pointerType === "touch" ? this.onTouchMove(t) : this.onMouseMove(t));
+    });
+    s(this, "onPointerUp", (t) => {
+      if (this.removePointer(t), this.pointers.length === 0) {
+        const e = t.currentTarget;
+        e.releasePointerCapture(t.pointerId), e.removeEventListener("pointermove", this.onPointerMove), e.removeEventListener("pointerup", this.onPointerUp), this.dispatchEvent({ type: "end" }), this.state = -1;
+      }
+    });
+    s(this, "onPointerCancel", (t) => {
+      this.removePointer(t);
+    });
+    s(this, "onContextMenu", (t) => {
+      this.enabled !== !1 && t.preventDefault();
+    });
+    if (this.object = t, !t.isAttached)
+      throw new Error(
+        "OrbitController: the camera component must be attached to a node, because that is what gets moved."
+      );
+    this.domElements = Array.isArray(e) ? e : [e], Object.assign(this, i), this.target0 = this.target.clone(), this.position0 = this.object.owner.position.clone(), this.zoom0 = this._camera.zoom, this.quat = new y().setFromUnitVectors(
+      this.object.camera.up,
+      new n(0, 1, 0)
+    ), this.quatInverse = this.quat.clone().invert(), this.domElements.forEach((a) => this.addEventListeners(a)), this.update();
+  }
+  /**
+   * The camera, narrowed to the two kinds whose projection this can pan.
+   *
+   * `DIVECameraComponent` types its camera as the base `Camera`, which has no
+   * `zoom` or `fov`; the branches below narrow it further.
+   */
+  get _camera() {
+    return this.object.camera;
+  }
+  get domElement() {
+    return this.domElements[0];
+  }
+  tick() {
+    this.enabled && this.update();
+  }
+  getPolarAngle() {
+    return this.spherical.phi;
+  }
+  getAzimuthalAngle() {
+    return this.spherical.theta;
+  }
+  getDistance() {
+    return this.object.owner.position.distanceTo(this.target);
+  }
+  saveState() {
+    this.target0.copy(this.target), this.position0.copy(this.object.owner.position), this.zoom0 = this._camera.zoom;
+  }
+  reset() {
+    this.target.copy(this.target0), this.object.owner.position.copy(this.position0), this._camera.zoom = this.zoom0, this._camera.updateProjectionMatrix(), this.dispatchEvent({ type: "change" }), this.update(), this.state = -1;
+  }
+  update() {
+    return this.offset.copy(this.object.owner.position).sub(this.target), this.offset.applyQuaternion(this.quat), this.spherical.setFromVector3(this.offset), this.autoRotate && this.state === -1 && this.rotateLeft(this.getAutoRotationAngle()), this.enableDamping ? (this.spherical.theta += this.sphericalDelta.theta * this.dampingFactor, this.spherical.phi += this.sphericalDelta.phi * this.dampingFactor) : (this.spherical.theta += this.sphericalDelta.theta, this.spherical.phi += this.sphericalDelta.phi), this.spherical.theta = Math.max(
+      this.minAzimuthAngle,
+      Math.min(this.maxAzimuthAngle, this.spherical.theta)
+    ), this.spherical.phi = Math.max(
+      this.minPolarAngle,
+      Math.min(this.maxPolarAngle, this.spherical.phi)
+    ), this.spherical.makeSafe(), this.spherical.radius *= this.scale, this.spherical.radius = Math.max(
+      this.minDistance,
+      Math.min(this.maxDistance, this.spherical.radius)
+    ), this.enableDamping === !0 ? this.target.addScaledVector(this.panOffset, this.dampingFactor) : this.target.add(this.panOffset), this.offset.setFromSpherical(this.spherical), this.offset.applyQuaternion(this.quatInverse), this.object.owner.position.copy(this.target).add(this.offset), this.object.lookAt(this.target), this.enableDamping === !0 ? (this.sphericalDelta.theta *= 1 - this.dampingFactor, this.sphericalDelta.phi *= 1 - this.dampingFactor, this.panOffset.multiplyScalar(1 - this.dampingFactor)) : (this.sphericalDelta.set(0, 0, 0), this.panOffset.set(0, 0, 0)), this.scale = 1, this.zoomChanged || this.lastPosition.distanceToSquared(this.object.owner.position) > this.EPS || 8 * (1 - this.lastQuaternion.dot(this.object.owner.quaternion)) > this.EPS || this.lastTarget.distanceToSquared(this.target) > this.EPS ? (this.dispatchEvent({ type: "change" }), this.lastPosition.copy(this.object.owner.position), this.lastQuaternion.copy(this.object.owner.quaternion), this.lastTarget.copy(this.target), this.zoomChanged = !1, !0) : !1;
+  }
+  dispose() {
+    this.domElements.forEach(
+      (t) => this.removeEventListeners(t)
+    ), this.dispatchEvent({ type: "dispose" });
+  }
+  addDomElements(...t) {
+    t.forEach((e) => {
+      this.domElements.includes(e) || (this.domElements.push(e), this.addEventListeners(e));
+    });
+  }
+  removeDomElements(...t) {
+    t.forEach((e) => {
+      const i = this.domElements.indexOf(e);
+      i > -1 && (this.removeEventListeners(e), this.domElements.splice(i, 1));
+    });
+  }
+  setDomElements(...t) {
+    this.removeDomElements(...this.domElements), this.domElements = [], this.addDomElements(...t);
+  }
+  /**
+   * Where to put the camera so a sphere fills the view.
+   *
+   * Takes a `Sphere` rather than a bounding box: framing needs a centre and a
+   * radius, and nothing else. Build one with `new BoundingBox().enclose(...)`,
+   * or read `sphere` off a `BoundingBoxComponent` that already measures a node.
+   *
+   * @param sphere - What to frame, in world space.
+   * @param padding - Extra distance as a fraction of the fitted one.
+   */
+  computeEncompassingView(t, e = 0) {
+    const i = t.center, a = t.radius, o = this._camera, d = o.fov * (Math.PI / 180), P = o.aspect, m = d / 2, D = Math.atan(Math.tan(m) * P), w = a / Math.sin(m), E = a / Math.sin(D), S = Math.max(w, E) * (1 + e), f = this.object.owner.position.clone().sub(this.target).normalize(), M = f.length() > 1e-3 ? f : new n(0, 0, 1);
+    return {
+      position: i.clone().add(M.multiplyScalar(S)),
+      target: i
+    };
+  }
+  /**
+   * Puts the camera where the whole node fits in the view.
+   *
+   * One node, not a list: a node already is the handle for everything below it,
+   * so anything worth framing together belongs under a common parent.
+   *
+   * @param node - What to frame.
+   * @param padding - Extra distance as a fraction of the fitted one.
+   */
+  focusObject(t, e = 0) {
+    const i = this.computeEncompassingView(
+      new R().enclose(t).sphere,
+      e
+    );
+    this.object.owner.position.copy(i.position), this.target.copy(i.target), this.update();
+  }
+  zoomIn(t) {
+    this.dollyIn(Math.pow(0.95, t ?? u.DEFAULT_ZOOM_FACTOR)), this.update();
+  }
+  zoomOut(t) {
+    this.dollyOut(
+      Math.pow(0.95, t ?? u.DEFAULT_ZOOM_FACTOR)
+    ), this.update();
+  }
+  getState() {
+    return {
+      target: this.target.clone(),
+      azimuthalAngle: this.getAzimuthalAngle(),
+      polarAngle: this.getPolarAngle(),
+      distance: this.getDistance(),
+      position: this.object.owner.position.clone(),
+      quaternion: this.object.owner.quaternion.clone()
+    };
+  }
+  setState(t) {
+    this.target.copy(t.target), this.object.owner.position.copy(t.position), this.object.owner.quaternion.copy(t.quaternion), this.update();
+  }
+  //
+  // Private methods
+  //
+  addEventListeners(t) {
+    t.style.touchAction = "none", t.addEventListener("contextmenu", this.onContextMenu), t.addEventListener("pointerdown", this.onPointerDown), t.addEventListener("pointercancel", this.onPointerCancel), t.addEventListener("wheel", this.onMouseWheel, {
+      passive: !1
+    }), t.addEventListener("keydown", this.onKeyDown);
+  }
+  removeEventListeners(t) {
+    t.removeEventListener("contextmenu", this.onContextMenu), t.removeEventListener("pointerdown", this.onPointerDown), t.removeEventListener("pointercancel", this.onPointerCancel), t.removeEventListener("wheel", this.onMouseWheel), t.removeEventListener("keydown", this.onKeyDown), t.removeEventListener("pointermove", this.onPointerMove), t.removeEventListener("pointerup", this.onPointerUp);
+  }
+  getAutoRotationAngle() {
+    return 2 * Math.PI / 60 / 60 * this.autoRotateSpeed;
+  }
+  getZoomScale() {
+    return Math.pow(0.95, this.zoomSpeed);
+  }
+  rotateLeft(t) {
+    this.sphericalDelta.theta -= t;
+  }
+  rotateUp(t) {
+    this.sphericalDelta.phi -= t;
+  }
+  pan(t, e, i) {
+    const a = new n();
+    if ("isPerspectiveCamera" in this._camera) {
+      const o = this.object.owner.position;
+      a.copy(o).sub(this.target);
+      let d = a.length();
+      d *= Math.tan(
+        this._camera.fov / 2 * Math.PI / 180
+      ), this.panLeft(
+        2 * t * d / i.clientHeight,
+        this.object.owner.matrix
+      ), this.panUp(
+        2 * e * d / i.clientHeight,
+        this.object.owner.matrix
+      );
+    } else "isOrthographicCamera" in this._camera ? (this.panLeft(
+      t * (this._camera.right - this._camera.left) / this._camera.zoom / i.clientWidth,
+      this.object.owner.matrix
+    ), this.panUp(
+      e * (this._camera.top - this._camera.bottom) / this._camera.zoom / i.clientHeight,
+      this.object.owner.matrix
+    )) : (console.warn(
+      "WARNING: OrbitController encountered an unknown camera type - pan disabled."
+    ), this.enablePan = !1);
+  }
+  dollyIn(t) {
+    "isPerspectiveCamera" in this._camera || "isOrthographicCamera" in this._camera ? this.scale *= t : (console.warn(
+      "WARNING: OrbitController encountered an unknown camera type - dolly/zoom disabled."
+    ), this.enableZoom = !1);
+  }
+  dollyOut(t) {
+    "isPerspectiveCamera" in this._camera || "isOrthographicCamera" in this._camera ? this.scale /= t : (console.warn(
+      "WARNING: OrbitController encountered an unknown camera type - dolly/zoom disabled."
+    ), this.enableZoom = !1);
+  }
+  // event callbacks
+  handleMouseDownRotate(t) {
+    this.rotateStart.set(t.clientX, t.clientY);
+  }
+  handleMouseDownDolly(t) {
+    this.dollyStart.set(t.clientX, t.clientY);
+  }
+  handleMouseDownPan(t) {
+    this.panStart.set(t.clientX, t.clientY);
+  }
+  handleMouseMoveRotate(t) {
+    this.rotateEnd.set(t.clientX, t.clientY), this.rotateDelta.subVectors(this.rotateEnd, this.rotateStart).multiplyScalar(this.rotateSpeed);
+    const e = t.currentTarget;
+    this.rotateLeft(
+      2 * Math.PI * this.rotateDelta.x / e.clientHeight
+    ), this.rotateUp(
+      2 * Math.PI * this.rotateDelta.y / e.clientHeight
+    ), this.rotateStart.copy(this.rotateEnd), this.update();
+  }
+  handleMouseMoveDolly(t) {
+    this.dollyEnd.set(t.clientX, t.clientY), this.dollyDelta.subVectors(this.dollyEnd, this.dollyStart), this.dollyDelta.y > 0 ? this.dollyIn(this.getZoomScale()) : this.dollyDelta.y < 0 && this.dollyOut(this.getZoomScale()), this.dollyStart.copy(this.dollyEnd), this.update();
+  }
+  handleMouseMovePan(t) {
+    const e = t.currentTarget;
+    this.panEnd.set(t.clientX, t.clientY), this.panDelta.subVectors(this.panEnd, this.panStart).multiplyScalar(this.panSpeed), this.pan(this.panDelta.x, this.panDelta.y, e), this.panStart.copy(this.panEnd), this.update();
+  }
+  handleMouseWheel(t) {
+    t.deltaY < 0 ? this.dollyIn(this.getZoomScale()) : t.deltaY > 0 && this.dollyOut(this.getZoomScale()), this.update();
+  }
+  handleKeyDown(t) {
+    let e = !1;
+    const i = t.currentTarget;
+    switch (t.code) {
+      case this.keys.UP:
+        this.pan(0, this.keyPanSpeed, i), e = !0;
+        break;
+      case this.keys.BOTTOM:
+        this.pan(0, -this.keyPanSpeed, i), e = !0;
+        break;
+      case this.keys.LEFT:
+        this.pan(this.keyPanSpeed, 0, i), e = !0;
+        break;
+      case this.keys.RIGHT:
+        this.pan(-this.keyPanSpeed, 0, i), e = !0;
+        break;
+    }
+    e && (t.preventDefault(), this.update());
+  }
+  handleTouchStartRotate(t) {
+    if (this.pointers.length === 1)
+      this.rotateStart.set(t.pageX, t.pageY);
+    else {
+      const e = this.getSecondPointer(t), i = 0.5 * (t.pageX + e.pageX), a = 0.5 * (t.pageY + e.pageY);
+      this.rotateStart.set(i, a);
+    }
+  }
+  handleTouchStartPan(t) {
+    if (this.pointers.length === 1)
+      this.panStart.set(t.pageX, t.pageY);
+    else {
+      const e = this.getSecondPointer(t), i = 0.5 * (t.pageX + e.pageX), a = 0.5 * (t.pageY + e.pageY);
+      this.panStart.set(i, a);
+    }
+  }
+  handleTouchStartDolly(t) {
+    const e = this.getSecondPointer(t), i = t.pageX - e.pageX, a = t.pageY - e.pageY, o = Math.sqrt(i * i + a * a);
+    this.dollyStart.set(0, o);
+  }
+  handleTouchStartDollyPan(t) {
+    this.enableZoom && this.handleTouchStartDolly(t), this.enablePan && this.handleTouchStartPan(t);
+  }
+  handleTouchStartDollyRotate(t) {
+    this.enableZoom && this.handleTouchStartDolly(t), this.enableRotate && this.handleTouchStartRotate(t);
+  }
+  handleTouchMoveRotate(t) {
+    if (this.pointers.length === 1)
+      this.rotateEnd.set(t.pageX, t.pageY);
+    else {
+      const i = this.getSecondPointer(t), a = 0.5 * (t.pageX + i.pageX), o = 0.5 * (t.pageY + i.pageY);
+      this.rotateEnd.set(a, o);
+    }
+    const e = t.currentTarget;
+    this.rotateDelta.subVectors(this.rotateEnd, this.rotateStart).multiplyScalar(this.rotateSpeed), this.rotateLeft(
+      2 * Math.PI * this.rotateDelta.x / e.clientHeight
+    ), this.rotateUp(
+      2 * Math.PI * this.rotateDelta.y / e.clientHeight
+    ), this.rotateStart.copy(this.rotateEnd);
+  }
+  handleTouchMovePan(t) {
+    if (this.pointers.length === 1)
+      this.panEnd.set(t.pageX, t.pageY);
+    else {
+      const i = this.getSecondPointer(t), a = 0.5 * (t.pageX + i.pageX), o = 0.5 * (t.pageY + i.pageY);
+      this.panEnd.set(a, o);
+    }
+    const e = t.currentTarget;
+    this.panDelta.subVectors(this.panEnd, this.panStart).multiplyScalar(this.panSpeed), this.pan(this.panDelta.x, this.panDelta.y, e), this.panStart.copy(this.panEnd);
+  }
+  handleTouchMoveDolly(t) {
+    const e = this.getSecondPointer(t), i = t.pageX - e.pageX, a = t.pageY - e.pageY, o = Math.sqrt(i * i + a * a);
+    this.dollyEnd.set(0, o), this.dollyDelta.set(
+      0,
+      Math.pow(this.dollyEnd.y / this.dollyStart.y, this.zoomSpeed)
+    ), this.dollyOut(this.dollyDelta.y), this.dollyStart.copy(this.dollyEnd);
+  }
+  handleTouchMoveDollyPan(t) {
+    this.enableZoom && this.handleTouchMoveDolly(t), this.enablePan && this.handleTouchMovePan(t);
+  }
+  handleTouchMoveDollyRotate(t) {
+    this.enableZoom && this.handleTouchMoveDolly(t), this.enableRotate && this.handleTouchMoveRotate(t);
+  }
+  addPointer(t) {
+    this.pointers.push(t);
+  }
+  removePointer(t) {
+    delete this.pointerPositions[t.pointerId];
+    for (let e = 0; e < this.pointers.length; e++)
+      if (this.pointers[e].pointerId == t.pointerId) {
+        this.pointers.splice(e, 1);
+        return;
+      }
+  }
+  trackPointer(t) {
+    let e = this.pointerPositions[t.pointerId];
+    e === void 0 && (e = new h(), this.pointerPositions[t.pointerId] = e), e.set(t.pageX, t.pageY);
+  }
+  getSecondPointer(t) {
+    return this.pointers[0].pointerId === t.pointerId ? this.pointers[1] : this.pointers[0];
+  }
+  isTrackingPointer(t) {
+    return this.pointers.some(
+      (e) => e.pointerId === t.pointerId
+    );
+  }
+};
+s(u, "DEFAULT_ZOOM_FACTOR", 1);
+let b = u;
+export {
+  b as O,
+  Z as a
+};

package/build/chunks/SpriteTextComponent-BpoKLOjA.cjs

@@ -0,0 +1 @@
+"use strict";var a=Object.defineProperty;var _=(i,e,t)=>e in i?a(i,e,{enumerable:!0,configurable:!0,writable:!0,value:t}):i[e]=t;var s=(i,e,t)=>_(i,typeof e!="symbol"?e+"":e,t);const r=require("three/webgpu"),x=require("./FileTypes-B-MjfMGd.cjs"),h=90,o=`normal ${h}px Arial`;class p extends x.DIVEComponent{constructor(){super();s(this,"isSpriteTextComponent",!0);s(this,"_text","");s(this,"_textHeight",1);s(this,"_color",new r.Color(16777215));s(this,"_canvas");s(this,"_texture");s(this,"_sprite");this.name="SpriteTextComponent",this._canvas=document.createElement("canvas"),this._texture=new r.CanvasTexture(this._canvas),this._texture.colorSpace=r.SRGBColorSpace,this._sprite=new r.Sprite(new r.SpriteMaterial({map:this._texture})),this._sprite.name="SpriteText",this.contribute(this._sprite),this._draw()}get sprite(){return this._sprite}get text(){return this._text}get textHeight(){return this._textHeight}get color(){return this._color}setText(t){return this._text=t,this._draw(),this}setTextHeight(t){return this._textHeight=t,this._draw(),this}setColor(t){return this._color.set(t),this._draw(),this}onAttach(t){this._sprite.layers.mask=t.layers.mask}copy(t){return super.copy(t),this._text=t.text,this._textHeight=t.textHeight,this._color.copy(t.color),this._draw(),this}dispose(){this._texture.dispose(),this._sprite.material.dispose()}_draw(){const t=this._canvas.getContext("2d");if(t===null)return;t.font=o;const n=Math.max(1,Math.ceil(t.measureText(this._text).width));this._canvas.width=n,this._canvas.height=h,t.font=o,t.fillStyle=`#${this._color.getHexString()}`,t.textBaseline="bottom",t.fillText(this._text,0,h),this._texture.needsUpdate=!0,this._sprite.scale.set(this._textHeight*n/h,this._textHeight,1)}}exports.SpriteTextComponent=p;

package/build/chunks/SpriteTextComponent-DIZFqao0.mjs

@@ -0,0 +1,83 @@
+var a = Object.defineProperty;
+var n = (i, e, t) => e in i ? a(i, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[e] = t;
+var s = (i, e, t) => n(i, typeof e != "symbol" ? e + "" : e, t);
+import { Color as _, CanvasTexture as x, SRGBColorSpace as p, Sprite as c, SpriteMaterial as l } from "three/webgpu";
+import { a as u } from "./FileTypes-D3Dxr2dj.mjs";
+const r = 90, o = `normal ${r}px Arial`;
+class w extends u {
+  constructor() {
+    super();
+    s(this, "isSpriteTextComponent", !0);
+    s(this, "_text", "");
+    s(this, "_textHeight", 1);
+    s(this, "_color", new _(16777215));
+    s(this, "_canvas");
+    s(this, "_texture");
+    s(this, "_sprite");
+    this.name = "SpriteTextComponent", this._canvas = document.createElement("canvas"), this._texture = new x(this._canvas), this._texture.colorSpace = p, this._sprite = new c(new l({ map: this._texture })), this._sprite.name = "SpriteText", this.contribute(this._sprite), this._draw();
+  }
+  /** The sprite the label is drawn on. */
+  get sprite() {
+    return this._sprite;
+  }
+  /** The text currently drawn. */
+  get text() {
+    return this._text;
+  }
+  /** The label's height in world units. */
+  get textHeight() {
+    return this._textHeight;
+  }
+  /** The colour the text is rasterized in. */
+  get color() {
+    return this._color;
+  }
+  /**
+   * @param text - What to write.
+   */
+  setText(t) {
+    return this._text = t, this._draw(), this;
+  }
+  /**
+   * @param textHeight - The label's height in world units.
+   */
+  setTextHeight(t) {
+    return this._textHeight = t, this._draw(), this;
+  }
+  /**
+   * @param color - The colour to rasterize the text in.
+   */
+  setColor(t) {
+    return this._color.set(t), this._draw(), this;
+  }
+  onAttach(t) {
+    this._sprite.layers.mask = t.layers.mask;
+  }
+  copy(t) {
+    return super.copy(t), this._text = t.text, this._textHeight = t.textHeight, this._color.copy(t.color), this._draw(), this;
+  }
+  dispose() {
+    this._texture.dispose(), this._sprite.material.dispose();
+  }
+  /**
+   * Rasterizes the text to the canvas and scales the sprite to the resulting
+   * aspect ratio, so the label's height matches its text height in world units.
+   */
+  _draw() {
+    const t = this._canvas.getContext("2d");
+    if (t === null) return;
+    t.font = o;
+    const h = Math.max(
+      1,
+      Math.ceil(t.measureText(this._text).width)
+    );
+    this._canvas.width = h, this._canvas.height = r, t.font = o, t.fillStyle = `#${this._color.getHexString()}`, t.textBaseline = "bottom", t.fillText(this._text, 0, r), this._texture.needsUpdate = !0, this._sprite.scale.set(
+      this._textHeight * h / r,
+      this._textHeight,
+      1
+    );
+  }
+}
+export {
+  w as S
+};