@nebula-spatial/viewer 0.4.4 → 0.4.5

package/dist/{stage-D113SHD8.js → stage-BPiGudYP.js}

@@ -1,9 +1,9 @@
-var y = Object.defineProperty;
-var b = (u, e, t) => e in u ? y(u, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : u[e] = t;
-var a = (u, e, t) => b(u, typeof e != "symbol" ? e + "" : e, t);
+var b = Object.defineProperty;
+var M = (u, t, e) => t in u ? b(u, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : u[t] = e;
+var a = (u, t, e) => M(u, typeof t != "symbol" ? t + "" : t, e);
 import * as r from "three";
-import { V as g } from "./index-D-o1ODOX.js";
-const m = 1, M = (
+import { V as x } from "./index-CxbZ--5C.js";
+const p = 1, w = (
   /* glsl */
   `
   uniform mat4 textureMatrix;
@@ -19,7 +19,7 @@ const m = 1, M = (
     gl_Position = projectionMatrix * mvPosition;
   }
 `
-), w = (
+), P = (
   /* glsl */
   `
   uniform sampler2D tDiffuse;
@@ -86,8 +86,8 @@ const m = 1, M = (
   }
 `
 );
-class P extends r.Mesh {
-  constructor({ size: t = 20, textureWidth: i = 512, textureHeight: o = 512 } = {}) {
+class C extends r.Mesh {
+  constructor({ size: e = 20, textureWidth: i = 512, textureHeight: o = 512 } = {}) {
     const s = new r.Matrix4(), l = new r.WebGLRenderTarget(i, o, {
       type: r.HalfFloatType,
       minFilter: r.LinearFilter,
@@ -107,17 +107,17 @@ class P extends r.Mesh {
         gridOpacity: { value: 1 },
         gridScale: { value: 0.2 },
         groundCenter: { value: new r.Vector2() },
-        maxRadius: { value: t * 0.5 },
-        fadeSoftness: { value: t * 0.325 }
+        maxRadius: { value: e * 0.5 },
+        fadeSoftness: { value: e * 0.325 }
       },
-      vertexShader: M,
-      fragmentShader: w,
+      vertexShader: w,
+      fragmentShader: P,
       transparent: !0,
       depthWrite: !1,
       toneMapped: !0,
       fog: !1
     });
-    super(new r.PlaneGeometry(t, t), n);
+    super(new r.PlaneGeometry(e, e), n);
     a(this, "renderTarget");
     a(this, "textureMatrix");
     a(this, "virtualCamera");
@@ -132,9 +132,9 @@ class P extends r.Mesh {
     a(this, "view");
     a(this, "target");
     a(this, "q");
-    this.renderTarget = l, this.textureMatrix = s, this.virtualCamera = new r.PerspectiveCamera(), this.virtualCamera.layers.set(m), this.clipBias = 3e-3, this.frustumCulled = !1, this.renderOrder = 1, this.position.z = 2e-3, this.reflectorPlane = new r.Plane(), this.normal = new r.Vector3(), this.reflectorWorldPosition = new r.Vector3(), this.cameraWorldPosition = new r.Vector3(), this.rotationMatrix = new r.Matrix4(), this.lookAtPosition = new r.Vector3(0, 0, -1), this.clipPlane = new r.Vector4(), this.view = new r.Vector3(), this.target = new r.Vector3(), this.q = new r.Vector4();
+    this.renderTarget = l, this.textureMatrix = s, this.virtualCamera = new r.PerspectiveCamera(), this.virtualCamera.layers.set(p), this.clipBias = 3e-3, this.frustumCulled = !1, this.renderOrder = 1, this.position.z = 2e-3, this.reflectorPlane = new r.Plane(), this.normal = new r.Vector3(), this.reflectorWorldPosition = new r.Vector3(), this.cameraWorldPosition = new r.Vector3(), this.rotationMatrix = new r.Matrix4(), this.lookAtPosition = new r.Vector3(0, 0, -1), this.clipPlane = new r.Vector4(), this.view = new r.Vector3(), this.target = new r.Vector3(), this.q = new r.Vector4();
   }
-  renderReflection(t, i, o) {
+  renderReflection(e, i, o) {
     if (this.reflectorWorldPosition.setFromMatrixPosition(this.matrixWorld), this.cameraWorldPosition.setFromMatrixPosition(o.matrixWorld), this.rotationMatrix.extractRotation(this.matrixWorld), this.normal.set(0, 0, 1).applyMatrix4(this.rotationMatrix), this.view.subVectors(this.reflectorWorldPosition, this.cameraWorldPosition), this.view.dot(this.normal) > 0) return;
     this.view.reflect(this.normal).negate().add(this.reflectorWorldPosition), this.rotationMatrix.extractRotation(o.matrixWorld), this.lookAtPosition.set(0, 0, -1).applyMatrix4(this.rotationMatrix).add(this.cameraWorldPosition), this.target.subVectors(this.reflectorWorldPosition, this.lookAtPosition).reflect(this.normal).negate().add(this.reflectorWorldPosition), this.virtualCamera.position.copy(this.view), this.virtualCamera.up.set(0, 1, 0).applyMatrix4(this.rotationMatrix).reflect(this.normal), this.virtualCamera.lookAt(this.target), this.virtualCamera.near = o.near, this.virtualCamera.far = o.far, this.virtualCamera.updateMatrixWorld(), this.virtualCamera.projectionMatrix.copy(o.projectionMatrix), this.textureMatrix.set(
       0.5,
@@ -166,54 +166,54 @@ class P extends r.Mesh {
       -1,
       (1 + s.elements[10]) / s.elements[14]
     ), this.clipPlane.multiplyScalar(2 / this.clipPlane.dot(this.q)), s.elements[2] = this.clipPlane.x, s.elements[6] = this.clipPlane.y, s.elements[10] = this.clipPlane.z + 1 - this.clipBias, s.elements[14] = this.clipPlane.w, this.virtualCamera.projectionMatrixInverse.copy(s).invert();
-    const l = t.getRenderTarget(), n = t.xr.enabled, c = t.shadowMap.autoUpdate, d = t.shadowMap.enabled;
+    const l = e.getRenderTarget(), n = e.xr.enabled, c = e.shadowMap.autoUpdate, d = e.shadowMap.enabled;
     try {
-      t.xr.enabled = !1, t.shadowMap.enabled = !1, t.shadowMap.autoUpdate = !1, t.setRenderTarget(this.renderTarget), t.state.buffers.depth.setMask(!0), t.clear(), t.render(i, this.virtualCamera);
+      e.xr.enabled = !1, e.shadowMap.enabled = !1, e.shadowMap.autoUpdate = !1, e.setRenderTarget(this.renderTarget), e.state.buffers.depth.setMask(!0), e.clear(), e.render(i, this.virtualCamera);
     } finally {
-      t.setRenderTarget(l), t.xr.enabled = n, t.shadowMap.enabled = d, t.shadowMap.autoUpdate = c;
+      e.setRenderTarget(l), e.xr.enabled = n, e.shadowMap.enabled = d, e.shadowMap.autoUpdate = c;
     }
   }
-  setRenderSize(t, i) {
-    this.renderTarget.setSize(t, i), this.material.uniforms.resolution.value.set(t, i);
+  setRenderSize(e, i) {
+    this.renderTarget.setSize(e, i), this.material.uniforms.resolution.value.set(e, i);
   }
   // Radius is in world units; the outer 65% fades before the square mesh edge.
-  setRadius(t, i, o = this.material.uniforms.groundCenter.value) {
-    this.scale.setScalar(t * 2 / this.geometry.parameters.width), this.position.x = o.x, this.position.y = o.y, this.material.uniforms.groundCenter.value.set(o.x, o.y), this.material.uniforms.gridScale.value = i, this.material.uniforms.maxRadius.value = t, this.material.uniforms.fadeSoftness.value = t * 0.65;
+  setRadius(e, i, o = this.material.uniforms.groundCenter.value) {
+    this.scale.setScalar(e * 2 / this.geometry.parameters.width), this.position.x = o.x, this.position.y = o.y, this.material.uniforms.groundCenter.value.set(o.x, o.y), this.material.uniforms.gridScale.value = i, this.material.uniforms.maxRadius.value = e, this.material.uniforms.fadeSoftness.value = e * 0.65;
   }
 }
 const v = {
   light: {
-    background: g.light,
+    background: x.light,
     fineGrid: 5859168,
     coarseGrid: 3427136,
     gridOpacity: 0.85,
     reflectionMix: 0.06
   },
   dark: {
-    background: g.dark,
+    background: x.dark,
     fineGrid: 7375236,
     coarseGrid: 5552554,
     gridOpacity: 0.9,
     reflectionMix: 0.06
   }
-}, C = {
+}, S = {
   simulation: 0.68,
   model: 1.4
 };
-function x(u, e = []) {
+function y(u, t = []) {
   var l;
-  const t = /* @__PURE__ */ new Set(), i = /* @__PURE__ */ new Set(), o = new Set(e), s = /* @__PURE__ */ new Set();
+  const e = /* @__PURE__ */ new Set(), i = /* @__PURE__ */ new Set(), o = new Set(t), s = /* @__PURE__ */ new Set();
   u.traverse((n) => {
     const c = n;
-    c.geometry && t.add(c.geometry);
+    c.geometry && e.add(c.geometry);
     for (const d of Array.isArray(c.material) ? c.material : [c.material])
       if (d) {
         i.add(d);
         for (const h of Object.values(d))
-          S(h) && o.add(h);
+          G(h) && o.add(h);
       }
   });
-  for (const n of t) n.dispose();
+  for (const n of e) n.dispose();
   for (const n of i) n.dispose();
   for (const n of o) {
     const c = (l = n.source) == null ? void 0 : l.data;
@@ -221,22 +221,35 @@ function x(u, e = []) {
   }
   for (const n of s) n.close();
 }
-function S(u) {
+function G(u) {
   return !!(u && typeof u == "object" && u.isTexture);
 }
-const V = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const W = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  disposeModelResources: x
-}, Symbol.toStringTag, { value: "Module" })), f = 2213822, G = 6000111, R = 6;
-function T(u, e, t) {
-  e.updateMatrixWorld();
+  disposeModelResources: y
+}, Symbol.toStringTag, { value: "Module" })), f = 2213822, R = 6000111, T = 6;
+function L(u, t, e) {
+  t.updateMatrixWorld();
   const i = new r.Vector3();
-  return e.getWorldDirection(i).normalize(), u.setFromNormalAndCoplanarPoint(i, t);
+  return t.getWorldDirection(i).normalize(), u.setFromNormalAndCoplanarPoint(i, e);
 }
-class W {
-  constructor(e, t = "dark", i, o = "simulation") {
+function m(u) {
+  u.updateWorldMatrix(!0, !0);
+  const t = new r.Box3();
+  return u.traverse((e) => {
+    if (!(e instanceof r.Mesh)) return;
+    let i = e;
+    for (; i; ) {
+      if (i.userData.excludeFromSimulationFit || !i.visible) return;
+      i = i.parent;
+    }
+    e.geometry.boundingBox || e.geometry.computeBoundingBox(), e.geometry.boundingBox && t.union(e.geometry.boundingBox.clone().applyMatrix4(e.matrixWorld));
+  }), t.isEmpty() ? new r.Box3().setFromObject(u) : t;
+}
+class B {
+  constructor(t, e = "dark", i, o = "simulation") {
     a(this, "root", new r.Group());
-    a(this, "reflector", new P({ size: 100, textureWidth: 256, textureHeight: 256 }));
+    a(this, "reflector", new C({ size: 100, textureWidth: 256, textureHeight: 256 }));
     a(this, "values");
     a(this, "fog");
     a(this, "raycaster", new r.Raycaster());
@@ -254,36 +267,36 @@ class W {
     a(this, "size", "");
     a(this, "groundVisible");
     a(this, "disposed", !1);
-    this.model = e, this.runtime = i, this.presentation = o, this.values = v[t];
-    const s = this.values, l = new r.Box3().setFromObject(e), n = Math.max(...l.getSize(new r.Vector3()).toArray());
+    this.model = t, this.runtime = i, this.presentation = o, this.values = v[e];
+    const s = this.values, l = m(t), n = Math.max(...l.getSize(new r.Vector3()).toArray());
     if (!Number.isFinite(n) || n <= 0) throw new Error("Empty simulation geometry.");
-    this.root.add(e), this.forceLine = this.createForceLine(), this.root.add(this.forceLine), e.traverse((p) => {
-      p instanceof r.Mesh && p.layers.enable(m);
+    this.root.add(t), this.forceLine = this.createForceLine(), this.root.add(this.forceLine), t.traverse((g) => {
+      g instanceof r.Mesh && g.layers.enable(p);
     }), this.root.add(this.reflector);
     const c = Math.max(l.getSize(new r.Vector3()).length() * 0.5, 0.02), d = this.reflector.material.uniforms;
     d.fineGridColor.value.setHex(s.fineGrid), d.coarseGridColor.value.setHex(s.coarseGrid), d.gridOpacity.value = s.gridOpacity, d.reflectionMix.value = s.reflectionMix, this.layoutGround(l, c), this.groundVisible = o === "simulation", this.setGroundVisible(this.groundVisible);
     const h = c / Math.sin(r.MathUtils.degToRad(38) / 2) * 1.25;
     this.fog = new r.Fog(s.background, h * 2.5, h * 8);
   }
-  setRuntime(e) {
-    this.disposed || this.runtime === e || (this.endGrab(), this.runtime = e, this.bodyGroups.clear());
+  setRuntime(t) {
+    this.disposed || this.runtime === t || (this.endGrab(), this.runtime = t, this.bodyGroups.clear());
   }
-  replaceModel(e, t = !0) {
-    this.disposed || e === this.model || (this.endGrab(), this.bodyGroups.clear(), this.model.removeFromParent(), this.model = e, this.root.add(e), e.traverse((i) => {
-      i instanceof r.Mesh && i.layers.enable(m);
-    }), t && this.reseatGround());
+  replaceModel(t, e = !0) {
+    this.disposed || t === this.model || (this.endGrab(), this.bodyGroups.clear(), this.model.removeFromParent(), this.model = t, this.root.add(t), t.traverse((i) => {
+      i instanceof r.Mesh && i.layers.enable(p);
+    }), e && this.reseatGround());
   }
   resetGround() {
-    var e;
-    this.disposed || (this.reflector.position.z = (((e = this.runtime) == null ? void 0 : e.defaultGroundHeight) ?? 0) + 2e-3);
+    var t;
+    this.disposed || (this.reflector.position.z = (((t = this.runtime) == null ? void 0 : t.defaultGroundHeight) ?? 0) + 2e-3);
   }
-  setTheme(e) {
+  setTheme(t) {
     if (this.disposed) return;
-    const t = this.values = v[e], i = this.reflector.material.uniforms;
-    i.fineGridColor.value.setHex(t.fineGrid), i.coarseGridColor.value.setHex(t.coarseGrid), i.gridOpacity.value = t.gridOpacity, i.reflectionMix.value = t.reflectionMix, this.fog.color.setHex(t.background);
+    const e = this.values = v[t], i = this.reflector.material.uniforms;
+    i.fineGridColor.value.setHex(e.fineGrid), i.coarseGridColor.value.setHex(e.coarseGrid), i.gridOpacity.value = e.gridOpacity, i.reflectionMix.value = e.reflectionMix, this.fog.color.setHex(e.background);
   }
-  layoutGround(e, t) {
-    this.reflector.setRadius(t * 8, Math.pow(10, Math.floor(Math.log10(Math.max(t, 0.01)))), e.getCenter(new r.Vector3()));
+  layoutGround(t, e) {
+    this.reflector.setRadius(e * 8, Math.pow(10, Math.floor(Math.log10(Math.max(e, 0.01)))), t.getCenter(new r.Vector3()));
   }
   /**
    * Re-fits the ground disc and reflection to the model's current world bounds.
@@ -294,67 +307,67 @@ class W {
   reseatGround() {
     if (this.disposed) return;
     this.root.updateMatrixWorld(!0);
-    const e = new r.Box3().setFromObject(this.model);
-    e.isEmpty() || this.layoutGround(e, Math.max(e.getSize(new r.Vector3()).length() * 0.5, 0.02));
+    const t = m(this.model);
+    t.isEmpty() || this.layoutGround(t, Math.max(t.getSize(new r.Vector3()).length() * 0.5, 0.02));
   }
   createForceLine() {
-    const e = new r.BufferGeometry().setFromPoints([
+    const t = new r.BufferGeometry().setFromPoints([
       new r.Vector3(),
       new r.Vector3()
-    ]), t = new r.LineBasicMaterial({
+    ]), e = new r.LineBasicMaterial({
       color: f,
       depthTest: !1,
       transparent: !0
-    }), i = new r.Line(e, t);
+    }), i = new r.Line(t, e);
     return i.renderOrder = 1e3, i.visible = !1, i;
   }
-  findBodyGroup(e) {
+  findBodyGroup(t) {
     var i;
-    let t = e;
-    for (; t && t !== this.model && t !== this.root; ) {
-      if (typeof ((i = t.userData) == null ? void 0 : i.bodyId) == "number") return t;
-      t = t.parent;
+    let e = t;
+    for (; e && e !== this.model && e !== this.root; ) {
+      if (typeof ((i = e.userData) == null ? void 0 : i.bodyId) == "number") return e;
+      e = e.parent;
     }
     return null;
   }
-  getBodyGroup(e) {
-    let t = this.bodyGroups.get(e);
-    return t || this.model.traverse((i) => {
+  getBodyGroup(t) {
+    let e = this.bodyGroups.get(t);
+    return e || this.model.traverse((i) => {
       var o;
-      ((o = i.userData) == null ? void 0 : o.bodyId) === e && (t = i, this.bodyGroups.set(e, i));
-    }), t;
+      ((o = i.userData) == null ? void 0 : o.bodyId) === t && (e = i, this.bodyGroups.set(t, i));
+    }), e;
   }
-  pointerRay(e, t, i) {
+  pointerRay(t, e, i) {
     const o = i.getBoundingClientRect();
     this.pointer.set(
-      (e.clientX - o.left) / o.width * 2 - 1,
-      -((e.clientY - o.top) / o.height) * 2 + 1
-    ), this.raycaster.setFromCamera(this.pointer, t);
+      (t.clientX - o.left) / o.width * 2 - 1,
+      -((t.clientY - o.top) / o.height) * 2 + 1
+    ), this.raycaster.setFromCamera(this.pointer, e);
   }
-  setForceBoost(e) {
-    var t;
-    !((t = this.runtime) != null && t.grab) || e === this.forceBoosted || (this.forceBoosted = e, this.runtime.updateGrabStrength(e ? R : 1), this.forceLine.material.color.setHex(e ? G : f));
+  setForceBoost(t) {
+    var e;
+    !((e = this.runtime) != null && e.grab) || t === this.forceBoosted || (this.forceBoosted = t, this.runtime.updateGrabStrength(t ? T : 1), this.forceLine.material.color.setHex(t ? R : f));
   }
-  beginGrab(e, t, i) {
+  beginGrab(t, e, i) {
     if (!this.runtime || this.disposed) return !1;
-    this.pointerRay(e, t, i);
+    this.pointerRay(t, e, i);
     const o = this.raycaster.intersectObject(this.model, !0).find((c) => c.object.isMesh);
     if (!o) return !1;
     const s = this.findBodyGroup(o.object);
     if (!s) return !1;
     const l = s.worldToLocal(o.point.clone());
-    this.dragTarget.copy(o.point), T(this.dragPlane, t, o.point), this.dragOffset.set(0, 0, 0);
+    this.dragTarget.copy(o.point), L(this.dragPlane, e, o.point), this.dragOffset.set(0, 0, 0);
     const n = this.root.worldToLocal(o.point.clone());
     return this.bodyGroups.set(s.userData.bodyId, s), this.runtime.beginGrab({
       bodyId: s.userData.bodyId,
       localPoint: [l.x, l.y, l.z],
       target: [n.x, n.y, n.z]
-    }), this.forceBoosted = !1, this.setForceBoost(e.shiftKey), this.forceLine.visible = !0, this.updateForceLine(), this.grabCanvas = i, i != null && i.style && (this.previousCursor = i.style.cursor, i.style.cursor = "grabbing"), !0;
+    }), this.forceBoosted = !1, this.setForceBoost(t.shiftKey), this.forceLine.visible = !0, this.updateForceLine(), this.grabCanvas = i, i != null && i.style && (this.previousCursor = i.style.cursor, i.style.cursor = "grabbing"), !0;
   }
-  moveGrab(e, t, i) {
+  moveGrab(t, e, i) {
     var s;
     if (!((s = this.runtime) != null && s.grab)) return;
-    if (this.pointerRay(e, t, i), this.setForceBoost(e.shiftKey), i != null && i.style && i.style.cursor !== "grabbing" && (i.style.cursor = "grabbing"), this.raycaster.ray.intersectPlane(this.dragPlane, this.dragIntersection))
+    if (this.pointerRay(t, e, i), this.setForceBoost(t.shiftKey), i != null && i.style && i.style.cursor !== "grabbing" && (i.style.cursor = "grabbing"), this.raycaster.ray.intersectPlane(this.dragPlane, this.dragIntersection))
       this.dragTarget.copy(this.dragIntersection).add(this.dragOffset);
     else
       return;
@@ -362,37 +375,37 @@ class W {
     this.runtime.updateGrabTarget([o.x, o.y, o.z]), this.updateForceLine();
   }
   endGrab() {
-    var e;
-    this.runtime && (this.runtime.endGrab(), this.forceBoosted = !1, this.forceLine.visible = !1, this.forceLine.material.color.setHex(f), (e = this.grabCanvas) != null && e.style && (this.grabCanvas.style.cursor = this.previousCursor), this.grabCanvas = null);
+    var t;
+    this.runtime && (this.runtime.endGrab(), this.forceBoosted = !1, this.forceLine.visible = !1, this.forceLine.material.color.setHex(f), (t = this.grabCanvas) != null && t.style && (this.grabCanvas.style.cursor = this.previousCursor), this.grabCanvas = null);
   }
   updateForceLine() {
     var n;
-    const e = (n = this.runtime) == null ? void 0 : n.grab;
-    if (!e) return;
-    const t = this.getBodyGroup(e.bodyId);
+    const t = (n = this.runtime) == null ? void 0 : n.grab;
     if (!t) return;
-    const i = new r.Vector3().fromArray(e.localPoint), o = t.localToWorld(i), s = this.root.worldToLocal(o), l = this.forceLine.geometry.attributes.position;
-    l.setXYZ(0, s.x, s.y, s.z), l.setXYZ(1, e.target[0], e.target[1], e.target[2]), l.needsUpdate = !0;
+    const e = this.getBodyGroup(t.bodyId);
+    if (!e) return;
+    const i = new r.Vector3().fromArray(t.localPoint), o = e.localToWorld(i), s = this.root.worldToLocal(o), l = this.forceLine.geometry.attributes.position;
+    l.setXYZ(0, s.x, s.y, s.z), l.setXYZ(1, t.target[0], t.target[1], t.target[2]), l.needsUpdate = !0;
   }
-  beforeRender(e, t, i) {
+  beforeRender(t, e, i) {
     var l, n;
     const o = {
-      tone: e.toneMapping,
-      exposure: e.toneMappingExposure,
-      color: e.outputColorSpace,
-      environment: t.environment,
-      fog: t.fog,
-      background: t.background
+      tone: t.toneMapping,
+      exposure: t.toneMappingExposure,
+      color: t.outputColorSpace,
+      environment: e.environment,
+      fog: e.fog,
+      background: e.background
     }, s = () => {
-      e.toneMapping = o.tone, e.toneMappingExposure = o.exposure, e.outputColorSpace = o.color, t.environment = o.environment, t.fog = o.fog, t.background = o.background;
+      t.toneMapping = o.tone, t.toneMappingExposure = o.exposure, t.outputColorSpace = o.color, e.environment = o.environment, e.fog = o.fog, e.background = o.background;
     };
     if (this.disposed) return s;
     try {
       (l = this.runtime) != null && l.grab && this.updateForceLine();
       const c = (n = this.runtime) == null ? void 0 : n.defaultGroundHeight;
-      c !== void 0 && (this.reflector.position.z = c + 2e-3), e.toneMapping = r.ACESFilmicToneMapping, e.toneMappingExposure = C[this.presentation], e.outputColorSpace = r.SRGBColorSpace, t.background = new r.Color(this.values.background), t.fog = this.fog;
-      const d = e.getSize(new r.Vector2()), h = `${d.x}:${d.y}`;
-      return h !== this.size && (this.size = h, this.reflector.setRenderSize(Math.max(1, Math.floor(d.x * 0.35)), Math.max(1, Math.floor(d.y * 0.35)))), t.updateMatrixWorld(!0), i.updateMatrixWorld(!0), this.groundVisible && i instanceof r.PerspectiveCamera && this.reflector.renderReflection(e, t, i), s;
+      c !== void 0 && (this.reflector.position.z = c + 2e-3), t.toneMapping = r.ACESFilmicToneMapping, t.toneMappingExposure = S[this.presentation], t.outputColorSpace = r.SRGBColorSpace, e.background = new r.Color(this.values.background), e.fog = this.fog;
+      const d = t.getSize(new r.Vector2()), h = `${d.x}:${d.y}`;
+      return h !== this.size && (this.size = h, this.reflector.setRenderSize(Math.max(1, Math.floor(d.x * 0.35)), Math.max(1, Math.floor(d.y * 0.35)))), e.updateMatrixWorld(!0), i.updateMatrixWorld(!0), this.groundVisible && i instanceof r.PerspectiveCamera && this.reflector.renderReflection(t, e, i), s;
     } catch (c) {
       throw s(), c;
     }
@@ -401,8 +414,8 @@ class W {
    * The reflector mesh carries both the grid lines and the reflection. Hiding
    * it also skips the reflection render pass, which only feeds its shader.
    */
-  setGroundVisible(e) {
-    this.groundVisible = e, this.reflector.visible = e;
+  setGroundVisible(t) {
+    this.groundVisible = t, this.reflector.visible = t;
   }
   getGroundVisible() {
     return this.groundVisible;
@@ -413,29 +426,29 @@ class W {
    * so nesting hidden aids (collision meshes, which are far larger than the
    * visual shell) would inflate both the reflection extent and the camera fit.
    */
-  attachAuxiliary(e) {
-    this.auxiliaries.add(e), this.root.add(e);
+  attachAuxiliary(t) {
+    this.auxiliaries.add(t), this.root.add(t);
   }
-  detachAuxiliary(e) {
-    this.auxiliaries.delete(e) && e.removeFromParent();
+  detachAuxiliary(t) {
+    this.auxiliaries.delete(t) && t.removeFromParent();
   }
   getModelBounds() {
     this.root.updateMatrixWorld(!0);
-    const e = new r.Box3().setFromObject(this.model);
-    if (!e.isEmpty()) return e;
-    const t = new r.Box3();
-    return t.min.set(-5e3, -5e3, -5e3), t.max.set(5e3, 5e3, 5e3), t;
+    const t = m(this.model);
+    if (!t.isEmpty()) return t;
+    const e = new r.Box3();
+    return e.min.set(-5e3, -5e3, -5e3), e.max.set(5e3, 5e3, 5e3), e;
   }
   dispose() {
     if (!this.disposed) {
       this.disposed = !0, this.endGrab(), this.model.removeFromParent();
-      for (const e of this.auxiliaries) e.removeFromParent();
-      this.auxiliaries.clear(), this.root.removeFromParent(), this.reflector.renderTarget.dispose(), x(this.root);
+      for (const t of this.auxiliaries) t.removeFromParent();
+      this.auxiliaries.clear(), this.root.removeFromParent(), this.reflector.renderTarget.dispose(), y(this.root);
     }
   }
 }
 export {
-  W as S,
-  x as d,
-  V as r
+  B as S,
+  y as d,
+  W as r
 };