softbox 4.2.0 → 4.2.2

package/dist/{ThreePathTracingService-BE8t2ThI.js → ThreePathTracingService-bdhnuLzE.js}

@@ -1,7 +1,7 @@
-import * as H from "three";
-import { UnsignedIntType as re, DataTexture as M, NearestFilter as T, IntType as Te, FloatType as R, UnsignedByteType as _e, UnsignedShortType as Mt, ByteType as Be, ShortType as At, RGBAFormat as I, RGBAIntegerFormat as Me, RGIntegerFormat as ut, RedIntegerFormat as Ft, RGFormat as ht, RedFormat as me, BufferAttribute as P, BufferGeometry as $, Matrix4 as O, Matrix3 as Ct, Vector3 as C, Vector4 as J, MeshBasicMaterial as Dt, Mesh as ft, OrthographicCamera as Pt, Float32BufferAttribute as He, ShaderMaterial as pe, NoBlending as ie, WebGLRenderTarget as ae, Vector2 as j, PerspectiveCamera as dt, DataUtils as k, HalfFloatType as D, LinearFilter as F, RepeatWrapping as z, ClampToEdgeWrapping as N, Source as Et, Quaternion as kt, DataArrayTexture as Ot, DoubleSide as zt, BackSide as Nt, FrontSide as Bt, WebGLArrayRenderTarget as Ht, Color as se, NoToneMapping as Wt, NormalBlending as mt, EquirectangularReflectionMapping as pt, Spherical as Lt, LinearMipMapLinearFilter as Ut, Clock as Vt, Scene as Gt, AdditiveBlending as qt } from "three";
-import { g as $t, a as jt, B as We, I as Yt, C as Xt, O as Qt, S as Kt, b as Zt, L as Jt, c as er, M as tr, T as rr, D as ar, R as S, d as W, E as L, h as Le } from "./index-B0k0_Cfm.js";
-function ir(s) {
+import * as B from "three";
+import { UnsignedIntType as re, DataTexture as M, NearestFilter as T, IntType as Te, FloatType as R, UnsignedByteType as _e, UnsignedShortType as Mt, ByteType as He, ShortType as At, RGBAFormat as I, RGBAIntegerFormat as Me, RGIntegerFormat as ut, RedIntegerFormat as Ft, RGFormat as ht, RedFormat as me, BufferAttribute as P, BufferGeometry as $, Matrix4 as O, Matrix3 as Ct, Vector3 as C, Vector4 as J, MeshBasicMaterial as Dt, Mesh as ft, OrthographicCamera as Pt, Float32BufferAttribute as Be, ShaderMaterial as pe, NoBlending as ie, WebGLRenderTarget as ae, Vector2 as j, PerspectiveCamera as dt, DataUtils as k, HalfFloatType as D, LinearFilter as F, RepeatWrapping as z, ClampToEdgeWrapping as N, Source as Et, Quaternion as kt, DataArrayTexture as Ot, DoubleSide as zt, BackSide as Nt, FrontSide as Ht, WebGLArrayRenderTarget as Bt, Color as se, NoToneMapping as Wt, NormalBlending as mt, EquirectangularReflectionMapping as pt, Spherical as Lt, LinearMipMapLinearFilter as Ut, Clock as Vt, Scene as Gt, AdditiveBlending as qt } from "three";
+import { g as $t, a as jt, B as We, I as Yt, C as Xt, O as Qt, S as Kt, b as Zt, L as Jt, c as er, M as tr, T as rr, D as ar, d as ir, R as S, e as W, E as L, h as Le } from "./index-D9zA-xWX.js";
+function sr(s) {
   switch (s) {
     case 1:
       return "R";
@@ -14,7 +14,7 @@ function ir(s) {
   }
   throw new Error();
 }
-function sr(s) {
+function or(s) {
   switch (s) {
     case 1:
       return me;
@@ -59,44 +59,44 @@ class gt extends M {
         throw new Error("VertexAttributeTexture: overrideItemSize must divide evenly into buffer length.");
       e.itemSize = t, e.count = i * r / t;
     }
-    const o = e.itemSize, a = e.count, l = e.normalized, h = e.array.constructor, f = h.BYTES_PER_ELEMENT;
-    let d = this._forcedType, u = o;
-    if (d === null)
+    const o = e.itemSize, a = e.count, l = e.normalized, h = e.array.constructor, d = h.BYTES_PER_ELEMENT;
+    let f = this._forcedType, u = o;
+    if (f === null)
       switch (h) {
         case Float32Array:
-          d = R;
+          f = R;
           break;
         case Uint8Array:
         case Uint16Array:
         case Uint32Array:
-          d = re;
+          f = re;
           break;
         case Int8Array:
         case Int16Array:
         case Int32Array:
-          d = Te;
+          f = Te;
           break;
       }
-    let n, v, m, g, c = ir(o);
-    switch (d) {
+    let n, x, m, g, c = sr(o);
+    switch (f) {
       case R:
-        m = 1, v = sr(o), l && f === 1 ? (g = h, c += "8", h === Uint8Array ? n = _e : (n = Be, c += "_SNORM")) : (g = Float32Array, c += "32F", n = R);
+        m = 1, x = or(o), l && d === 1 ? (g = h, c += "8", h === Uint8Array ? n = _e : (n = He, c += "_SNORM")) : (g = Float32Array, c += "32F", n = R);
         break;
       case Te:
-        c += f * 8 + "I", m = l ? Math.pow(2, h.BYTES_PER_ELEMENT * 8 - 1) : 1, v = Ue(o), f === 1 ? (g = Int8Array, n = Be) : f === 2 ? (g = Int16Array, n = At) : (g = Int32Array, n = Te);
+        c += d * 8 + "I", m = l ? Math.pow(2, h.BYTES_PER_ELEMENT * 8 - 1) : 1, x = Ue(o), d === 1 ? (g = Int8Array, n = He) : d === 2 ? (g = Int16Array, n = At) : (g = Int32Array, n = Te);
         break;
       case re:
-        c += f * 8 + "UI", m = l ? Math.pow(2, h.BYTES_PER_ELEMENT * 8 - 1) : 1, v = Ue(o), f === 1 ? (g = Uint8Array, n = _e) : f === 2 ? (g = Uint16Array, n = Mt) : (g = Uint32Array, n = re);
+        c += d * 8 + "UI", m = l ? Math.pow(2, h.BYTES_PER_ELEMENT * 8 - 1) : 1, x = Ue(o), d === 1 ? (g = Uint8Array, n = _e) : d === 2 ? (g = Uint16Array, n = Mt) : (g = Uint32Array, n = re);
         break;
     }
-    u === 3 && (v === I || v === Me) && (u = 4);
-    const p = Math.ceil(Math.sqrt(a)) || 1, x = u * p * p, b = new g(x), y = e.normalized;
+    u === 3 && (x === I || x === Me) && (u = 4);
+    const p = Math.ceil(Math.sqrt(a)) || 1, v = u * p * p, b = new g(v), y = e.normalized;
     e.normalized = !1;
     for (let w = 0; w < a; w++) {
       const E = u * w;
       b[E] = e.getX(w) / m, o >= 2 && (b[E + 1] = e.getY(w) / m), o >= 3 && (b[E + 2] = e.getZ(w) / m, u === 4 && (b[E + 3] = 1)), o >= 4 && (b[E + 3] = e.getW(w) / m);
     }
-    e.normalized = y, this.internalFormat = c, this.format = v, this.type = n, this.image.width = p, this.image.height = p, this.image.data = b, this.needsUpdate = !0, this.dispose(), e.itemSize = r, e.count = i;
+    e.normalized = y, this.internalFormat = c, this.format = x, this.type = n, this.image.width = p, this.image.height = p, this.image.data = b, this.needsUpdate = !0, this.dispose(), e.itemSize = r, e.count = i;
   }
 }
 class vt extends gt {
@@ -109,7 +109,7 @@ class xt extends gt {
     super(), this._forcedType = R;
   }
 }
-class or {
+class nr {
   constructor() {
     this.index = new vt(), this.position = new xt(), this.bvhBounds = new M(), this.bvhContents = new M(), this._cachedIndexAttr = null, this.index.overrideItemSize = 3;
   }
@@ -121,7 +121,7 @@ class or {
    */
   updateFrom(e) {
     const { geometry: t } = e;
-    if (lr(e, this.bvhBounds, this.bvhContents), this.position.updateFrom(t.attributes.position), e.indirect) {
+    if (cr(e, this.bvhBounds, this.bvhContents), this.position.updateFrom(t.attributes.position), e.indirect) {
       const r = e._indirectBuffer;
       if (this._cachedIndexAttr === null || this._cachedIndexAttr.count !== r.length)
         if (t.index)
@@ -130,7 +130,7 @@ class or {
           const i = $t(jt(t));
           this._cachedIndexAttr = new P(i, 1, !1);
         }
-      nr(t, r, this._cachedIndexAttr), this.index.updateFrom(this._cachedIndexAttr);
+      lr(t, r, this._cachedIndexAttr), this.index.updateFrom(this._cachedIndexAttr);
     } else
       this.index.updateFrom(t.index);
   }
@@ -144,34 +144,34 @@ class or {
     e && e.dispose(), t && t.dispose(), r && r.dispose(), i && i.dispose();
   }
 }
-function nr(s, e, t) {
+function lr(s, e, t) {
   const r = t.array, i = s.index ? s.index.array : null;
   for (let o = 0, a = e.length; o < a; o++) {
     const l = 3 * o, h = 3 * e[o];
-    for (let f = 0; f < 3; f++)
-      r[l + f] = i ? i[h + f] : h + f;
+    for (let d = 0; d < 3; d++)
+      r[l + d] = i ? i[h + d] : h + d;
   }
 }
-function lr(s, e, t) {
+function cr(s, e, t) {
   const r = s._roots;
   if (r.length !== 1)
     throw new Error("MeshBVHUniformStruct: Multi-root BVHs not supported.");
-  const i = r[0], o = new Uint16Array(i), a = new Uint32Array(i), l = new Float32Array(i), h = i.byteLength / We, f = 2 * Math.ceil(Math.sqrt(h / 2)), d = new Float32Array(4 * f * f), u = Math.ceil(Math.sqrt(h)), n = new Uint32Array(2 * u * u);
-  for (let v = 0; v < h; v++) {
-    const m = v * We / 4, g = m * 2, c = Zt(m);
+  const i = r[0], o = new Uint16Array(i), a = new Uint32Array(i), l = new Float32Array(i), h = i.byteLength / We, d = 2 * Math.ceil(Math.sqrt(h / 2)), f = new Float32Array(4 * d * d), u = Math.ceil(Math.sqrt(h)), n = new Uint32Array(2 * u * u);
+  for (let x = 0; x < h; x++) {
+    const m = x * We / 4, g = m * 2, c = Zt(m);
     for (let p = 0; p < 3; p++)
-      d[8 * v + 0 + p] = l[c + 0 + p], d[8 * v + 4 + p] = l[c + 3 + p];
+      f[8 * x + 0 + p] = l[c + 0 + p], f[8 * x + 4 + p] = l[c + 3 + p];
     if (Yt(g, o)) {
-      const p = Xt(g, o), x = Qt(m, a), b = Jt | p;
-      n[v * 2 + 0] = b, n[v * 2 + 1] = x;
+      const p = Xt(g, o), v = Qt(m, a), b = Jt | p;
+      n[x * 2 + 0] = b, n[x * 2 + 1] = v;
     } else {
-      const p = a[m + 6], x = Kt(m, a);
-      n[v * 2 + 0] = x, n[v * 2 + 1] = p;
+      const p = a[m + 6], v = Kt(m, a);
+      n[x * 2 + 0] = v, n[x * 2 + 1] = p;
     }
   }
-  e.image.data = d, e.image.width = f, e.image.height = f, e.format = I, e.type = R, e.internalFormat = "RGBA32F", e.minFilter = T, e.magFilter = T, e.generateMipmaps = !1, e.needsUpdate = !0, e.dispose(), t.image.data = n, t.image.width = u, t.image.height = u, t.format = ut, t.type = re, t.internalFormat = "RG32UI", t.minFilter = T, t.magFilter = T, t.generateMipmaps = !1, t.needsUpdate = !0, t.dispose();
+  e.image.data = f, e.image.width = d, e.image.height = d, e.format = I, e.type = R, e.internalFormat = "RGBA32F", e.minFilter = T, e.magFilter = T, e.generateMipmaps = !1, e.needsUpdate = !0, e.dispose(), t.image.data = n, t.image.width = u, t.image.height = u, t.format = ut, t.type = re, t.internalFormat = "RG32UI", t.minFilter = T, t.magFilter = T, t.generateMipmaps = !1, t.needsUpdate = !0, t.dispose();
 }
-const cr = (
+const ur = (
   /* glsl */
   `
 
@@ -256,7 +256,7 @@ void ndcToCameraRay(
 
 }
 `
-), ur = (
+), hr = (
   /* glsl */
   `
 
@@ -463,7 +463,7 @@ bool _bvhIntersectFirstHit(
 
 }
 `
-), hr = (
+), fr = (
   /* glsl */
   `
 struct BVH {
@@ -501,7 +501,7 @@ function Z(s, e) {
   const t = s.count === e.count, r = s.normalized === e.normalized, i = s.array.constructor === e.array.constructor, o = s.itemSize === e.itemSize;
   return !(!t || !r || !i || !o);
 }
-function fr(s) {
+function dr(s) {
   const e = s[0].index !== null, t = new Set(Object.keys(s[0].attributes));
   if (!s[0].getAttribute("position"))
     throw new Error("StaticGeometryGenerator: position attribute is required.");
@@ -519,36 +519,36 @@ function fr(s) {
       throw new Error("StaticGeometryGenerator: All geometries must have the same number of attributes.");
   }
 }
-function dr(s) {
+function mr(s) {
   let e = 0;
   for (let t = 0, r = s.length; t < r; t++)
     e += s[t].getIndex().count;
   return e;
 }
-function mr(s) {
+function pr(s) {
   let e = 0;
   for (let t = 0, r = s.length; t < r; t++)
     e += s[t].getAttribute("position").count;
   return e;
 }
-function pr(s, e, t) {
+function gr(s, e, t) {
   s.index && s.index.count !== e && s.setIndex(null);
   const r = s.attributes;
   for (const i in r)
     r[i].count !== t && s.deleteAttribute(i);
 }
-function gr(s, e = {}, t = new $()) {
+function vr(s, e = {}, t = new $()) {
   const {
     useGroups: r = !1,
     forceUpdate: i = !1,
     skipAssigningAttributes: o = [],
     overwriteIndex: a = !0
   } = e;
-  fr(s);
-  const l = s[0].index !== null, h = l ? dr(s) : -1, f = mr(s);
-  if (pr(t, h, f), r) {
+  dr(s);
+  const l = s[0].index !== null, h = l ? mr(s) : -1, d = pr(s);
+  if (gr(t, h, d), r) {
     let u = 0;
-    for (let n = 0, v = s.length; n < v; n++) {
+    for (let n = 0, x = s.length; n < x; n++) {
       const m = s[n];
       let g;
       l ? g = m.getIndex().count : g = m.getAttribute("position").count, t.addGroup(u, g, n), u += g;
@@ -557,52 +557,52 @@ function gr(s, e = {}, t = new $()) {
   if (l) {
     let u = !1;
     if (t.index || (t.setIndex(new P(new Uint32Array(h), 1, !1)), u = !0), u || a) {
-      let n = 0, v = 0;
+      let n = 0, x = 0;
       const m = t.getIndex();
       for (let g = 0, c = s.length; g < c; g++) {
-        const p = s[g], x = p.getIndex();
+        const p = s[g], v = p.getIndex();
         if (!(!i && !u && o[g]))
-          for (let y = 0; y < x.count; ++y)
-            m.setX(n + y, x.getX(y) + v);
-        n += x.count, v += p.getAttribute("position").count;
+          for (let y = 0; y < v.count; ++y)
+            m.setX(n + y, v.getX(y) + x);
+        n += v.count, x += p.getAttribute("position").count;
       }
     }
   }
-  const d = Object.keys(s[0].attributes);
-  for (let u = 0, n = d.length; u < n; u++) {
-    let v = !1;
-    const m = d[u];
+  const f = Object.keys(s[0].attributes);
+  for (let u = 0, n = f.length; u < n; u++) {
+    let x = !1;
+    const m = f[u];
     if (!t.getAttribute(m)) {
       const p = s[0].getAttribute(m);
-      t.setAttribute(m, te(p, f)), v = !0;
+      t.setAttribute(m, te(p, d)), x = !0;
     }
     let g = 0;
     const c = t.getAttribute(m);
-    for (let p = 0, x = s.length; p < x; p++) {
-      const b = s[p], y = !i && !v && o[p], w = b.getAttribute(m);
+    for (let p = 0, v = s.length; p < v; p++) {
+      const b = s[p], y = !i && !x && o[p], w = b.getAttribute(m);
       y || bt(w, c, g), g += w.count;
     }
   }
 }
-function vr(s, e, t) {
+function xr(s, e, t) {
   const r = s.index, o = s.attributes.position.count, a = r ? r.count : o;
   let l = s.groups;
   l.length === 0 && (l = [{ count: a, start: 0, materialIndex: 0 }]);
   let h = s.getAttribute("materialIndex");
   if (!h || h.count !== o) {
-    let d;
-    t.length <= 255 ? d = new Uint8Array(o) : d = new Uint16Array(o), h = new P(d, 1, !1), s.deleteAttribute("materialIndex"), s.setAttribute("materialIndex", h);
+    let f;
+    t.length <= 255 ? f = new Uint8Array(o) : f = new Uint16Array(o), h = new P(f, 1, !1), s.deleteAttribute("materialIndex"), s.setAttribute("materialIndex", h);
   }
-  const f = h.array;
-  for (let d = 0; d < l.length; d++) {
-    const u = l[d], n = u.start, v = u.count, m = Math.min(v, a - n), g = Array.isArray(e) ? e[u.materialIndex] : e, c = t.indexOf(g);
+  const d = h.array;
+  for (let f = 0; f < l.length; f++) {
+    const u = l[f], n = u.start, x = u.count, m = Math.min(x, a - n), g = Array.isArray(e) ? e[u.materialIndex] : e, c = t.indexOf(g);
     for (let p = 0; p < m; p++) {
-      let x = n + p;
-      r && (x = r.getX(x)), f[x] = c;
+      let v = n + p;
+      r && (v = r.getX(v)), d[v] = c;
     }
   }
 }
-function xr(s, e) {
+function br(s, e) {
   if (!s.index) {
     const t = s.attributes.position.count, r = new Array(t);
     for (let i = 0; i < t; i++)
@@ -655,7 +655,7 @@ function Ge(s) {
   const e = s.skeleton;
   return e ? (e.boneTexture || e.computeBoneTexture(), `${Ce(e.boneTexture.image.data.buffer)}_${e.boneTexture.uuid}`) : null;
 }
-class br {
+class yr {
   constructor(e = null) {
     this.matrixWorld = new O(), this.geometryHash = null, this.skeletonHash = null, this.primitiveCount = -1, e !== null && this.updateFrom(e);
   }
@@ -675,8 +675,8 @@ function Xe(s, e, t) {
   for (let l = 0; l < 4; l++) {
     const h = je.getComponent(l);
     if (h !== 0) {
-      const f = $e.getComponent(l);
-      Ye.multiplyMatrices(o[f].matrixWorld, a[f]), yr(ce, Ye, h);
+      const d = $e.getComponent(l);
+      Ye.multiplyMatrices(o[d].matrixWorld, a[d]), Tr(ce, Ye, h);
     }
   }
   return ce.multiply(s.bindMatrix).premultiply(s.bindMatrixInverse), t.transformDirection(ce), t;
@@ -689,12 +689,12 @@ function Ie(s, e, t, r, i) {
   }
   i.add(le);
 }
-function yr(s, e, t) {
+function Tr(s, e, t) {
   const r = s.elements, i = e.elements;
   for (let o = 0, a = i.length; o < a; o++)
     r[o] += i[o] * t;
 }
-function Tr(s) {
+function wr(s) {
   const { index: e, attributes: t } = s;
   if (e)
     for (let r = 0, i = e.count; r < i; r += 3) {
@@ -706,35 +706,35 @@ function Tr(s) {
       const i = t[r], o = i.itemSize;
       for (let a = 0, l = i.count; a < l; a += 3)
         for (let h = 0; h < o; h++) {
-          const f = i.getComponent(a, h), d = i.getComponent(a + 2, h);
-          i.setComponent(a, h, d), i.setComponent(a + 2, h, f);
+          const d = i.getComponent(a, h), f = i.getComponent(a + 2, h);
+          i.setComponent(a, h, f), i.setComponent(a + 2, h, d);
         }
     }
   return s;
 }
-function wr(s, e = {}, t = new $()) {
+function Ir(s, e = {}, t = new $()) {
   e = {
     applyWorldTransforms: !0,
     attributes: [],
     ...e
   };
   const r = s.geometry, i = e.applyWorldTransforms, o = e.attributes.includes("normal"), a = e.attributes.includes("tangent"), l = r.attributes, h = t.attributes;
-  for (const x in t.attributes)
-    (!e.attributes.includes(x) || !(x in r.attributes)) && t.deleteAttribute(x);
+  for (const v in t.attributes)
+    (!e.attributes.includes(v) || !(v in r.attributes)) && t.deleteAttribute(v);
   !t.index && r.index && (t.index = r.index.clone()), h.position || t.setAttribute("position", te(l.position)), o && !h.normal && l.normal && t.setAttribute("normal", te(l.normal)), a && !h.tangent && l.tangent && t.setAttribute("tangent", te(l.tangent)), Z(r.index, t.index), Z(l.position, h.position), o && Z(l.normal, h.normal), a && Z(l.tangent, h.tangent);
-  const f = l.position, d = o ? l.normal : null, u = a ? l.tangent : null, n = r.morphAttributes.position, v = r.morphAttributes.normal, m = r.morphAttributes.tangent, g = r.morphTargetsRelative, c = s.morphTargetInfluences, p = new Ct();
+  const d = l.position, f = o ? l.normal : null, u = a ? l.tangent : null, n = r.morphAttributes.position, x = r.morphAttributes.normal, m = r.morphAttributes.tangent, g = r.morphTargetsRelative, c = s.morphTargetInfluences, p = new Ct();
   p.getNormalMatrix(s.matrixWorld), r.index && t.index.array.set(r.index.array);
-  for (let x = 0, b = l.position.count; x < b; x++)
-    U.fromBufferAttribute(f, x), d && V.fromBufferAttribute(d, x), u && (qe.fromBufferAttribute(u, x), G.fromBufferAttribute(u, x)), c && (n && Ie(n, c, g, x, U), v && Ie(v, c, g, x, V), m && Ie(m, c, g, x, G)), s.isSkinnedMesh && (s.applyBoneTransform(x, U), d && Xe(s, x, V), u && Xe(s, x, G)), i && U.applyMatrix4(s.matrixWorld), h.position.setXYZ(x, U.x, U.y, U.z), d && (i && V.applyNormalMatrix(p), h.normal.setXYZ(x, V.x, V.y, V.z)), u && (i && G.transformDirection(s.matrixWorld), h.tangent.setXYZW(x, G.x, G.y, G.z, qe.w));
-  for (const x in e.attributes) {
-    const b = e.attributes[x];
+  for (let v = 0, b = l.position.count; v < b; v++)
+    U.fromBufferAttribute(d, v), f && V.fromBufferAttribute(f, v), u && (qe.fromBufferAttribute(u, v), G.fromBufferAttribute(u, v)), c && (n && Ie(n, c, g, v, U), x && Ie(x, c, g, v, V), m && Ie(m, c, g, v, G)), s.isSkinnedMesh && (s.applyBoneTransform(v, U), f && Xe(s, v, V), u && Xe(s, v, G)), i && U.applyMatrix4(s.matrixWorld), h.position.setXYZ(v, U.x, U.y, U.z), f && (i && V.applyNormalMatrix(p), h.normal.setXYZ(v, V.x, V.y, V.z)), u && (i && G.transformDirection(s.matrixWorld), h.tangent.setXYZW(v, G.x, G.y, G.z, qe.w));
+  for (const v in e.attributes) {
+    const b = e.attributes[v];
     b === "position" || b === "tangent" || b === "normal" || !(b in l) || (h[b] || t.setAttribute(b, te(l[b])), Z(l[b], h[b]), bt(l[b], h[b]));
   }
-  return s.matrixWorld.determinant() < 0 && Tr(t), t;
+  return s.matrixWorld.determinant() < 0 && wr(t), t;
 }
-class Ir extends $ {
+class Rr extends $ {
   constructor() {
-    super(), this.version = 0, this.hash = null, this._diff = new br();
+    super(), this.version = 0, this.hash = null, this._diff = new yr();
   }
   // returns whether the passed mesh is compatible with this baked geometry
   // such that it can be updated without resizing attributes
@@ -749,17 +749,17 @@ class Ir extends $ {
   }
   updateFrom(e, t) {
     const r = this._diff;
-    return r.didChange(e) ? (wr(e, t, this), r.updateFrom(e), this.version++, this.hash = `${this.uuid}_${this.version}`, !0) : !1;
+    return r.didChange(e) ? (Ir(e, t, this), r.updateFrom(e), this.version++, this.hash = `${this.uuid}_${this.version}`, !0) : !1;
   }
 }
 const Ae = 0, yt = 1, Tt = 2;
-function Rr(s, e) {
+function Sr(s, e) {
   for (let t = 0, r = s.length; t < r; t++)
     s[t].traverseVisible((o) => {
       o.isMesh && e(o);
     });
 }
-function Sr(s) {
+function _r(s) {
   const e = [];
   for (let t = 0, r = s.length; t < r; t++) {
     const i = s[t];
@@ -767,7 +767,7 @@ function Sr(s) {
   }
   return e;
 }
-function _r(s, e, t) {
+function Mr(s, e, t) {
   if (s.length === 0) {
     e.setIndex(null);
     const r = e.attributes;
@@ -776,11 +776,11 @@ function _r(s, e, t) {
     for (const i in t.attributes)
       e.setAttribute(t.attributes[i], new P(new Float32Array(0), 4, !1));
   } else
-    gr(s, t, e);
+    vr(s, t, e);
   for (const r in e.attributes)
     e.attributes[r].needsUpdate = !0;
 }
-class Mr {
+class Ar {
   constructor(e) {
     this.objects = null, this.useGroups = !0, this.applyWorldTransforms = !0, this.generateMissingAttributes = !0, this.overwriteIndex = !0, this.attributes = ["position", "normal", "color", "tangent", "uv", "uv2"], this._intermediateGeometry = /* @__PURE__ */ new Map(), this._geometryMergeSets = /* @__PURE__ */ new WeakMap(), this._mergeOrder = [], this._dummyMesh = null, this.setObjects(e || []);
   }
@@ -793,7 +793,7 @@ class Mr {
   }
   _getMeshes() {
     const e = [];
-    return Rr(this.objects, (t) => {
+    return Sr(this.objects, (t) => {
       e.push(t);
     }), e.sort((t, r) => t.uuid > r.uuid ? 1 : t.uuid < r.uuid ? -1 : 0), e.length === 0 && e.push(this._getDummyMesh()), e;
   }
@@ -805,8 +805,8 @@ class Mr {
     for (let o = 0, a = t.length; o < a; o++) {
       const l = t[o], h = l.uuid;
       r.delete(h);
-      let f = e.get(h);
-      (!f || !f.isCompatible(l, this.attributes)) && (f && f.dispose(), f = new Ir(), e.set(h, f)), f.updateFrom(l, i) && this.generateMissingAttributes && xr(f, this.attributes);
+      let d = e.get(h);
+      (!d || !d.isCompatible(l, this.attributes)) && (d && d.dispose(), d = new Rr(), e.set(h, d)), d.updateFrom(l, i) && this.generateMissingAttributes && br(d, this.attributes);
     }
     r.forEach((o) => {
       e.delete(o);
@@ -816,29 +816,29 @@ class Mr {
     Array.isArray(e) ? this.objects = [...e] : this.objects = [e];
   }
   generate(e = new $()) {
-    const { useGroups: t, overwriteIndex: r, _intermediateGeometry: i, _geometryMergeSets: o } = this, a = this._getMeshes(), l = [], h = [], f = o.get(e) || [];
+    const { useGroups: t, overwriteIndex: r, _intermediateGeometry: i, _geometryMergeSets: o } = this, a = this._getMeshes(), l = [], h = [], d = o.get(e) || [];
     this._updateIntermediateGeometries();
-    let d = !1;
-    a.length !== f.length && (d = !0);
-    for (let n = 0, v = a.length; n < v; n++) {
+    let f = !1;
+    a.length !== d.length && (f = !0);
+    for (let n = 0, x = a.length; n < x; n++) {
       const m = a[n], g = i.get(m.uuid);
       h.push(g);
-      const c = f[n];
-      !c || c.uuid !== g.uuid ? (l.push(!1), d = !0) : c.version !== g.version ? l.push(!1) : l.push(!0);
+      const c = d[n];
+      !c || c.uuid !== g.uuid ? (l.push(!1), f = !0) : c.version !== g.version ? l.push(!1) : l.push(!0);
     }
-    _r(h, e, { useGroups: t, forceUpdate: d, skipAssigningAttributes: l, overwriteIndex: r }), d && e.dispose(), o.set(e, h.map((n) => ({
+    Mr(h, e, { useGroups: t, forceUpdate: f, skipAssigningAttributes: l, overwriteIndex: r }), f && e.dispose(), o.set(e, h.map((n) => ({
       version: n.version,
       uuid: n.uuid
     })));
     let u = Ae;
-    return d ? u = Tt : l.includes(!1) && (u = yt), {
+    return f ? u = Tt : l.includes(!1) && (u = yt), {
       changeType: u,
-      materials: Sr(a),
+      materials: _r(a),
       geometry: e
     };
   }
 }
-function Ar(s) {
+function Fr(s) {
   const e = /* @__PURE__ */ new Set();
   for (let t = 0, r = s.length; t < r; t++) {
     const i = s[t];
@@ -849,7 +849,7 @@ function Ar(s) {
   }
   return Array.from(e);
 }
-function Fr(s) {
+function Cr(s) {
   const e = [], t = /* @__PURE__ */ new Set();
   for (let i = 0, o = s.length; i < o; i++)
     s[i].traverse((a) => {
@@ -858,12 +858,12 @@ function Fr(s) {
   const r = Array.from(t).sort((i, o) => i.uuid < o.uuid ? 1 : i.uuid > o.uuid ? -1 : 0);
   return { lights: e, iesTextures: r };
 }
-class Cr {
+class Dr {
   get initialized() {
     return !!this.bvh;
   }
   constructor(e) {
-    this.bvhOptions = {}, this.attributes = ["position", "normal", "tangent", "color", "uv", "uv2"], this.generateBVH = !0, this.bvh = null, this.geometry = new $(), this.staticGeometryGenerator = new Mr(e), this._bvhWorker = null, this._pendingGenerate = null, this._buildAsync = !1;
+    this.bvhOptions = {}, this.attributes = ["position", "normal", "tangent", "color", "uv", "uv2"], this.generateBVH = !0, this.bvh = null, this.geometry = new $(), this.staticGeometryGenerator = new Ar(e), this._bvhWorker = null, this._pendingGenerate = null, this._buildAsync = !1;
   }
   setObjects(e) {
     this.staticGeometryGenerator.setObjects(e);
@@ -889,8 +889,8 @@ class Cr {
         n.isSkinnedMesh && n.skeleton && n.skeleton.update();
       });
     });
-    const a = t.generate(r), l = a.materials, h = Ar(l), { lights: f, iesTextures: d } = Fr(o);
-    if (a.changeType !== Ae && vr(r, l, l), this.generateBVH) {
+    const a = t.generate(r), l = a.materials, h = Fr(l), { lights: d, iesTextures: f } = Cr(o);
+    if (a.changeType !== Ae && xr(r, l, l), this.generateBVH) {
       if (this.bvh instanceof Promise)
         throw new Error("PathTracingSceneGenerator: BVH is already building asynchronously.");
       if (a.changeType === Tt) {
@@ -907,8 +907,8 @@ class Cr {
     return {
       bvhChanged: a.changeType !== Ae,
       bvh: this.bvh,
-      lights: f,
-      iesTextures: d,
+      lights: d,
+      iesTextures: f,
       geometry: r,
       materials: l,
       textures: h,
@@ -916,13 +916,13 @@ class Cr {
     };
   }
 }
-const Dr = new Pt(-1, 1, 1, -1, 0, 1);
-class Pr extends $ {
+const Pr = new Pt(-1, 1, 1, -1, 0, 1);
+class Er extends $ {
   constructor() {
-    super(), this.setAttribute("position", new He([-1, 3, 0, -1, -1, 0, 3, -1, 0], 3)), this.setAttribute("uv", new He([0, 2, 0, 0, 2, 0], 2));
+    super(), this.setAttribute("position", new Be([-1, 3, 0, -1, -1, 0, 3, -1, 0], 3)), this.setAttribute("uv", new Be([0, 2, 0, 0, 2, 0], 2));
   }
 }
-const Er = new Pr();
+const kr = new Er();
 class ee {
   /**
    * Constructs a new full screen quad.
@@ -930,7 +930,7 @@ class ee {
    * @param {?Material} material - The material to render te full screen quad with.
    */
   constructor(e) {
-    this._mesh = new ft(Er, e);
+    this._mesh = new ft(kr, e);
   }
   /**
    * Frees the GPU-related resources allocated by this instance. Call this
@@ -945,7 +945,7 @@ class ee {
    * @param {WebGLRenderer} renderer - The renderer.
    */
   render(e) {
-    e.render(this._mesh, Dr);
+    e.render(this._mesh, Pr);
   }
   /**
    * The quad's material.
@@ -987,7 +987,7 @@ class De extends pe {
     return !1;
   }
 }
-class kr extends De {
+class Or extends De {
   constructor(e) {
     super({
       blending: ie,
@@ -1133,7 +1133,7 @@ const wt = (
 	}
 
 `
-), Or = (
+), zr = (
   /* glsl */
   `
 
@@ -1214,7 +1214,7 @@ const wt = (
 	}
 
 `
-), zr = (
+), Nr = (
   /* glsl */
   `
 
@@ -1261,7 +1261,7 @@ const wt = (
 
 `
 );
-class Nr extends De {
+class Hr extends De {
   constructor() {
     super({
       blending: ie,
@@ -1286,7 +1286,7 @@ class Nr extends De {
         `
 
 				${wt}
-				${Or}
+				${zr}
 
 				varying vec2 vUv;
 				uniform vec2 resolution;
@@ -1311,11 +1311,11 @@ class Br {
       generateMipmaps: !1
     }), i = e.getRenderTarget();
     e.setRenderTarget(r);
-    const o = new ee(new Nr());
+    const o = new ee(new Hr());
     return o.material.resolution.set(t, t), o.render(e), e.setRenderTarget(i), o.dispose(), r;
   }
 }
-class Hr extends dt {
+class Wr extends dt {
   set bokehSize(e) {
     this.fStop = this.getFocalLength() / e;
   }
@@ -1329,12 +1329,12 @@ class Hr extends dt {
     return super.copy(e, t), this.fStop = e.fStop, this.apertureBlades = e.apertureBlades, this.apertureRotation = e.apertureRotation, this.focusDistance = e.focusDistance, this.anamorphicRatio = e.anamorphicRatio, this;
   }
 }
-class Wr {
+class Lr {
   constructor() {
     this.bokehSize = 0, this.apertureBlades = 0, this.apertureRotation = 0, this.focusDistance = 10, this.anamorphicRatio = 1;
   }
   updateFrom(e) {
-    e instanceof Hr ? (this.bokehSize = e.bokehSize, this.apertureBlades = e.apertureBlades, this.apertureRotation = e.apertureRotation, this.focusDistance = e.focusDistance, this.anamorphicRatio = e.anamorphicRatio) : (this.bokehSize = 0, this.apertureRotation = 0, this.apertureBlades = 0, this.focusDistance = 10, this.anamorphicRatio = 1);
+    e instanceof Wr ? (this.bokehSize = e.bokehSize, this.apertureBlades = e.apertureBlades, this.apertureRotation = e.apertureRotation, this.focusDistance = e.focusDistance, this.anamorphicRatio = e.anamorphicRatio) : (this.bokehSize = 0, this.apertureRotation = 0, this.apertureBlades = 0, this.focusDistance = 10, this.anamorphicRatio = 1);
   }
 }
 function Re(s) {
@@ -1351,10 +1351,10 @@ function Qe(s, e, t = 0, r = s.length) {
   }
   return i - t;
 }
-function Lr(s, e, t) {
+function Ur(s, e, t) {
   return 0.2126 * s + 0.7152 * e + 0.0722 * t;
 }
-function Ur(s, e = D) {
+function Vr(s, e = D) {
   const t = s.clone();
   t.source = new Et({ ...t.image });
   const { width: r, height: i, data: o } = t.image;
@@ -1363,9 +1363,9 @@ function Ur(s, e = D) {
     e === D ? a = new Uint16Array(o.length) : a = new Float32Array(o.length);
     let l;
     o instanceof Int8Array || o instanceof Int16Array || o instanceof Int32Array ? l = 2 ** (8 * o.BYTES_PER_ELEMENT - 1) - 1 : l = 2 ** (8 * o.BYTES_PER_ELEMENT) - 1;
-    for (let h = 0, f = o.length; h < f; h++) {
-      let d = o[h];
-      t.type === D && (d = k.fromHalfFloat(o[h])), t.type !== R && t.type !== D && (d /= l), e === D && (a[h] = k.toHalfFloat(d));
+    for (let h = 0, d = o.length; h < d; h++) {
+      let f = o[h];
+      t.type === D && (f = k.fromHalfFloat(o[h])), t.type !== R && t.type !== D && (f /= l), e === D && (a[h] = k.toHalfFloat(f));
     }
     t.image.data = a, t.type = e;
   }
@@ -1373,15 +1373,15 @@ function Ur(s, e = D) {
     const l = a;
     a = a.slice();
     for (let h = 0; h < i; h++)
-      for (let f = 0; f < r; f++) {
-        const d = i - h - 1, u = 4 * (h * r + f), n = 4 * (d * r + f);
+      for (let d = 0; d < r; d++) {
+        const f = i - h - 1, u = 4 * (h * r + d), n = 4 * (f * r + d);
         a[n + 0] = l[u + 0], a[n + 1] = l[u + 1], a[n + 2] = l[u + 2], a[n + 3] = l[u + 3];
       }
     t.flipY = !1, t.image.data = a;
   }
   return t;
 }
-class Vr {
+class Gr {
   constructor() {
     const e = new M(Re(new Float32Array([0, 0, 0, 0])), 1, 1);
     e.type = D, e.format = I, e.minFilter = F, e.magFilter = F, e.wrapS = z, e.wrapT = z, e.generateMipmaps = !1, e.needsUpdate = !0;
@@ -1394,41 +1394,41 @@ class Vr {
     this.marginalWeights.dispose(), this.conditionalWeights.dispose(), this.map.dispose();
   }
   updateFrom(e) {
-    const t = Ur(e);
+    const t = Vr(e);
     t.wrapS = z, t.wrapT = N;
-    const { width: r, height: i, data: o } = t.image, a = new Float32Array(r * i), l = new Float32Array(r * i), h = new Float32Array(i), f = new Float32Array(i);
-    let d = 0, u = 0;
+    const { width: r, height: i, data: o } = t.image, a = new Float32Array(r * i), l = new Float32Array(r * i), h = new Float32Array(i), d = new Float32Array(i);
+    let f = 0, u = 0;
     for (let c = 0; c < i; c++) {
       let p = 0;
-      for (let x = 0; x < r; x++) {
-        const b = c * r + x, y = k.fromHalfFloat(o[4 * b + 0]), w = k.fromHalfFloat(o[4 * b + 1]), E = k.fromHalfFloat(o[4 * b + 2]), B = Lr(y, w, E);
-        p += B, d += B, a[b] = B, l[b] = p;
+      for (let v = 0; v < r; v++) {
+        const b = c * r + v, y = k.fromHalfFloat(o[4 * b + 0]), w = k.fromHalfFloat(o[4 * b + 1]), E = k.fromHalfFloat(o[4 * b + 2]), H = Ur(y, w, E);
+        p += H, f += H, a[b] = H, l[b] = p;
       }
       if (p !== 0)
-        for (let x = c * r, b = c * r + r; x < b; x++)
-          a[x] /= p, l[x] /= p;
-      u += p, h[c] = p, f[c] = u;
+        for (let v = c * r, b = c * r + r; v < b; v++)
+          a[v] /= p, l[v] /= p;
+      u += p, h[c] = p, d[c] = u;
     }
     if (u !== 0)
       for (let c = 0, p = h.length; c < p; c++)
-        h[c] /= u, f[c] /= u;
-    const n = new Uint16Array(i), v = new Uint16Array(r * i);
+        h[c] /= u, d[c] /= u;
+    const n = new Uint16Array(i), x = new Uint16Array(r * i);
     for (let c = 0; c < i; c++) {
-      const p = (c + 1) / i, x = Qe(f, p);
-      n[c] = k.toHalfFloat((x + 0.5) / i);
+      const p = (c + 1) / i, v = Qe(d, p);
+      n[c] = k.toHalfFloat((v + 0.5) / i);
     }
     for (let c = 0; c < i; c++)
       for (let p = 0; p < r; p++) {
-        const x = c * r + p, b = (p + 1) / r, y = Qe(l, b, c * r, r);
-        v[x] = k.toHalfFloat((y + 0.5) / r);
+        const v = c * r + p, b = (p + 1) / r, y = Qe(l, b, c * r, r);
+        x[v] = k.toHalfFloat((y + 0.5) / r);
       }
     this.dispose();
     const { marginalWeights: m, conditionalWeights: g } = this;
-    m.image = { width: i, height: 1, data: n }, m.needsUpdate = !0, g.image = { width: r, height: i, data: v }, g.needsUpdate = !0, this.totalSum = d, this.map = t;
+    m.image = { width: i, height: 1, data: n }, m.needsUpdate = !0, g.image = { width: r, height: i, data: x }, g.needsUpdate = !0, this.totalSum = f, this.map = t;
   }
 }
-const Se = 6, Gr = 0, qr = 1, $r = 2, jr = 3, Yr = 4, A = new C(), _ = new C(), Ke = new O(), Y = new kt(), Ze = new C(), X = new C(), Xr = new C(0, 1, 0);
-class Qr {
+const Se = 6, qr = 0, $r = 1, jr = 2, Yr = 3, Xr = 4, A = new C(), _ = new C(), Ke = new O(), Y = new kt(), Ze = new C(), X = new C(), Qr = new C(0, 1, 0);
+class Kr {
   constructor() {
     const e = new M(new Float32Array(4), 1, 1);
     e.format = I, e.type = R, e.wrapS = N, e.wrapT = N, e.generateMipmaps = !1, e.minFilter = T, e.magFilter = T, this.tex = e, this.count = 0;
@@ -1437,23 +1437,23 @@ class Qr {
     const r = this.tex, i = Math.max(e.length * Se, 1), o = Math.ceil(Math.sqrt(i));
     r.image.width !== o && (r.dispose(), r.image.data = new Float32Array(o * o * 4), r.image.width = o, r.image.height = o);
     const a = r.image.data;
-    for (let h = 0, f = e.length; h < f; h++) {
-      const d = e[h], u = h * Se * 4;
+    for (let h = 0, d = e.length; h < d; h++) {
+      const f = e[h], u = h * Se * 4;
       let n = 0;
       for (let m = 0; m < Se * 4; m++)
         a[u + m] = 0;
-      d.getWorldPosition(_), a[u + n++] = _.x, a[u + n++] = _.y, a[u + n++] = _.z;
-      let v = Gr;
-      if (d.isRectAreaLight && d.isCircular ? v = qr : d.isSpotLight ? v = $r : d.isDirectionalLight ? v = jr : d.isPointLight && (v = Yr), a[u + n++] = v, a[u + n++] = d.color.r, a[u + n++] = d.color.g, a[u + n++] = d.color.b, a[u + n++] = d.intensity, d.getWorldQuaternion(Y), d.isRectAreaLight)
-        A.set(d.width, 0, 0).applyQuaternion(Y), a[u + n++] = A.x, a[u + n++] = A.y, a[u + n++] = A.z, n++, _.set(0, d.height, 0).applyQuaternion(Y), a[u + n++] = _.x, a[u + n++] = _.y, a[u + n++] = _.z, a[u + n++] = A.cross(_).length() * (d.isCircular ? Math.PI / 4 : 1);
-      else if (d.isSpotLight) {
-        const m = d.radius || 0;
-        Ze.setFromMatrixPosition(d.matrixWorld), X.setFromMatrixPosition(d.target.matrixWorld), Ke.lookAt(Ze, X, Xr), Y.setFromRotationMatrix(Ke), A.set(1, 0, 0).applyQuaternion(Y), a[u + n++] = A.x, a[u + n++] = A.y, a[u + n++] = A.z, n++, _.set(0, 1, 0).applyQuaternion(Y), a[u + n++] = _.x, a[u + n++] = _.y, a[u + n++] = _.z, a[u + n++] = Math.PI * m * m, a[u + n++] = m, a[u + n++] = d.decay, a[u + n++] = d.distance, a[u + n++] = Math.cos(d.angle), a[u + n++] = Math.cos(d.angle * (1 - d.penumbra)), a[u + n++] = d.iesMap ? t.indexOf(d.iesMap) : -1;
-      } else if (d.isPointLight) {
-        const m = A.setFromMatrixPosition(d.matrixWorld);
-        a[u + n++] = m.x, a[u + n++] = m.y, a[u + n++] = m.z, n++, n += 4, n += 1, a[u + n++] = d.decay, a[u + n++] = d.distance;
-      } else if (d.isDirectionalLight) {
-        const m = A.setFromMatrixPosition(d.matrixWorld), g = _.setFromMatrixPosition(d.target.matrixWorld);
+      f.getWorldPosition(_), a[u + n++] = _.x, a[u + n++] = _.y, a[u + n++] = _.z;
+      let x = qr;
+      if (f.isRectAreaLight && f.isCircular ? x = $r : f.isSpotLight ? x = jr : f.isDirectionalLight ? x = Yr : f.isPointLight && (x = Xr), a[u + n++] = x, a[u + n++] = f.color.r, a[u + n++] = f.color.g, a[u + n++] = f.color.b, a[u + n++] = f.intensity, f.getWorldQuaternion(Y), f.isRectAreaLight)
+        A.set(f.width, 0, 0).applyQuaternion(Y), a[u + n++] = A.x, a[u + n++] = A.y, a[u + n++] = A.z, n++, _.set(0, f.height, 0).applyQuaternion(Y), a[u + n++] = _.x, a[u + n++] = _.y, a[u + n++] = _.z, a[u + n++] = A.cross(_).length() * (f.isCircular ? Math.PI / 4 : 1);
+      else if (f.isSpotLight) {
+        const m = f.radius || 0;
+        Ze.setFromMatrixPosition(f.matrixWorld), X.setFromMatrixPosition(f.target.matrixWorld), Ke.lookAt(Ze, X, Qr), Y.setFromRotationMatrix(Ke), A.set(1, 0, 0).applyQuaternion(Y), a[u + n++] = A.x, a[u + n++] = A.y, a[u + n++] = A.z, n++, _.set(0, 1, 0).applyQuaternion(Y), a[u + n++] = _.x, a[u + n++] = _.y, a[u + n++] = _.z, a[u + n++] = Math.PI * m * m, a[u + n++] = m, a[u + n++] = f.decay, a[u + n++] = f.distance, a[u + n++] = Math.cos(f.angle), a[u + n++] = Math.cos(f.angle * (1 - f.penumbra)), a[u + n++] = f.iesMap ? t.indexOf(f.iesMap) : -1;
+      } else if (f.isPointLight) {
+        const m = A.setFromMatrixPosition(f.matrixWorld);
+        a[u + n++] = m.x, a[u + n++] = m.y, a[u + n++] = m.z, n++, n += 4, n += 1, a[u + n++] = f.decay, a[u + n++] = f.distance;
+      } else if (f.isDirectionalLight) {
+        const m = A.setFromMatrixPosition(f.matrixWorld), g = _.setFromMatrixPosition(f.target.matrixWorld);
         X.subVectors(m, g).normalize(), a[u + n++] = X.x, a[u + n++] = X.y, a[u + n++] = X.z;
       }
     }
@@ -1480,12 +1480,12 @@ function Je(s, e, t, r, i) {
       break;
   }
   for (let h = 0; h < o; h++) {
-    const f = 4 * h, d = e * h;
+    const d = 4 * h, f = e * h;
     for (let u = 0; u < r; u++)
-      t[i + f + u] = e >= u + 1 ? s[d + u] / l : 0;
+      t[i + d + u] = e >= u + 1 ? s[f + u] / l : 0;
   }
 }
-class Kr extends Ot {
+class Zr extends Ot {
   constructor() {
     super(), this._textures = [], this.type = R, this.format = I, this.internalFormat = "RGBA32F";
   }
@@ -1495,9 +1495,9 @@ class Kr extends Ot {
     const i = r.image, o = this.image;
     if (i.width !== o.width || i.height !== o.height)
       throw new Error("FloatAttributeTextureArray: Attribute must be the same dimensions when updating single layer.");
-    const { width: a, height: l, data: h } = o, d = a * l * 4 * e;
+    const { width: a, height: l, data: h } = o, f = a * l * 4 * e;
     let u = t.itemSize;
-    u === 3 && (u = 4), Je(r.image.data, u, h, 4, d), this.dispose(), this.needsUpdate = !0;
+    u === 3 && (u = 4), Je(r.image.data, u, h, 4, f), this.dispose(), this.needsUpdate = !0;
   }
   setAttributes(e) {
     const t = e[0].count, r = e.length;
@@ -1515,16 +1515,16 @@ class Kr extends Ot {
       i[u].updateFrom(e[u]);
     const a = i[0].image, l = this.image;
     (a.width !== l.width || a.height !== l.height || a.depth !== r) && (l.width = a.width, l.height = a.height, l.depth = r, l.data = new Float32Array(l.width * l.height * l.depth * 4));
-    const { data: h, width: f, height: d } = l;
+    const { data: h, width: d, height: f } = l;
     for (let u = 0, n = r; u < n; u++) {
-      const v = i[u], g = f * d * 4 * u;
+      const x = i[u], g = d * f * 4 * u;
       let c = e[u].itemSize;
-      c === 3 && (c = 4), Je(v.image.data, c, h, 4, g);
+      c === 3 && (c = 4), Je(x.image.data, c, h, 4, g);
     }
     this.dispose(), this.needsUpdate = !0;
   }
 }
-class Zr extends Kr {
+class Jr extends Zr {
   updateNormalAttribute(e) {
     this.updateAttribute(0, e);
   }
@@ -1547,7 +1547,7 @@ function Pe(s, e) {
 function Fe(s) {
   return `${s.source.uuid}:${s.colorSpace}`;
 }
-function Jr(s) {
+function ea(s) {
   const e = /* @__PURE__ */ new Set(), t = [];
   for (let r = 0, i = s.length; r < i; r++) {
     const o = s[r], a = Fe(o);
@@ -1555,11 +1555,11 @@ function Jr(s) {
   }
   return t;
 }
-function ea(s) {
+function ta(s) {
   const e = s.map((r) => r.iesMap || null).filter((r) => r), t = new Set(e);
   return Array.from(t).sort(Pe);
 }
-function ta(s) {
+function ra(s) {
   const e = /* @__PURE__ */ new Set();
   for (let r = 0, i = s.length; r < i; r++) {
     const o = s[r];
@@ -1569,16 +1569,16 @@ function ta(s) {
     }
   }
   const t = Array.from(e);
-  return Jr(t).sort(Pe);
+  return ea(t).sort(Pe);
 }
-function ra(s) {
+function aa(s) {
   const e = [];
   return s.traverse((t) => {
     t.visible && (t.isRectAreaLight || t.isSpotLight || t.isPointLight || t.isDirectionalLight) && e.push(t);
   }), e.sort(Pe);
 }
 const It = 45, et = It * 4;
-class aa {
+class ia {
   constructor() {
     this._features = {};
   }
@@ -1592,9 +1592,9 @@ class aa {
     this._features = {};
   }
 }
-class ia extends M {
+class sa extends M {
   constructor() {
-    super(new Float32Array(4), 1, 1), this.format = I, this.type = R, this.wrapS = N, this.wrapT = N, this.minFilter = T, this.magFilter = T, this.generateMipmaps = !1, this.features = new aa();
+    super(new Float32Array(4), 1, 1), this.format = I, this.type = R, this.wrapS = N, this.wrapT = N, this.minFilter = T, this.magFilter = T, this.generateMipmaps = !1, this.features = new ia();
   }
   updateFrom(e, t) {
     function r(m, g, c = -1) {
@@ -1608,26 +1608,26 @@ class ia extends M {
       return g in m ? m[g] : c;
     }
     function o(m, g, c, p) {
-      const x = m[g] && m[g].isTexture ? m[g] : null;
-      if (x) {
-        x.matrixAutoUpdate && x.updateMatrix();
-        const b = x.matrix.elements;
+      const v = m[g] && m[g].isTexture ? m[g] : null;
+      if (v) {
+        v.matrixAutoUpdate && v.updateMatrix();
+        const b = v.matrix.elements;
         let y = 0;
         c[p + y++] = b[0], c[p + y++] = b[3], c[p + y++] = b[6], y++, c[p + y++] = b[1], c[p + y++] = b[4], c[p + y++] = b[7], y++;
       }
       return 8;
     }
     let a = 0;
-    const l = e.length * It, h = Math.ceil(Math.sqrt(l)) || 1, { image: f, features: d } = this, u = {};
+    const l = e.length * It, h = Math.ceil(Math.sqrt(l)) || 1, { image: d, features: f } = this, u = {};
     for (let m = 0, g = t.length; m < g; m++)
       u[Fe(t[m])] = m;
-    f.width !== h && (this.dispose(), f.data = new Float32Array(h * h * 4), f.width = h, f.height = h);
-    const n = f.data;
-    d.reset();
+    d.width !== h && (this.dispose(), d.data = new Float32Array(h * h * 4), d.width = h, d.height = h);
+    const n = d.data;
+    f.reset();
     for (let m = 0, g = e.length; m < g; m++) {
       const c = e[m];
       if (c.isFogVolumeMaterial) {
-        d.setUsed("FOG");
+        f.setUsed("FOG");
         for (let b = 0; b < et; b++)
           n[a + b] = 0;
         n[a + 0 + 0] = c.color.r, n[a + 0 + 1] = c.color.g, n[a + 0 + 2] = c.color.b, n[a + 8 + 3] = i(c, "emissiveIntensity", 0), n[a + 12 + 0] = c.emissive.r, n[a + 12 + 1] = c.emissive.g, n[a + 12 + 2] = c.emissive.b, n[a + 52 + 1] = c.density, n[a + 52 + 3] = 0, n[a + 56 + 2] = 4, a += et;
@@ -1636,12 +1636,12 @@ class ia extends M {
       n[a++] = c.color.r, n[a++] = c.color.g, n[a++] = c.color.b, n[a++] = r(c, "map"), n[a++] = i(c, "metalness", 0), n[a++] = r(c, "metalnessMap"), n[a++] = i(c, "roughness", 0), n[a++] = r(c, "roughnessMap"), n[a++] = i(c, "ior", 1.5), n[a++] = i(c, "transmission", 0), n[a++] = r(c, "transmissionMap"), n[a++] = i(c, "emissiveIntensity", 0), "emissive" in c ? (n[a++] = c.emissive.r, n[a++] = c.emissive.g, n[a++] = c.emissive.b) : (n[a++] = 0, n[a++] = 0, n[a++] = 0), n[a++] = r(c, "emissiveMap"), n[a++] = r(c, "normalMap"), "normalScale" in c ? (n[a++] = c.normalScale.x, n[a++] = c.normalScale.y) : (n[a++] = 1, n[a++] = 1), n[a++] = i(c, "clearcoat", 0), n[a++] = r(c, "clearcoatMap"), n[a++] = i(c, "clearcoatRoughness", 0), n[a++] = r(c, "clearcoatRoughnessMap"), n[a++] = r(c, "clearcoatNormalMap"), "clearcoatNormalScale" in c ? (n[a++] = c.clearcoatNormalScale.x, n[a++] = c.clearcoatNormalScale.y) : (n[a++] = 1, n[a++] = 1), a++, n[a++] = i(c, "sheen", 0), "sheenColor" in c ? (n[a++] = c.sheenColor.r, n[a++] = c.sheenColor.g, n[a++] = c.sheenColor.b) : (n[a++] = 0, n[a++] = 0, n[a++] = 0), n[a++] = r(c, "sheenColorMap"), n[a++] = i(c, "sheenRoughness", 0), n[a++] = r(c, "sheenRoughnessMap"), n[a++] = r(c, "iridescenceMap"), n[a++] = r(c, "iridescenceThicknessMap"), n[a++] = i(c, "iridescence", 0), n[a++] = i(c, "iridescenceIOR", 1.3);
       const p = i(c, "iridescenceThicknessRange", [100, 400]);
       n[a++] = p[0], n[a++] = p[1], "specularColor" in c ? (n[a++] = c.specularColor.r, n[a++] = c.specularColor.g, n[a++] = c.specularColor.b) : (n[a++] = 1, n[a++] = 1, n[a++] = 1), n[a++] = r(c, "specularColorMap"), n[a++] = i(c, "specularIntensity", 1), n[a++] = r(c, "specularIntensityMap");
-      const x = i(c, "thickness", 0) === 0 && i(c, "attenuationDistance", 1 / 0) === 1 / 0;
-      if (n[a++] = Number(x), a++, "attenuationColor" in c ? (n[a++] = c.attenuationColor.r, n[a++] = c.attenuationColor.g, n[a++] = c.attenuationColor.b) : (n[a++] = 1, n[a++] = 1, n[a++] = 1), n[a++] = i(c, "attenuationDistance", 1 / 0), n[a++] = r(c, "alphaMap"), n[a++] = c.opacity, n[a++] = c.alphaTest, !x && c.transmission > 0)
+      const v = i(c, "thickness", 0) === 0 && i(c, "attenuationDistance", 1 / 0) === 1 / 0;
+      if (n[a++] = Number(v), a++, "attenuationColor" in c ? (n[a++] = c.attenuationColor.r, n[a++] = c.attenuationColor.g, n[a++] = c.attenuationColor.b) : (n[a++] = 1, n[a++] = 1, n[a++] = 1), n[a++] = i(c, "attenuationDistance", 1 / 0), n[a++] = r(c, "alphaMap"), n[a++] = c.opacity, n[a++] = c.alphaTest, !v && c.transmission > 0)
         n[a++] = 0;
       else
         switch (c.side) {
-          case Bt:
+          case Ht:
             n[a++] = 1;
             break;
           case Nt:
@@ -1653,19 +1653,19 @@ class ia extends M {
         }
       n[a++] = Number(i(c, "matte", !1)), n[a++] = Number(i(c, "castShadow", !0)), n[a++] = Number(c.vertexColors) | Number(c.flatShading) << 1, n[a++] = Number(c.transparent), a += o(c, "map", n, a), a += o(c, "metalnessMap", n, a), a += o(c, "roughnessMap", n, a), a += o(c, "transmissionMap", n, a), a += o(c, "emissiveMap", n, a), a += o(c, "normalMap", n, a), a += o(c, "clearcoatMap", n, a), a += o(c, "clearcoatNormalMap", n, a), a += o(c, "clearcoatRoughnessMap", n, a), a += o(c, "sheenColorMap", n, a), a += o(c, "sheenRoughnessMap", n, a), a += o(c, "iridescenceMap", n, a), a += o(c, "iridescenceThicknessMap", n, a), a += o(c, "specularColorMap", n, a), a += o(c, "specularIntensityMap", n, a);
     }
-    const v = Ce(n.buffer);
-    return this.hash !== v ? (this.hash = v, this.needsUpdate = !0, !0) : !1;
+    const x = Ce(n.buffer);
+    return this.hash !== x ? (this.hash = x, this.needsUpdate = !0, !0) : !1;
   }
 }
 const tt = new se();
-function sa(s) {
+function oa(s) {
   return s ? `${s.uuid}:${s.version}` : null;
 }
-function oa(s, e) {
+function na(s, e) {
   for (const t in e)
     t in s && (s[t] = e[t]);
 }
-class rt extends Ht {
+class rt extends Bt {
   constructor(e, t, r) {
     const i = {
       format: I,
@@ -1677,10 +1677,10 @@ class rt extends Ht {
       generateMipmaps: !1,
       ...r
     };
-    super(e, t, 1, i), oa(this.texture, i), this.texture.setTextures = (...a) => {
+    super(e, t, 1, i), na(this.texture, i), this.texture.setTextures = (...a) => {
       this.setTextures(...a);
     }, this.hashes = [null];
-    const o = new ee(new na());
+    const o = new ee(new la());
     this.fsQuad = o;
   }
   setTextures(e, t, r = this.width, i = this.height) {
@@ -1688,19 +1688,19 @@ class rt extends Ht {
     e.getClearColor(tt);
     const h = t.length || 1;
     (r !== this.width || i !== this.height || this.depth !== h) && (this.setSize(r, i, h), this.hashes = new Array(h).fill(null)), e.setClearColor(0, 0), e.toneMapping = Wt;
-    const f = this.fsQuad, d = this.hashes;
+    const d = this.fsQuad, f = this.hashes;
     let u = !1;
-    for (let n = 0, v = h; n < v; n++) {
-      const m = t[n], g = sa(m);
-      m && (d[n] !== g || m.isWebGLRenderTarget) && (m.matrixAutoUpdate = !1, m.matrix.identity(), f.material.map = m, e.setRenderTarget(this, n), f.render(e), m.updateMatrix(), m.matrixAutoUpdate = !0, d[n] = g, u = !0);
+    for (let n = 0, x = h; n < x; n++) {
+      const m = t[n], g = oa(m);
+      m && (f[n] !== g || m.isWebGLRenderTarget) && (m.matrixAutoUpdate = !1, m.matrix.identity(), d.material.map = m, e.setRenderTarget(this, n), d.render(e), m.updateMatrix(), m.matrixAutoUpdate = !0, f[n] = g, u = !0);
     }
-    return f.material.map = null, e.setClearColor(tt, l), e.setRenderTarget(o), e.toneMapping = a, u;
+    return d.material.map = null, e.setClearColor(tt, l), e.setRenderTarget(o), e.toneMapping = a, u;
   }
   dispose() {
     super.dispose(), this.fsQuad.dispose();
   }
 }
-class na extends pe {
+class la extends pe {
   get map() {
     return this.uniforms.map.value;
   }
@@ -1739,14 +1739,14 @@ class na extends pe {
     });
   }
 }
-function la(s, e = Math.random()) {
+function ca(s, e = Math.random()) {
   for (let t = s.length - 1; t > 0; t--) {
     const r = Math.floor(e() * (t + 1)), i = s[t];
     s[t] = s[r], s[r] = i;
   }
   return s;
 }
-class ca {
+class ua {
   constructor(e, t, r = Math.random) {
     const i = e ** t, o = new Uint16Array(i);
     let a = i;
@@ -1760,15 +1760,15 @@ class ca {
       a = 0;
     }, this.next = function() {
       const { samples: l } = this;
-      a >= o.length && (la(o, r), this.reshuffle());
+      a >= o.length && (ca(o, r), this.reshuffle());
       let h = o[a++];
-      for (let f = 0; f < t; f++)
-        l[f] = (h % e + r()) / e, h = Math.floor(h / e);
+      for (let d = 0; d < t; d++)
+        l[d] = (h % e + r()) / e, h = Math.floor(h / e);
       return l;
     };
   }
 }
-class ua {
+class ha {
   constructor(e, t, r = Math.random) {
     let i = 0;
     for (const h of t)
@@ -1776,8 +1776,8 @@ class ua {
     const o = new Float32Array(i), a = [];
     let l = 0;
     for (const h of t) {
-      const f = new ca(e, h, r);
-      f.samples = new Float32Array(o.buffer, l, f.samples.length), l += f.samples.length * 4, a.push(f);
+      const d = new ua(e, h, r);
+      d.samples = new Float32Array(o.buffer, l, d.samples.length), l += d.samples.length * 4, a.push(d);
     }
     this.samples = o, this.strataCount = e, this.next = function() {
       for (const h of a)
@@ -1792,7 +1792,7 @@ class ua {
     };
   }
 }
-class ha {
+class fa {
   constructor(e = 0) {
     this.m = 2147483648, this.a = 1103515245, this.c = 12345, this.seed = e;
   }
@@ -1803,15 +1803,15 @@ class ha {
     return this.nextInt() / (this.m - 1);
   }
 }
-class fa extends M {
+class da extends M {
   constructor(e = 1, t = 1, r = 8) {
-    super(new Float32Array(1), 1, 1, I, R), this.minFilter = T, this.magFilter = T, this.strata = r, this.sampler = null, this.generator = new ha(), this.stableNoise = !1, this.random = () => this.stableNoise ? this.generator.nextFloat() : Math.random(), this.init(e, t, r);
+    super(new Float32Array(1), 1, 1, I, R), this.minFilter = T, this.magFilter = T, this.strata = r, this.sampler = null, this.generator = new fa(), this.stableNoise = !1, this.random = () => this.stableNoise ? this.generator.nextFloat() : Math.random(), this.init(e, t, r);
   }
   init(e = this.image.height, t = this.image.width, r = this.strata) {
     const { image: i } = this;
     if (i.width === t && i.height === e && this.sampler !== null)
       return;
-    const o = new Array(e * t).fill(4), a = new ua(r, o, this.random);
+    const o = new Array(e * t).fill(4), a = new ha(r, o, this.random);
     i.width = t, i.height = e, i.data = a.samples, this.sampler = a, this.dispose(), this.next();
   }
   next() {
@@ -1821,13 +1821,13 @@ class fa extends M {
     this.sampler.reset(), this.generator.seed = 0;
   }
 }
-function da(s, e = Math.random) {
+function ma(s, e = Math.random) {
   for (let t = s.length - 1; t > 0; t--) {
     const r = ~~((e() - 1e-6) * t), i = s[t];
     s[t] = s[r], s[r] = i;
   }
 }
-function ma(s, e) {
+function pa(s, e) {
   s.fill(0);
   for (let t = 0; t < e; t++)
     s[t] = 1;
@@ -1864,8 +1864,8 @@ class at {
     const t = ~~(Math.sqrt(20 * e ** 2) + 1), r = 2 * t + 1, i = new Float32Array(r * r), o = e * e;
     for (let a = -t; a <= t; a++)
       for (let l = -t; l <= t; l++) {
-        const h = (t + l) * r + a + t, f = a * a + l * l;
-        i[h] = Math.E ** (-f / (2 * o));
+        const h = (t + l) * r + a + t, d = a * a + l * l;
+        i[h] = Math.E ** (-d / (2 * o));
       }
     this.lookupTable = i, this.sigma = e, this.radius = t;
   }
@@ -1884,14 +1884,14 @@ class at {
   }
   updateScore(e, t, r) {
     const { size: i, score: o, lookupTable: a } = this, l = this.radius, h = 2 * l + 1;
-    for (let f = -l; f <= l; f++)
-      for (let d = -l; d <= l; d++) {
-        const u = (l + d) * h + f + l, n = a[u];
-        let v = e + f;
-        v = v < 0 ? i + v : v % i;
-        let m = t + d;
+    for (let d = -l; d <= l; d++)
+      for (let f = -l; f <= l; f++) {
+        const u = (l + f) * h + d + l, n = a[u];
+        let x = e + d;
+        x = x < 0 ? i + x : x % i;
+        let m = t + f;
         m = m < 0 ? i + m : m % i;
-        const g = m * i + v;
+        const g = m * i + x;
         o[g] += r * n;
       }
   }
@@ -1909,7 +1909,7 @@ class at {
     this.resize(e.size), this.score.set(e.score), this.binaryPattern.set(e.binaryPattern), this.setSigma(e.sigma), this.count = e.count;
   }
 }
-class pa {
+class ga {
   constructor() {
     this.random = Math.random, this.sigma = 1.5, this.size = 64, this.majorityPointsRatio = 0.1, this.samples = new at(1), this.savedSamples = new at(1);
   }
@@ -1923,7 +1923,7 @@ class pa {
     } = this;
     e.resize(o), e.setSigma(r);
     const a = Math.floor(o * o * i), l = e.binaryPattern;
-    ma(l, a), da(l, this.random);
+    pa(l, a), ma(l, this.random);
     for (let u = 0, n = l.length; u < n; u++)
       l[u] === 1 && e.addPointIndex(u);
     for (; ; ) {
@@ -1938,27 +1938,27 @@ class pa {
     }
     const h = new Uint32Array(o * o);
     t.copy(e);
-    let f;
-    for (f = e.count - 1; f >= 0; ) {
+    let d;
+    for (d = e.count - 1; d >= 0; ) {
       const u = e.findCluster();
-      e.removePointIndex(u), h[u] = f, f--;
+      e.removePointIndex(u), h[u] = d, d--;
     }
-    const d = o * o;
-    for (f = t.count; f < d / 2; ) {
+    const f = o * o;
+    for (d = t.count; d < f / 2; ) {
       const u = t.findVoid();
-      t.addPointIndex(u), h[u] = f, f++;
+      t.addPointIndex(u), h[u] = d, d++;
     }
-    for (t.invert(); f < d; ) {
+    for (t.invert(); d < f; ) {
       const u = t.findCluster();
-      t.removePointIndex(u), h[u] = f, f++;
+      t.removePointIndex(u), h[u] = d, d++;
     }
-    return { data: h, maxValue: d };
+    return { data: h, maxValue: f };
   }
 }
-function ga(s) {
+function va(s) {
   return s >= 3 ? 4 : s;
 }
-function va(s) {
+function xa(s) {
   switch (s) {
     case 1:
       return me;
@@ -1968,27 +1968,27 @@ function va(s) {
       return I;
   }
 }
-class xa extends M {
+class ba extends M {
   constructor(e = 64, t = 1) {
     super(new Float32Array(4), 1, 1, I, R), this.minFilter = T, this.magFilter = T, this.size = e, this.channels = t, this.update();
   }
   update() {
-    const e = this.channels, t = this.size, r = new pa();
+    const e = this.channels, t = this.size, r = new ga();
     r.channels = e, r.size = t;
-    const i = ga(e), o = va(i);
+    const i = va(e), o = xa(i);
     (this.image.width !== t || o !== this.format) && (this.image.width = t, this.image.height = t, this.image.data = new Float32Array(t ** 2 * i), this.format = o, this.dispose());
     const a = this.image.data;
     for (let l = 0, h = e; l < h; l++) {
-      const f = r.generate(), d = f.data, u = f.maxValue;
-      for (let n = 0, v = d.length; n < v; n++) {
-        const m = d[n] / u;
+      const d = r.generate(), f = d.data, u = d.maxValue;
+      for (let n = 0, x = f.length; n < x; n++) {
+        const m = f[n] / u;
         a[n * i + l] = m;
       }
     }
     this.needsUpdate = !0;
   }
 }
-const ba = (
+const ya = (
   /* glsl */
   `
 
@@ -2003,7 +2003,7 @@ const ba = (
 	};
 
 `
-), ya = (
+), Ta = (
   /* glsl */
   `
 
@@ -2018,7 +2018,7 @@ const ba = (
 	};
 
 `
-), Ta = (
+), wa = (
   /* glsl */
   `
 
@@ -2107,7 +2107,7 @@ const ba = (
 	}
 
 `
-), wa = (
+), Ia = (
   /* glsl */
   `
 
@@ -2317,7 +2317,7 @@ const ba = (
 	}
 
 `
-), Ia = (
+), Ra = (
   /* glsl */
   `
 
@@ -2382,7 +2382,7 @@ const ba = (
 	};
 
 `
-), Ra = (
+), Sa = (
   /* glsl */
   `
 
@@ -2452,7 +2452,7 @@ const ba = (
 
 	}
 `
-), Sa = (
+), _a = (
   /* glsl */
   `
 
@@ -2670,7 +2670,7 @@ const ba = (
 	}
 
 `
-), _a = (
+), Ma = (
   /* glsl */
   `
 
@@ -2758,7 +2758,7 @@ const ba = (
 
 
 `
-), Ma = (
+), Aa = (
   /* glsl */
   `
 
@@ -2864,7 +2864,7 @@ const ba = (
 	}
 
 `
-), Aa = (
+), Fa = (
   /* glsl */
   `
 
@@ -2947,7 +2947,7 @@ const ba = (
 	}
 
 `
-), Fa = (
+), Ca = (
   /* glsl */
   `
 
@@ -3011,7 +3011,7 @@ const ba = (
 	}
 
 `
-), Ca = (
+), Da = (
   /*glsl */
   `
 
@@ -3214,7 +3214,7 @@ const ba = (
 
 	}
 `
-), Da = (
+), Pa = (
   /* glsl */
   `
 
@@ -3266,7 +3266,7 @@ const ba = (
 	}
 
 `
-), Pa = (
+), Ea = (
   /* glsl */
   `
 
@@ -3707,7 +3707,7 @@ const ba = (
 	}
 
 `
-), Ea = (
+), ka = (
   /* glsl */
   `
 
@@ -3731,7 +3731,7 @@ const ba = (
 	}
 
 `
-), ka = (
+), Oa = (
   /* glsl */
   `
 
@@ -3835,7 +3835,7 @@ const ba = (
 	}
 
 `
-), Oa = (
+), za = (
   /* glsl */
   `
 
@@ -3972,7 +3972,7 @@ const ba = (
 	}
 
 `
-), za = (
+), Na = (
   /* glsl */
   `
 
@@ -4072,7 +4072,7 @@ const ba = (
 	}
 
 `
-), Na = (
+), Ha = (
   /* glsl */
   `
 
@@ -4316,7 +4316,7 @@ bool bvhIntersectFogVolumeHit(
 	}
 
 `
-), Ha = (
+), Wa = (
   /* glsl */
   `
 
@@ -4402,7 +4402,7 @@ bool bvhIntersectFogVolumeHit(
 	}
 
 `
-), Wa = (
+), La = (
   /*glsl*/
   `
 
@@ -4501,7 +4501,7 @@ bool bvhIntersectFogVolumeHit(
 	}
 
 `
-), La = (
+), Ua = (
   /* glsl */
   `
 
@@ -4826,7 +4826,7 @@ bool bvhIntersectFogVolumeHit(
 
 	}
 `
-), Ua = (
+), Va = (
   /* glsl */
   `
 
@@ -4878,7 +4878,7 @@ bool bvhIntersectFogVolumeHit(
 	}
 
 `
-), Va = (
+), Ga = (
   /* glsl */
   `
 
@@ -4929,7 +4929,7 @@ bool bvhIntersectFogVolumeHit(
 
 `
 );
-class Ga extends De {
+class qa extends De {
   onBeforeRender() {
     this.setDefine("FEATURE_DOF", this.physicalCamera.bokehSize === 0 ? 0 : 1), this.setDefine("FEATURE_BACKGROUND_MAP", this.backgroundMap ? 1 : 0), this.setDefine("FEATURE_FOG", this.materials.features.isUsed("FOG") ? 1 : 0);
   }
@@ -4965,17 +4965,17 @@ class Ga extends De {
         transmissiveBounces: { value: 10 },
         filterGlossyFactor: { value: 0 },
         // camera uniforms
-        physicalCamera: { value: new Wr() },
+        physicalCamera: { value: new Lr() },
         cameraWorldMatrix: { value: new O() },
         invProjectionMatrix: { value: new O() },
         // scene uniforms
-        bvh: { value: new or() },
-        attributesArray: { value: new Zr() },
+        bvh: { value: new nr() },
+        attributesArray: { value: new Jr() },
         materialIndexAttribute: { value: new vt() },
-        materials: { value: new ia() },
+        materials: { value: new sa() },
         textures: { value: new rt().texture },
         // light uniforms
-        lights: { value: new Qr() },
+        lights: { value: new Kr() },
         iesProfiles: { value: new rt(360, 180, {
           type: D,
           wrapS: N,
@@ -4983,7 +4983,7 @@ class Ga extends De {
         }).texture },
         environmentIntensity: { value: 1 },
         environmentRotation: { value: new O() },
-        envMapInfo: { value: new Vr() },
+        envMapInfo: { value: new Gr() },
         // background uniforms
         backgroundBlur: { value: 0 },
         backgroundMap: { value: null },
@@ -4993,8 +4993,8 @@ class Ga extends De {
         // randomness uniforms
         seed: { value: 0 },
         sobolTexture: { value: null },
-        stratifiedTexture: { value: new fa() },
-        stratifiedOffsetTexture: { value: new xa(64, 1) }
+        stratifiedTexture: { value: new da() },
+        stratifiedOffsetTexture: { value: new ba(64, 1) }
       },
       vertexShader: (
         /* glsl */
@@ -5026,27 +5026,27 @@ class Ga extends De {
 				#include <common>
 
 				// bvh intersection
-				${cr}
-				${hr}
 				${ur}
+				${fr}
+				${hr}
 
 				// uniform structs
-				${ba}
-				${Ta}
 				${ya}
 				${wa}
+				${Ta}
 				${Ia}
+				${Ra}
 
 				// random
 				#if RANDOM_TYPE == 2 	// Stratified List
 
-					${Da}
+					${Pa}
 
 				#elif RANDOM_TYPE == 1 	// Sobol
 
 					${it}
 					${wt}
-					${zr}
+					${Nr}
 
 					#define rand(v) sobol(v)
 					#define rand2(v) sobol2(v)
@@ -5071,11 +5071,11 @@ class Ga extends De {
 				#endif
 
 				// common
-				${Ca}
-				${Ma}
-				${Rt}
+				${Da}
 				${Aa}
+				${Rt}
 				${Fa}
+				${Ca}
 
 				// environment
 				uniform EquirectHdrInfo envMapInfo;
@@ -5131,16 +5131,16 @@ class Ga extends De {
 				float lightsDenom;
 
 				// sampling
-				${_a}
-				${Ra}
+				${Ma}
 				${Sa}
+				${_a}
 
+				${Ha}
+				${Oa}
 				${Na}
-				${ka}
 				${za}
-				${Oa}
+				${ka}
 				${Ea}
-				${Pa}
 
 				float applyFilteredGlossy( float roughness, float accumulatedRoughness ) {
 
@@ -5172,12 +5172,12 @@ class Ga extends De {
 
 				}
 
-				${Ua}
-				${Ha}
 				${Va}
-				${Ba}
 				${Wa}
+				${Ga}
+				${Ba}
 				${La}
+				${Ua}
 
 				void main() {
 
@@ -5474,7 +5474,7 @@ class Ga extends De {
     }), this.setValues(e);
   }
 }
-function* qa() {
+function* $a() {
   const {
     _renderer: s,
     _fsQuad: e,
@@ -5485,17 +5485,17 @@ function* qa() {
     _subframe: a,
     alpha: l,
     material: h
-  } = this, f = new J(), d = new J(), u = t.material;
-  let [n, v] = i;
+  } = this, d = new J(), f = new J(), u = t.material;
+  let [n, x] = i;
   for (; ; ) {
     l ? (u.opacity = this._opacityFactor / (this.samples + 1), h.blending = ie, h.opacity = 1) : (h.opacity = this._opacityFactor / (this.samples + 1), h.blending = mt);
-    const [m, g, c, p] = a, x = r.width, b = r.height;
-    h.resolution.set(x * c, b * p), h.sobolTexture = o.texture, h.stratifiedTexture.init(20, h.bounces + h.transmissiveBounces + 5), h.stratifiedTexture.next(), h.seed++;
-    const y = this.tiles.x || 1, w = this.tiles.y || 1, E = y * w, B = Math.ceil(x * c), ge = Math.ceil(b * p), Ee = Math.floor(m * x), ke = Math.floor(g * b), ve = Math.ceil(B / y), xe = Math.ceil(ge / w);
+    const [m, g, c, p] = a, v = r.width, b = r.height;
+    h.resolution.set(v * c, b * p), h.sobolTexture = o.texture, h.stratifiedTexture.init(20, h.bounces + h.transmissiveBounces + 5), h.stratifiedTexture.next(), h.seed++;
+    const y = this.tiles.x || 1, w = this.tiles.y || 1, E = y * w, H = Math.ceil(v * c), ge = Math.ceil(b * p), Ee = Math.floor(m * v), ke = Math.floor(g * b), ve = Math.ceil(H / y), xe = Math.ceil(ge / w);
     for (let oe = 0; oe < w; oe++)
       for (let ne = 0; ne < y; ne++) {
         const Oe = s.getRenderTarget(), St = s.autoClear, _t = s.getScissorTest();
-        s.getScissor(f), s.getViewport(d);
+        s.getScissor(d), s.getViewport(f);
         let be = ne, ze = oe;
         if (!this.stableTiles) {
           const ye = this._currentTile % (y * w);
@@ -5505,16 +5505,16 @@ function* qa() {
         r.scissor.set(
           Ee + be * ve,
           ke + Ne * xe,
-          Math.min(ve, B - be * ve),
+          Math.min(ve, H - be * ve),
           Math.min(xe, ge - Ne * xe)
         ), r.viewport.set(
           Ee,
           ke,
-          B,
+          H,
           ge
-        ), s.setRenderTarget(r), s.setScissorTest(!0), s.autoClear = !1, e.render(s), s.setViewport(d), s.setScissor(f), s.setScissorTest(_t), s.setRenderTarget(Oe), s.autoClear = St, l && (u.target1 = n.texture, u.target2 = r.texture, s.setRenderTarget(v), t.render(s), s.setRenderTarget(Oe)), this.samples += 1 / E, ne === y - 1 && oe === w - 1 && (this.samples = Math.round(this.samples)), yield;
+        ), s.setRenderTarget(r), s.setScissorTest(!0), s.autoClear = !1, e.render(s), s.setViewport(f), s.setScissor(d), s.setScissorTest(_t), s.setRenderTarget(Oe), s.autoClear = St, l && (u.target1 = n.texture, u.target2 = r.texture, s.setRenderTarget(x), t.render(s), s.setRenderTarget(Oe)), this.samples += 1 / E, ne === y - 1 && oe === w - 1 && (this.samples = Math.round(this.samples)), yield;
       }
-    [n, v] = [v, n];
+    [n, x] = [x, n];
   }
 }
 const st = new se();
@@ -5538,7 +5538,7 @@ class ot {
     return !!this._compilePromise;
   }
   constructor(e) {
-    this.camera = null, this.tiles = new j(3, 3), this.stableNoise = !1, this.stableTiles = !0, this.samples = 0, this._subframe = new J(0, 0, 1, 1), this._opacityFactor = 1, this._renderer = e, this._alpha = !1, this._fsQuad = new ee(new Ga()), this._blendQuad = new ee(new kr()), this._task = null, this._currentTile = 0, this._compilePromise = null, this._sobolTarget = new Br().generate(e), this._primaryTarget = new ae(1, 1, {
+    this.camera = null, this.tiles = new j(3, 3), this.stableNoise = !1, this.stableTiles = !0, this.samples = 0, this._subframe = new J(0, 0, 1, 1), this._opacityFactor = 1, this._renderer = e, this._alpha = !1, this._fsQuad = new ee(new qa()), this._blendQuad = new ee(new Or()), this._task = null, this._currentTile = 0, this._compilePromise = null, this._sobolTarget = new Br().generate(e), this._primaryTarget = new ae(1, 1, {
       format: I,
       type: R,
       magFilter: T,
@@ -5586,11 +5586,11 @@ class ot {
     e.getClearColor(st), e.setRenderTarget(t), e.setClearColor(0, 0), e.clearColor(), e.setRenderTarget(r[0]), e.setClearColor(0, 0), e.clearColor(), e.setRenderTarget(r[1]), e.setClearColor(0, 0), e.clearColor(), e.setClearColor(st, o), e.setRenderTarget(i), this.samples = 0, this._task = null, this.material.stratifiedTexture.stableNoise = this.stableNoise, this.stableNoise && (this.material.seed = 0, this.material.stratifiedTexture.reset());
   }
   update() {
-    this.material.onBeforeRender(), !this.isCompiling && (this._task || (this._task = qa.call(this)), this._task.next());
+    this.material.onBeforeRender(), !this.isCompiling && (this._task || (this._task = $a.call(this)), this._task.next());
   }
 }
 const q = new j(), nt = new j(), fe = new Lt(), de = new se();
-class $a extends M {
+class ja extends M {
   constructor(e = 512, t = 512) {
     super(
       new Float32Array(e * t * 4),
@@ -5620,7 +5620,7 @@ class $a extends M {
   }
 }
 const lt = new C();
-class ja extends $a {
+class Ya extends ja {
   constructor(e = 512) {
     super(e, e), this.topColor = new se().set(16777215), this.bottomColor = new se().set(0), this.exponent = 2, this.generationCallback = (t, r, i, o) => {
       lt.setFromSpherical(t);
@@ -5632,7 +5632,7 @@ class ja extends $a {
     return super.copy(e), this.topColor.copy(e.topColor), this.bottomColor.copy(e.bottomColor), this;
   }
 }
-class Ya extends pe {
+class Xa extends pe {
   get map() {
     return this.uniforms.map.value;
   }
@@ -5719,7 +5719,7 @@ class Ya extends pe {
     }), this.setValues(e);
   }
 }
-class Xa extends pe {
+class Qa extends pe {
   constructor() {
     super({
       uniforms: {
@@ -5764,7 +5764,7 @@ class Xa extends pe {
 }
 class ct {
   constructor(e) {
-    this._renderer = e, this._quad = new ee(new Xa());
+    this._renderer = e, this._quad = new ee(new Qa());
   }
   generate(e, t = null, r = null) {
     if (!e.isCubeTexture)
@@ -5774,13 +5774,13 @@ class ct {
     const l = new ae(t, r, {
       type: R,
       colorSpace: i.colorSpace
-    }), h = i.height, f = Math.log2(h) - 2, d = 1 / h, u = 1 / (3 * Math.max(Math.pow(2, f), 112));
-    a.material.defines.CUBEUV_MAX_MIP = `${f}.0`, a.material.defines.CUBEUV_TEXEL_WIDTH = u, a.material.defines.CUBEUV_TEXEL_HEIGHT = d, a.material.uniforms.envMap.value = e, a.material.uniforms.flipEnvMap.value = e.isRenderTargetTexture ? 1 : -1, a.material.needsUpdate = !0;
-    const n = o.getRenderTarget(), v = o.autoClear;
-    o.autoClear = !0, o.setRenderTarget(l), a.render(o), o.setRenderTarget(n), o.autoClear = v;
+    }), h = i.height, d = Math.log2(h) - 2, f = 1 / h, u = 1 / (3 * Math.max(Math.pow(2, d), 112));
+    a.material.defines.CUBEUV_MAX_MIP = `${d}.0`, a.material.defines.CUBEUV_TEXEL_WIDTH = u, a.material.defines.CUBEUV_TEXEL_HEIGHT = f, a.material.uniforms.envMap.value = e, a.material.uniforms.flipEnvMap.value = e.isRenderTargetTexture ? 1 : -1, a.material.needsUpdate = !0;
+    const n = o.getRenderTarget(), x = o.autoClear;
+    o.autoClear = !0, o.setRenderTarget(l), a.render(o), o.setRenderTarget(n), o.autoClear = x;
     const m = new Uint16Array(t * r * 4), g = new Float32Array(t * r * 4);
     o.readRenderTargetPixels(l, 0, 0, t, r, g), l.dispose();
-    for (let p = 0, x = g.length; p < x; p++)
+    for (let p = 0, v = g.length; p < v; p++)
       m[p] = k.toHalfFloat(g[p]);
     const c = new M(m, t, r, I, D);
     return c.minFilter = Ut, c.magFilter = F, c.wrapS = z, c.wrapT = z, c.mapping = pt, c.needsUpdate = !0, c;
@@ -5789,11 +5789,11 @@ class ct {
     this._quad.dispose();
   }
 }
-function Qa(s) {
+function Ka(s) {
   return s.extensions.get("EXT_float_blend");
 }
 const Q = new j();
-class Ka {
+class Za {
   get multipleImportanceSampling() {
     return !!this._pathTracer.material.defines.FEATURE_MIS;
   }
@@ -5837,7 +5837,7 @@ class Ka {
     return !!this._pathTracer.isCompiling;
   }
   constructor(e) {
-    this._renderer = e, this._generator = new Cr(), this._pathTracer = new ot(e), this._queueReset = !1, this._clock = new Vt(), this._compilePromise = null, this._lowResPathTracer = new ot(e), this._lowResPathTracer.tiles.set(1, 1), this._quad = new ee(new Ya({
+    this._renderer = e, this._generator = new Dr(), this._pathTracer = new ot(e), this._queueReset = !1, this._clock = new Vt(), this._compilePromise = null, this._lowResPathTracer = new ot(e), this._lowResPathTracer.tiles.set(1, 1), this._quad = new ee(new Xa({
       map: null,
       transparent: !0,
       blending: ie,
@@ -5875,11 +5875,11 @@ class Ka {
     e.updateMatrixWorld(), this._pathTracer.setCamera(e), this._lowResPathTracer.setCamera(e), this.reset();
   }
   updateMaterials() {
-    const e = this._pathTracer.material, t = this._renderer, r = this._materials, i = this.textureSize, o = ta(r);
+    const e = this._pathTracer.material, t = this._renderer, r = this._materials, i = this.textureSize, o = ra(r);
     e.textures.setTextures(t, o, i.x, i.y), e.materials.updateFrom(r, o), this.reset();
   }
   updateLights() {
-    const e = this.scene, t = this._renderer, r = this._pathTracer.material, i = ra(e), o = ea(i);
+    const e = this.scene, t = this._renderer, r = this._pathTracer.material, i = aa(e), o = ta(i);
     r.lights.updateFrom(i, o), r.iesProfiles.setTextures(t, o), this.reset();
   }
   updateEnvironment() {
@@ -5887,7 +5887,7 @@ class Ka {
     if (this._internalBackground && (this._internalBackground.dispose(), this._internalBackground = null), t.backgroundBlur = e.backgroundBlurriness, t.backgroundIntensity = e.backgroundIntensity ?? 1, t.backgroundRotation.makeRotationFromEuler(e.backgroundRotation).invert(), e.background === null)
       t.backgroundMap = null, t.backgroundAlpha = 0;
     else if (e.background.isColor) {
-      this._colorBackground = this._colorBackground || new ja(16);
+      this._colorBackground = this._colorBackground || new Ya(16);
       const r = this._colorBackground;
       r.topColor.equals(e.background) || (r.topColor.set(e.background), r.bottomColor.set(e.background), r.update()), t.backgroundMap = r, t.backgroundAlpha = 1;
     } else if (e.background.isCubeTexture) {
@@ -5916,25 +5916,25 @@ class Ka {
       bvhChanged: l
     } = r;
     this._materials = i;
-    const f = this._pathTracer.material;
-    return l && (f.bvh.updateFrom(a), f.attributesArray.updateFrom(
+    const d = this._pathTracer.material;
+    return l && (d.bvh.updateFrom(a), d.attributesArray.updateFrom(
       o.attributes.normal,
       o.attributes.tangent,
       o.attributes.uv,
       o.attributes.color
-    ), f.materialIndexAttribute.updateFrom(o.attributes.materialIndex)), this._previousScene = e, this.scene = e, this.camera = t, this.updateCamera(), this.updateMaterials(), this.updateEnvironment(), this.updateLights(), r;
+    ), d.materialIndexAttribute.updateFrom(o.attributes.materialIndex)), this._previousScene = e, this.scene = e, this.camera = t, this.updateCamera(), this.updateMaterials(), this.updateEnvironment(), this.updateLights(), r;
   }
   renderSample() {
     const e = this._lowResPathTracer, t = this._pathTracer, r = this._renderer, i = this._clock, o = this._quad;
     this._updateScale(), this._queueReset && (t.reset(), e.reset(), this._queueReset = !1, o.material.opacity = 0, i.start());
     const a = i.getDelta() * 1e3, l = i.getElapsedTime() * 1e3;
-    if (!this.pausePathTracing && this.enablePathTracing && this.renderDelay <= l && !this.isCompiling && t.update(), t.alpha = t.material.backgroundAlpha !== 1 || !Qa(r), e.alpha = t.alpha, this.renderToCanvas) {
-      const h = this._renderer, f = this.minSamples;
-      if (l >= this.renderDelay && this.samples >= this.minSamples && (this.fadeDuration !== 0 ? o.material.opacity = Math.min(o.material.opacity + a / this.fadeDuration, 1) : o.material.opacity = 1), !this.enablePathTracing || this.samples < f || o.material.opacity < 1) {
+    if (!this.pausePathTracing && this.enablePathTracing && this.renderDelay <= l && !this.isCompiling && t.update(), t.alpha = t.material.backgroundAlpha !== 1 || !Ka(r), e.alpha = t.alpha, this.renderToCanvas) {
+      const h = this._renderer, d = this.minSamples;
+      if (l >= this.renderDelay && this.samples >= this.minSamples && (this.fadeDuration !== 0 ? o.material.opacity = Math.min(o.material.opacity + a / this.fadeDuration, 1) : o.material.opacity = 1), !this.enablePathTracing || this.samples < d || o.material.opacity < 1) {
         if (this.dynamicLowRes && !this.isCompiling) {
           e.samples < 1 && (e.material = t.material, e.update());
-          const d = o.material.opacity;
-          o.material.opacity = 1 - o.material.opacity, o.material.map = e.target.texture, o.render(h), o.material.opacity = d;
+          const f = o.material.opacity;
+          o.material.opacity = 1 - o.material.opacity, o.material.map = e.target.texture, o.render(h), o.material.opacity = f;
         }
         (!this.dynamicLowRes && this.rasterizeScene || this.dynamicLowRes && this.isCompiling) && this.rasterizeSceneCallback(this.scene, this.camera);
       }
@@ -5961,7 +5961,7 @@ class Ka {
 function K(s) {
   return s !== null && typeof s == "object" && "getInternalRenderer" in s && typeof s.getInternalRenderer == "function";
 }
-class ei {
+class ti {
   constructor() {
     this.pathTracer = null, this.enabled = !1, this.renderer = null, this.sampleCount = 0, this.createAttempts = 0, this.maxCreateAttempts = 10, this.sceneInitialized = !1, this.environmentWaitFrames = 0, this.maxEnvironmentWaitFrames = 300, this.disposed = !1, this.disposeTimer = null, this.convertedEnvTexture = null, this.lastResetTime = 0, this.events = new rr(), this.settings = {
       samples: ar,
@@ -5976,6 +5976,27 @@ class ei {
       enablePathTracing: !0
     };
   }
+  /**
+   * Hand the scene to the path tracer with the viewer's own contact-shadow
+   * helpers hidden: the tracer computes physically-correct contact shadows
+   * itself, so ingesting the baked disc double-darkens the contact area (and
+   * the live ShadowMaterial catcher is equally meaningless to it). The
+   * generator skips invisible nodes; visibility is restored right after the
+   * ingest so the raster fallback path keeps its baked shadow.
+   */
+  ingestSceneWithoutShadowHelpers(e, t) {
+    var i;
+    const r = [];
+    e.traverse((o) => {
+      var a;
+      (a = o.userData) != null && a[ir] && o.visible && r.push(o);
+    }), r.forEach((o) => o.visible = !1);
+    try {
+      (i = this.pathTracer) == null || i.setScene(e, t);
+    } finally {
+      r.forEach((o) => o.visible = !0);
+    }
+  }
   /**
    * Convert an HTMLImageElement-based texture to a DataTexture for path tracing
    */
@@ -5991,12 +6012,12 @@ class ei {
     const o = i.getImageData(0, 0, r.width, r.height), a = new Float32Array(o.data.length);
     for (let h = 0; h < o.data.length; h++)
       a[h] = o.data[h] / 255;
-    const l = new H.DataTexture(
+    const l = new B.DataTexture(
       a,
       r.width,
       r.height,
-      H.RGBAFormat,
-      H.FloatType
+      B.RGBAFormat,
+      B.FloatType
     );
     return l.mapping = e.mapping, l.wrapS = e.wrapS, l.wrapT = e.wrapT, l.magFilter = e.magFilter, l.minFilter = e.minFilter, l.anisotropy = e.anisotropy, l.needsUpdate = !0, l;
   }
@@ -6029,7 +6050,7 @@ class ei {
       );
     try {
       const e = K(this.renderer) ? this.renderer.getInternalRenderer() : null;
-      return e ? (this.pathTracer = new Ka(e), this.pathTracer.tiles && "set" in this.pathTracer.tiles && this.pathTracer.tiles.set(1, 1), this.pathTracer.bounces = this.settings.bounces, this.settings.transmissiveBounces !== void 0 && (this.pathTracer.transmissiveBounces = this.settings.transmissiveBounces), this.pathTracer.renderScale = this.settings.renderScale, this.pathTracer.dynamicLowRes = this.settings.dynamicLowRes, this.pathTracer.lowResScale = this.settings.lowResScale, this.pathTracer.environmentIntensity !== void 0 && (this.pathTracer.environmentIntensity = 2), e.toneMapping !== H.ACESFilmicToneMapping && (e.toneMapping = H.ACESFilmicToneMapping, e.toneMappingExposure = 1.5), e.autoClear = !1, e.setRenderTarget(null), S.ok(void 0)) : S.err(
+      return e ? (this.pathTracer = new Za(e), this.pathTracer.tiles && "set" in this.pathTracer.tiles && this.pathTracer.tiles.set(1, 1), this.pathTracer.bounces = this.settings.bounces, this.settings.transmissiveBounces !== void 0 && (this.pathTracer.transmissiveBounces = this.settings.transmissiveBounces), this.pathTracer.renderScale = this.settings.renderScale, this.pathTracer.dynamicLowRes = this.settings.dynamicLowRes, this.pathTracer.lowResScale = this.settings.lowResScale, this.pathTracer.environmentIntensity !== void 0 && (this.pathTracer.environmentIntensity = 2), e.toneMapping !== B.ACESFilmicToneMapping && (e.toneMapping = B.ACESFilmicToneMapping, e.toneMappingExposure = 1.5), e.autoClear = !1, e.setRenderTarget(null), S.ok(void 0)) : S.err(
         new W(
           "Renderer not ready, will retry",
           L.RENDERER_NOT_INITIALIZED
@@ -6139,42 +6160,42 @@ class ei {
    * waiting, or the environment shape isn't one the tracer can use.
    */
   async initializeSceneForPathTracing(e, t, r, i, o) {
-    var a, l, h;
+    var a;
     try {
-      const f = i.__originalEnvironmentTexture;
-      if (!i.environment && !f)
+      const l = i.__originalEnvironmentTexture;
+      if (!i.environment && !l)
         return this.environmentWaitFrames++, this.environmentWaitFrames >= this.maxEnvironmentWaitFrames && (this.disableAfterSelfPause("gave-up"), this.environmentWaitFrames = 0), e.render(t, r);
-      if (this.environmentWaitFrames = 0, f && f.mapping === H.EquirectangularReflectionMapping) {
-        let d = f;
-        if (f.image instanceof HTMLImageElement)
+      if (this.environmentWaitFrames = 0, l && l.mapping === B.EquirectangularReflectionMapping) {
+        let h = l;
+        if (l.image instanceof HTMLImageElement)
           if (this.convertedEnvTexture)
-            d = this.convertedEnvTexture;
+            h = this.convertedEnvTexture;
           else {
-            const n = this.convertToDataTexture(f);
-            if (!n)
+            const f = this.convertToDataTexture(l);
+            if (!f)
               throw new Error("Failed to convert environment texture to DataTexture");
-            this.convertedEnvTexture = n, d = n;
+            this.convertedEnvTexture = f, h = f;
           }
-        const u = i.environment;
-        i.environment = d;
+        const d = i.environment;
+        i.environment = h;
         try {
-          const n = f.image;
-          n && !("data" in n && n.data) && n instanceof HTMLImageElement && !n.complete && await new Promise((v) => {
-            n.onload = () => {
-              f.needsUpdate = !0, v();
-            }, n.onerror = () => {
-              v();
-            }, n.complete && v();
-          }), (a = this.pathTracer) == null || a.setScene(i, o), this.sceneInitialized = !0, i.environment = u;
-        } catch (n) {
-          throw i.environment = u, n;
+          const f = l.image;
+          f && !("data" in f && f.data) && f instanceof HTMLImageElement && !f.complete && await new Promise((u) => {
+            f.onload = () => {
+              l.needsUpdate = !0, u();
+            }, f.onerror = () => {
+              u();
+            }, f.complete && u();
+          }), this.ingestSceneWithoutShadowHelpers(i, o), this.sceneInitialized = !0, i.environment = d;
+        } catch (f) {
+          throw i.environment = d, f;
         }
-      } else if (((l = i.environment) == null ? void 0 : l.mapping) === H.EquirectangularReflectionMapping)
-        (h = this.pathTracer) == null || h.setScene(i, o), this.sceneInitialized = !0;
+      } else if (((a = i.environment) == null ? void 0 : a.mapping) === B.EquirectangularReflectionMapping)
+        this.ingestSceneWithoutShadowHelpers(i, o), this.sceneInitialized = !0;
       else
         return this.disableAfterSelfPause("gave-up"), e.render(t, r);
-    } catch (f) {
-      return console.warn("Scene initialization error:", f), e.render(t, r);
+    } catch (l) {
+      return console.warn("Scene initialization error:", l), e.render(t, r);
     }
     return null;
   }
@@ -6245,9 +6266,9 @@ class ei {
   isPathTracerDisposed() {
     return this.disposed;
   }
-  reset() {
-    const e = performance.now();
-    e - this.lastResetTime < 50 || (this.lastResetTime = e, this.sampleCount = 0, this.pathTracer && (this.pathTracer.reset(), this.sceneInitialized = !1));
+  reset(e = !1) {
+    const t = performance.now();
+    !e && t - this.lastResetTime < 50 || (this.lastResetTime = t, this.sampleCount = 0, this.pathTracer && (this.pathTracer.reset(), this.sceneInitialized = !1));
   }
   /**
    * Dispose of path tracing resources after the final frame is on screen
@@ -6283,5 +6304,5 @@ class ei {
   }
 }
 export {
-  ei as ThreePathTracingService
+  ti as ThreePathTracingService
 };