softbox 4.7.0 → 4.9.0

package/dist/{ThreePathTracingService-DbqedkL2.js → ThreePathTracingService-CZdztwad.js}

@@ -1,8 +1,9 @@
-import * as J from "three";
-import { UnsignedIntType as re, DataTexture as M, NearestFilter as T, IntType as we, FloatType as R, UnsignedByteType as Me, UnsignedShortType as Ct, ByteType as Be, ShortType as Ft, RGBAFormat as I, RGBAIntegerFormat as Ae, RGIntegerFormat as ft, RedIntegerFormat as Dt, RGFormat as dt, RedFormat as me, BufferAttribute as P, BufferGeometry as q, Matrix4 as O, Matrix3 as Pt, Vector3 as F, Vector4 as K, MeshBasicMaterial as Et, Mesh as mt, OrthographicCamera as kt, Float32BufferAttribute as We, ShaderMaterial as ge, NoBlending as ie, WebGLRenderTarget as ae, Vector2 as $, PerspectiveCamera as pt, DataUtils as k, HalfFloatType as D, LinearFilter as C, RepeatWrapping as z, ClampToEdgeWrapping as N, Source as Ot, Quaternion as zt, DataArrayTexture as Nt, DoubleSide as Ht, BackSide as Bt, FrontSide as Wt, WebGLArrayRenderTarget as Lt, Color as se, NoToneMapping as Ut, NormalBlending as gt, EquirectangularReflectionMapping as vt, Spherical as Vt, LinearMipMapLinearFilter as Gt, Clock as qt, Scene as $t, AdditiveBlending as jt } from "three";
-import { g as Yt, a as Xt, B as Le, I as Qt, C as Kt, O as Zt, S as Jt, b as er, L as tr, c as rr, M as ar, T as ir, D as sr, d as or, R as _, e as B, E as W } from "./index-DXbG9xpu.js";
-function nr(s) {
-  switch (s) {
+import * as _ from "three";
+import { UnsignedIntType as ae, DataTexture as F, NearestFilter as T, IntType as we, FloatType as R, UnsignedByteType as Me, UnsignedShortType as Mt, ByteType as Be, ShortType as At, RGBAFormat as I, RGBAIntegerFormat as Ae, RGIntegerFormat as ft, RedIntegerFormat as Ft, RGFormat as ht, RedFormat as pe, BufferAttribute as O, BufferGeometry as ee, Matrix4 as z, Matrix3 as Ct, Vector3 as P, Vector4 as te, MeshBasicMaterial as Dt, Mesh as Pt, ShaderMaterial as ge, NoBlending as se, WebGLRenderTarget as ie, Vector2 as X, PerspectiveCamera as dt, DataUtils as N, HalfFloatType as E, LinearFilter as D, RepeatWrapping as H, ClampToEdgeWrapping as B, Source as Et, Quaternion as Ot, DataArrayTexture as kt, DoubleSide as Nt, BackSide as zt, FrontSide as Ht, WebGLArrayRenderTarget as Bt, Color as oe, NoToneMapping as Wt, NormalBlending as mt, EquirectangularReflectionMapping as pt, Spherical as Lt, LinearMipMapLinearFilter as Ut, Clock as Gt, Scene as Vt, AdditiveBlending as qt } from "three";
+import { F as Y } from "./Pass-DOcH4lwV.js";
+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, P as sr, R as S, e as L, E as U } from "./index-op1Vhyk7.js";
+function or(o) {
+  switch (o) {
     case 1:
       return "R";
     case 2:
@@ -14,22 +15,22 @@ function nr(s) {
   }
   throw new Error();
 }
-function lr(s) {
-  switch (s) {
+function nr(o) {
+  switch (o) {
     case 1:
-      return me;
+      return pe;
     case 2:
-      return dt;
+      return ht;
     case 3:
       return I;
     case 4:
       return I;
   }
 }
-function Ue(s) {
-  switch (s) {
+function Le(o) {
+  switch (o) {
     case 1:
-      return Dt;
+      return Ft;
     case 2:
       return ft;
     case 3:
@@ -38,7 +39,7 @@ function Ue(s) {
       return Ae;
   }
 }
-class xt extends M {
+class gt extends F {
   constructor() {
     super(), this.minFilter = T, this.magFilter = T, this.generateMipmaps = !1, this.overrideItemSize = null, this._forcedType = null;
   }
@@ -59,59 +60,59 @@ class xt 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, d = h.BYTES_PER_ELEMENT;
-    let f = this._forcedType, u = o;
-    if (f === null)
-      switch (h) {
+    const s = e.itemSize, a = e.count, l = e.normalized, u = e.array.constructor, d = u.BYTES_PER_ELEMENT;
+    let h = this._forcedType, f = s;
+    if (h === null)
+      switch (u) {
         case Float32Array:
-          f = R;
+          h = R;
           break;
         case Uint8Array:
         case Uint16Array:
         case Uint32Array:
-          f = re;
+          h = ae;
           break;
         case Int8Array:
         case Int16Array:
         case Int32Array:
-          f = we;
+          h = we;
           break;
       }
-    let n, x, m, g, c = nr(o);
-    switch (f) {
+    let n, x, m, g, c = or(s);
+    switch (h) {
       case R:
-        m = 1, x = lr(o), l && d === 1 ? (g = h, c += "8", h === Uint8Array ? n = Me : (n = Be, c += "_SNORM")) : (g = Float32Array, c += "32F", n = R);
+        m = 1, x = nr(s), l && d === 1 ? (g = u, c += "8", u === Uint8Array ? n = Me : (n = Be, c += "_SNORM")) : (g = Float32Array, c += "32F", n = R);
         break;
       case we:
-        c += d * 8 + "I", m = l ? Math.pow(2, h.BYTES_PER_ELEMENT * 8 - 1) : 1, x = Ue(o), d === 1 ? (g = Int8Array, n = Be) : d === 2 ? (g = Int16Array, n = Ft) : (g = Int32Array, n = we);
+        c += d * 8 + "I", m = l ? Math.pow(2, u.BYTES_PER_ELEMENT * 8 - 1) : 1, x = Le(s), d === 1 ? (g = Int8Array, n = Be) : d === 2 ? (g = Int16Array, n = At) : (g = Int32Array, n = we);
         break;
-      case 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 = Me) : d === 2 ? (g = Uint16Array, n = Ct) : (g = Uint32Array, n = re);
+      case ae:
+        c += d * 8 + "UI", m = l ? Math.pow(2, u.BYTES_PER_ELEMENT * 8 - 1) : 1, x = Le(s), d === 1 ? (g = Uint8Array, n = Me) : d === 2 ? (g = Uint16Array, n = Mt) : (g = Uint32Array, n = ae);
         break;
     }
-    u === 3 && (x === I || x === Ae) && (u = 4);
-    const p = Math.ceil(Math.sqrt(a)) || 1, v = u * p * p, b = new g(v), y = e.normalized;
+    f === 3 && (x === I || x === Ae) && (f = 4);
+    const p = Math.ceil(Math.sqrt(a)) || 1, v = f * 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);
+      const k = f * w;
+      b[k] = e.getX(w) / m, s >= 2 && (b[k + 1] = e.getY(w) / m), s >= 3 && (b[k + 2] = e.getZ(w) / m, f === 4 && (b[k + 3] = 1)), s >= 4 && (b[k + 3] = e.getW(w) / m);
     }
     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 bt extends xt {
+class vt extends gt {
   constructor() {
-    super(), this._forcedType = re;
+    super(), this._forcedType = ae;
   }
 }
-class yt extends xt {
+class xt extends gt {
   constructor() {
     super(), this._forcedType = R;
   }
 }
-class cr {
+class lr {
   constructor() {
-    this.index = new bt(), this.position = new yt(), this.bvhBounds = new M(), this.bvhContents = new M(), this._cachedIndexAttr = null, this.index.overrideItemSize = 3;
+    this.index = new vt(), this.position = new xt(), this.bvhBounds = new F(), this.bvhContents = new F(), this._cachedIndexAttr = null, this.index.overrideItemSize = 3;
   }
   /**
    * Updates the object and associated textures with data from the provided BVH.
@@ -121,16 +122,16 @@ class cr {
    */
   updateFrom(e) {
     const { geometry: t } = e;
-    if (hr(e, this.bvhBounds, this.bvhContents), this.position.updateFrom(t.attributes.position), e.indirect) {
+    if (ur(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)
           this._cachedIndexAttr = t.index.clone();
         else {
-          const i = Yt(Xt(t));
-          this._cachedIndexAttr = new P(i, 1, !1);
+          const i = $t(jt(t));
+          this._cachedIndexAttr = new O(i, 1, !1);
         }
-      ur(t, r, this._cachedIndexAttr), this.index.updateFrom(this._cachedIndexAttr);
+      cr(t, r, this._cachedIndexAttr), this.index.updateFrom(this._cachedIndexAttr);
     } else
       this.index.updateFrom(t.index);
   }
@@ -144,32 +145,32 @@ class cr {
     e && e.dispose(), t && t.dispose(), r && r.dispose(), i && i.dispose();
   }
 }
-function ur(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];
+function cr(o, e, t) {
+  const r = t.array, i = o.index ? o.index.array : null;
+  for (let s = 0, a = e.length; s < a; s++) {
+    const l = 3 * s, u = 3 * e[s];
     for (let d = 0; d < 3; d++)
-      r[l + d] = i ? i[h + d] : h + d;
+      r[l + d] = i ? i[u + d] : u + d;
   }
 }
-function hr(s, e, t) {
-  const r = s._roots;
+function ur(o, e, t) {
+  const r = o._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 / Le, 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 * Le / 4, g = m * 2, c = er(m);
+  const i = r[0], s = new Uint16Array(i), a = new Uint32Array(i), l = new Float32Array(i), u = i.byteLength / We, d = 2 * Math.ceil(Math.sqrt(u / 2)), h = new Float32Array(4 * d * d), f = Math.ceil(Math.sqrt(u)), n = new Uint32Array(2 * f * f);
+  for (let x = 0; x < u; x++) {
+    const m = x * We / 4, g = m * 2, c = Zt(m);
     for (let p = 0; p < 3; p++)
-      f[8 * x + 0 + p] = l[c + 0 + p], f[8 * x + 4 + p] = l[c + 3 + p];
-    if (Qt(g, o)) {
-      const p = Kt(g, o), v = Zt(m, a), b = tr | p;
+      h[8 * x + 0 + p] = l[c + 0 + p], h[8 * x + 4 + p] = l[c + 3 + p];
+    if (Yt(g, s)) {
+      const p = Xt(g, s), v = Qt(m, a), b = Jt | p;
       n[x * 2 + 0] = b, n[x * 2 + 1] = v;
     } else {
-      const p = a[m + 6], v = Jt(m, a);
+      const p = a[m + 6], v = Kt(m, a);
       n[x * 2 + 0] = v, n[x * 2 + 1] = p;
     }
   }
-  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 = ft, t.type = re, t.internalFormat = "RG32UI", t.minFilter = T, t.magFilter = T, t.generateMipmaps = !1, t.needsUpdate = !0, t.dispose();
+  e.image.data = h, 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 = f, t.image.height = f, t.format = ft, t.type = ae, t.internalFormat = "RG32UI", t.minFilter = T, t.magFilter = T, t.generateMipmaps = !1, t.needsUpdate = !0, t.dispose();
 }
 const fr = (
   /* glsl */
@@ -256,7 +257,7 @@ void ndcToCameraRay(
 
 }
 `
-), dr = (
+), hr = (
   /* glsl */
   `
 
@@ -463,7 +464,7 @@ bool _bvhIntersectFirstHit(
 
 }
 `
-), mr = (
+), dr = (
   /* glsl */
   `
 struct BVH {
@@ -477,306 +478,306 @@ struct BVH {
 };
 `
 );
-function Tt(s, e, t = 0) {
-  if (s.isInterleavedBufferAttribute) {
-    const r = s.itemSize;
-    for (let i = 0, o = s.count; i < o; i++) {
+function bt(o, e, t = 0) {
+  if (o.isInterleavedBufferAttribute) {
+    const r = o.itemSize;
+    for (let i = 0, s = o.count; i < s; i++) {
       const a = i + t;
-      e.setX(a, s.getX(i)), r >= 2 && e.setY(a, s.getY(i)), r >= 3 && e.setZ(a, s.getZ(i)), r >= 4 && e.setW(a, s.getW(i));
+      e.setX(a, o.getX(i)), r >= 2 && e.setY(a, o.getY(i)), r >= 3 && e.setZ(a, o.getZ(i)), r >= 4 && e.setW(a, o.getW(i));
     }
   } else {
-    const r = e.array, i = r.constructor, o = r.BYTES_PER_ELEMENT * s.itemSize * t;
-    new i(r.buffer, o, s.array.length).set(s.array);
+    const r = e.array, i = r.constructor, s = r.BYTES_PER_ELEMENT * o.itemSize * t;
+    new i(r.buffer, s, o.array.length).set(o.array);
   }
 }
-function te(s, e = null) {
-  const t = s.array.constructor, r = s.normalized, i = s.itemSize, o = e === null ? s.count : e;
-  return new P(new t(i * o), i, r);
+function re(o, e = null) {
+  const t = o.array.constructor, r = o.normalized, i = o.itemSize, s = e === null ? o.count : e;
+  return new O(new t(i * s), i, r);
 }
-function Q(s, e) {
-  if (!s && !e)
+function J(o, e) {
+  if (!o && !e)
     return !0;
-  if (!!s != !!e)
+  if (!!o != !!e)
     return !1;
-  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);
+  const t = o.count === e.count, r = o.normalized === e.normalized, i = o.array.constructor === e.array.constructor, s = o.itemSize === e.itemSize;
+  return !(!t || !r || !i || !s);
 }
-function pr(s) {
-  const e = s[0].index !== null, t = new Set(Object.keys(s[0].attributes));
-  if (!s[0].getAttribute("position"))
+function mr(o) {
+  const e = o[0].index !== null, t = new Set(Object.keys(o[0].attributes));
+  if (!o[0].getAttribute("position"))
     throw new Error("StaticGeometryGenerator: position attribute is required.");
-  for (let r = 0; r < s.length; ++r) {
-    const i = s[r];
-    let o = 0;
+  for (let r = 0; r < o.length; ++r) {
+    const i = o[r];
+    let s = 0;
     if (e !== (i.index !== null))
       throw new Error("StaticGeometryGenerator: All geometries must have compatible attributes; make sure index attribute exists among all geometries, or in none of them.");
     for (const a in i.attributes) {
       if (!t.has(a))
         throw new Error('StaticGeometryGenerator: All geometries must have compatible attributes; make sure "' + a + '" attribute exists among all geometries, or in none of them.');
-      o++;
+      s++;
     }
-    if (o !== t.size)
+    if (s !== t.size)
       throw new Error("StaticGeometryGenerator: All geometries must have the same number of attributes.");
   }
 }
-function gr(s) {
+function pr(o) {
   let e = 0;
-  for (let t = 0, r = s.length; t < r; t++)
-    e += s[t].getIndex().count;
+  for (let t = 0, r = o.length; t < r; t++)
+    e += o[t].getIndex().count;
   return e;
 }
-function vr(s) {
+function gr(o) {
   let e = 0;
-  for (let t = 0, r = s.length; t < r; t++)
-    e += s[t].getAttribute("position").count;
+  for (let t = 0, r = o.length; t < r; t++)
+    e += o[t].getAttribute("position").count;
   return e;
 }
-function xr(s, e, t) {
-  s.index && s.index.count !== e && s.setIndex(null);
-  const r = s.attributes;
+function vr(o, e, t) {
+  o.index && o.index.count !== e && o.setIndex(null);
+  const r = o.attributes;
   for (const i in r)
-    r[i].count !== t && s.deleteAttribute(i);
+    r[i].count !== t && o.deleteAttribute(i);
 }
-function br(s, e = {}, t = new q()) {
+function xr(o, e = {}, t = new ee()) {
   const {
     useGroups: r = !1,
     forceUpdate: i = !1,
-    skipAssigningAttributes: o = [],
+    skipAssigningAttributes: s = [],
     overwriteIndex: a = !0
   } = e;
-  pr(s);
-  const l = s[0].index !== null, h = l ? gr(s) : -1, d = vr(s);
-  if (xr(t, h, d), r) {
-    let u = 0;
-    for (let n = 0, x = s.length; n < x; n++) {
-      const m = s[n];
+  mr(o);
+  const l = o[0].index !== null, u = l ? pr(o) : -1, d = gr(o);
+  if (vr(t, u, d), r) {
+    let f = 0;
+    for (let n = 0, x = o.length; n < x; n++) {
+      const m = o[n];
       let g;
-      l ? g = m.getIndex().count : g = m.getAttribute("position").count, t.addGroup(u, g, n), u += g;
+      l ? g = m.getIndex().count : g = m.getAttribute("position").count, t.addGroup(f, g, n), f += g;
     }
   }
   if (l) {
-    let u = !1;
-    if (t.index || (t.setIndex(new P(new Uint32Array(h), 1, !1)), u = !0), u || a) {
+    let f = !1;
+    if (t.index || (t.setIndex(new O(new Uint32Array(u), 1, !1)), f = !0), f || a) {
       let n = 0, x = 0;
       const m = t.getIndex();
-      for (let g = 0, c = s.length; g < c; g++) {
-        const p = s[g], v = p.getIndex();
-        if (!(!i && !u && o[g]))
+      for (let g = 0, c = o.length; g < c; g++) {
+        const p = o[g], v = p.getIndex();
+        if (!(!i && !f && s[g]))
           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 f = Object.keys(s[0].attributes);
-  for (let u = 0, n = f.length; u < n; u++) {
+  const h = Object.keys(o[0].attributes);
+  for (let f = 0, n = h.length; f < n; f++) {
     let x = !1;
-    const m = f[u];
+    const m = h[f];
     if (!t.getAttribute(m)) {
-      const p = s[0].getAttribute(m);
-      t.setAttribute(m, te(p, d)), x = !0;
+      const p = o[0].getAttribute(m);
+      t.setAttribute(m, re(p, d)), x = !0;
     }
     let g = 0;
     const c = t.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 || Tt(w, c, g), g += w.count;
+    for (let p = 0, v = o.length; p < v; p++) {
+      const b = o[p], y = !i && !x && s[p], w = b.getAttribute(m);
+      y || bt(w, c, g), g += w.count;
     }
   }
 }
-function yr(s, e, t) {
-  const r = s.index, o = s.attributes.position.count, a = r ? r.count : o;
-  let l = s.groups;
+function br(o, e, t) {
+  const r = o.index, s = o.attributes.position.count, a = r ? r.count : s;
+  let l = o.groups;
   l.length === 0 && (l = [{ count: a, start: 0, materialIndex: 0 }]);
-  let h = s.getAttribute("materialIndex");
-  if (!h || h.count !== o) {
-    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 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);
+  let u = o.getAttribute("materialIndex");
+  if (!u || u.count !== s) {
+    let h;
+    t.length <= 255 ? h = new Uint8Array(s) : h = new Uint16Array(s), u = new O(h, 1, !1), o.deleteAttribute("materialIndex"), o.setAttribute("materialIndex", u);
+  }
+  const d = u.array;
+  for (let h = 0; h < l.length; h++) {
+    const f = l[h], n = f.start, x = f.count, m = Math.min(x, a - n), g = Array.isArray(e) ? e[f.materialIndex] : e, c = t.indexOf(g);
     for (let p = 0; p < m; p++) {
       let v = n + p;
       r && (v = r.getX(v)), d[v] = c;
     }
   }
 }
-function Tr(s, e) {
-  if (!s.index) {
-    const t = s.attributes.position.count, r = new Array(t);
+function yr(o, e) {
+  if (!o.index) {
+    const t = o.attributes.position.count, r = new Array(t);
     for (let i = 0; i < t; i++)
       r[i] = i;
-    s.setIndex(r);
+    o.setIndex(r);
   }
-  if (!s.attributes.normal && e && e.includes("normal") && s.computeVertexNormals(), !s.attributes.uv && e && e.includes("uv")) {
-    const t = s.attributes.position.count;
-    s.setAttribute("uv", new P(new Float32Array(t * 2), 2, !1));
+  if (!o.attributes.normal && e && e.includes("normal") && o.computeVertexNormals(), !o.attributes.uv && e && e.includes("uv")) {
+    const t = o.attributes.position.count;
+    o.setAttribute("uv", new O(new Float32Array(t * 2), 2, !1));
   }
-  if (!s.attributes.uv2 && e && e.includes("uv2")) {
-    const t = s.attributes.position.count;
-    s.setAttribute("uv2", new P(new Float32Array(t * 2), 2, !1));
+  if (!o.attributes.uv2 && e && e.includes("uv2")) {
+    const t = o.attributes.position.count;
+    o.setAttribute("uv2", new O(new Float32Array(t * 2), 2, !1));
   }
-  if (!s.attributes.tangent && e && e.includes("tangent"))
-    if (s.attributes.uv && s.attributes.normal)
-      s.computeTangents();
+  if (!o.attributes.tangent && e && e.includes("tangent"))
+    if (o.attributes.uv && o.attributes.normal)
+      o.computeTangents();
     else {
-      const t = s.attributes.position.count;
-      s.setAttribute("tangent", new P(new Float32Array(t * 4), 4, !1));
+      const t = o.attributes.position.count;
+      o.setAttribute("tangent", new O(new Float32Array(t * 4), 4, !1));
     }
-  if (!s.attributes.color && e && e.includes("color")) {
-    const t = s.attributes.position.count, r = new Float32Array(t * 4);
-    r.fill(1), s.setAttribute("color", new P(r, 4));
+  if (!o.attributes.color && e && e.includes("color")) {
+    const t = o.attributes.position.count, r = new Float32Array(t * 4);
+    r.fill(1), o.setAttribute("color", new O(r, 4));
   }
 }
-function De(s) {
+function De(o) {
   let e = 0;
-  if (s.byteLength !== 0) {
-    const t = new Uint8Array(s);
-    for (let r = 0; r < s.byteLength; r++) {
+  if (o.byteLength !== 0) {
+    const t = new Uint8Array(o);
+    for (let r = 0; r < o.byteLength; r++) {
       const i = t[r];
       e = (e << 5) - e + i, e |= 0;
     }
   }
   return e;
 }
-function Ve(s) {
-  let e = s.uuid;
-  const t = Object.values(s.attributes);
-  s.index && (t.push(s.index), e += `index|${s.index.version}`);
+function Ue(o) {
+  let e = o.uuid;
+  const t = Object.values(o.attributes);
+  o.index && (t.push(o.index), e += `index|${o.index.version}`);
   const r = Object.keys(t).sort();
   for (const i of r) {
-    const o = t[i];
-    e += `${i}_${o.version}|`;
+    const s = t[i];
+    e += `${i}_${s.version}|`;
   }
   return e;
 }
-function Ge(s) {
-  const e = s.skeleton;
+function Ge(o) {
+  const e = o.skeleton;
   return e ? (e.boneTexture || e.computeBoneTexture(), `${De(e.boneTexture.image.data.buffer)}_${e.boneTexture.uuid}`) : null;
 }
-class wr {
+class Tr {
   constructor(e = null) {
-    this.matrixWorld = new O(), this.geometryHash = null, this.skeletonHash = null, this.primitiveCount = -1, e !== null && this.updateFrom(e);
+    this.matrixWorld = new z(), this.geometryHash = null, this.skeletonHash = null, this.primitiveCount = -1, e !== null && this.updateFrom(e);
   }
   updateFrom(e) {
     const t = e.geometry, r = (t.index ? t.index.count : t.attributes.position.count) / 3;
-    this.matrixWorld.copy(e.matrixWorld), this.geometryHash = Ve(t), this.primitiveCount = r, this.skeletonHash = Ge(e);
+    this.matrixWorld.copy(e.matrixWorld), this.geometryHash = Ue(t), this.primitiveCount = r, this.skeletonHash = Ge(e);
   }
   didChange(e) {
     const t = e.geometry, r = (t.index ? t.index.count : t.attributes.position.count) / 3;
-    return !(this.matrixWorld.equals(e.matrixWorld) && this.geometryHash === Ve(t) && this.skeletonHash === Ge(e) && this.primitiveCount === r);
+    return !(this.matrixWorld.equals(e.matrixWorld) && this.geometryHash === Ue(t) && this.skeletonHash === Ge(e) && this.primitiveCount === r);
   }
 }
-const L = /* @__PURE__ */ new F(), U = /* @__PURE__ */ new F(), V = /* @__PURE__ */ new F(), qe = /* @__PURE__ */ new K(), le = /* @__PURE__ */ new F(), Ie = /* @__PURE__ */ new F(), $e = /* @__PURE__ */ new K(), je = /* @__PURE__ */ new K(), ce = /* @__PURE__ */ new O(), Ye = /* @__PURE__ */ new O();
-function Xe(s, e, t) {
-  const r = s.skeleton, i = s.geometry, o = r.bones, a = r.boneInverses;
-  $e.fromBufferAttribute(i.attributes.skinIndex, e), je.fromBufferAttribute(i.attributes.skinWeight, e), ce.elements.fill(0);
+const G = /* @__PURE__ */ new P(), V = /* @__PURE__ */ new P(), q = /* @__PURE__ */ new P(), Ve = /* @__PURE__ */ new te(), ce = /* @__PURE__ */ new P(), Ie = /* @__PURE__ */ new P(), qe = /* @__PURE__ */ new te(), $e = /* @__PURE__ */ new te(), ue = /* @__PURE__ */ new z(), je = /* @__PURE__ */ new z();
+function Ye(o, e, t) {
+  const r = o.skeleton, i = o.geometry, s = r.bones, a = r.boneInverses;
+  qe.fromBufferAttribute(i.attributes.skinIndex, e), $e.fromBufferAttribute(i.attributes.skinWeight, e), ue.elements.fill(0);
   for (let l = 0; l < 4; l++) {
-    const h = je.getComponent(l);
-    if (h !== 0) {
-      const d = $e.getComponent(l);
-      Ye.multiplyMatrices(o[d].matrixWorld, a[d]), Ir(ce, Ye, h);
+    const u = $e.getComponent(l);
+    if (u !== 0) {
+      const d = qe.getComponent(l);
+      je.multiplyMatrices(s[d].matrixWorld, a[d]), wr(ue, je, u);
     }
   }
-  return ce.multiply(s.bindMatrix).premultiply(s.bindMatrixInverse), t.transformDirection(ce), t;
+  return ue.multiply(o.bindMatrix).premultiply(o.bindMatrixInverse), t.transformDirection(ue), t;
 }
-function Re(s, e, t, r, i) {
-  le.set(0, 0, 0);
-  for (let o = 0, a = s.length; o < a; o++) {
-    const l = e[o], h = s[o];
-    l !== 0 && (Ie.fromBufferAttribute(h, r), t ? le.addScaledVector(Ie, l) : le.addScaledVector(Ie.sub(i), l));
+function Re(o, e, t, r, i) {
+  ce.set(0, 0, 0);
+  for (let s = 0, a = o.length; s < a; s++) {
+    const l = e[s], u = o[s];
+    l !== 0 && (Ie.fromBufferAttribute(u, r), t ? ce.addScaledVector(Ie, l) : ce.addScaledVector(Ie.sub(i), l));
   }
-  i.add(le);
+  i.add(ce);
 }
-function Ir(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 wr(o, e, t) {
+  const r = o.elements, i = e.elements;
+  for (let s = 0, a = i.length; s < a; s++)
+    r[s] += i[s] * t;
 }
-function Rr(s) {
-  const { index: e, attributes: t } = s;
+function Ir(o) {
+  const { index: e, attributes: t } = o;
   if (e)
     for (let r = 0, i = e.count; r < i; r += 3) {
-      const o = e.getX(r), a = e.getX(r + 2);
-      e.setX(r, a), e.setX(r + 2, o);
+      const s = e.getX(r), a = e.getX(r + 2);
+      e.setX(r, a), e.setX(r + 2, s);
     }
   else
     for (const r in t) {
-      const i = t[r], o = i.itemSize;
+      const i = t[r], s = i.itemSize;
       for (let a = 0, l = i.count; a < l; a += 3)
-        for (let h = 0; h < o; h++) {
-          const d = i.getComponent(a, h), f = i.getComponent(a + 2, h);
-          i.setComponent(a, h, f), i.setComponent(a + 2, h, d);
+        for (let u = 0; u < s; u++) {
+          const d = i.getComponent(a, u), h = i.getComponent(a + 2, u);
+          i.setComponent(a, u, h), i.setComponent(a + 2, u, d);
         }
     }
-  return s;
+  return o;
 }
-function _r(s, e = {}, t = new q()) {
+function Rr(o, e = {}, t = new ee()) {
   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;
+  const r = o.geometry, i = e.applyWorldTransforms, s = e.attributes.includes("normal"), a = e.attributes.includes("tangent"), l = r.attributes, u = t.attributes;
   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)), Q(r.index, t.index), Q(l.position, h.position), o && Q(l.normal, h.normal), a && Q(l.tangent, h.tangent);
-  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 Pt();
-  p.getNormalMatrix(s.matrixWorld), r.index && t.index.array.set(r.index.array);
+  !t.index && r.index && (t.index = r.index.clone()), u.position || t.setAttribute("position", re(l.position)), s && !u.normal && l.normal && t.setAttribute("normal", re(l.normal)), a && !u.tangent && l.tangent && t.setAttribute("tangent", re(l.tangent)), J(r.index, t.index), J(l.position, u.position), s && J(l.normal, u.normal), a && J(l.tangent, u.tangent);
+  const d = l.position, h = s ? l.normal : null, f = a ? l.tangent : null, n = r.morphAttributes.position, x = r.morphAttributes.normal, m = r.morphAttributes.tangent, g = r.morphTargetsRelative, c = o.morphTargetInfluences, p = new Ct();
+  p.getNormalMatrix(o.matrixWorld), r.index && t.index.array.set(r.index.array);
   for (let v = 0, b = l.position.count; v < b; v++)
-    L.fromBufferAttribute(d, v), f && U.fromBufferAttribute(f, v), u && (qe.fromBufferAttribute(u, v), V.fromBufferAttribute(u, v)), c && (n && Re(n, c, g, v, L), x && Re(x, c, g, v, U), m && Re(m, c, g, v, V)), s.isSkinnedMesh && (s.applyBoneTransform(v, L), f && Xe(s, v, U), u && Xe(s, v, V)), i && L.applyMatrix4(s.matrixWorld), h.position.setXYZ(v, L.x, L.y, L.z), f && (i && U.applyNormalMatrix(p), h.normal.setXYZ(v, U.x, U.y, U.z)), u && (i && V.transformDirection(s.matrixWorld), h.tangent.setXYZW(v, V.x, V.y, V.z, qe.w));
+    G.fromBufferAttribute(d, v), h && V.fromBufferAttribute(h, v), f && (Ve.fromBufferAttribute(f, v), q.fromBufferAttribute(f, v)), c && (n && Re(n, c, g, v, G), x && Re(x, c, g, v, V), m && Re(m, c, g, v, q)), o.isSkinnedMesh && (o.applyBoneTransform(v, G), h && Ye(o, v, V), f && Ye(o, v, q)), i && G.applyMatrix4(o.matrixWorld), u.position.setXYZ(v, G.x, G.y, G.z), h && (i && V.applyNormalMatrix(p), u.normal.setXYZ(v, V.x, V.y, V.z)), f && (i && q.transformDirection(o.matrixWorld), u.tangent.setXYZW(v, q.x, q.y, q.z, Ve.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])), Q(l[b], h[b]), Tt(l[b], h[b]));
+    b === "position" || b === "tangent" || b === "normal" || !(b in l) || (u[b] || t.setAttribute(b, re(l[b])), J(l[b], u[b]), bt(l[b], u[b]));
   }
-  return s.matrixWorld.determinant() < 0 && Rr(t), t;
+  return o.matrixWorld.determinant() < 0 && Ir(t), t;
 }
-class Sr extends q {
+class _r extends ee {
   constructor() {
-    super(), this.version = 0, this.hash = null, this._diff = new wr();
+    super(), this.version = 0, this.hash = null, this._diff = new Tr();
   }
   // returns whether the passed mesh is compatible with this baked geometry
   // such that it can be updated without resizing attributes
   isCompatible(e, t) {
     const r = e.geometry;
     for (let i = 0; i < t.length; i++) {
-      const o = t[i], a = r.attributes[o], l = this.attributes[o];
-      if (a && !Q(a, l))
+      const s = t[i], a = r.attributes[s], l = this.attributes[s];
+      if (a && !J(a, l))
         return !1;
     }
     return !0;
   }
   updateFrom(e, t) {
     const r = this._diff;
-    return r.didChange(e) ? (_r(e, t, this), r.updateFrom(e), this.version++, this.hash = `${this.uuid}_${this.version}`, !0) : !1;
+    return r.didChange(e) ? (Rr(e, t, this), r.updateFrom(e), this.version++, this.hash = `${this.uuid}_${this.version}`, !0) : !1;
   }
 }
-const Ce = 0, wt = 1, It = 2;
-function Mr(s, e) {
-  for (let t = 0, r = s.length; t < r; t++)
-    s[t].traverseVisible((o) => {
-      o.isMesh && e(o);
+const Fe = 0, yt = 1, Tt = 2;
+function Sr(o, e) {
+  for (let t = 0, r = o.length; t < r; t++)
+    o[t].traverseVisible((s) => {
+      s.isMesh && e(s);
     });
 }
-function Ar(s) {
+function Mr(o) {
   const e = [];
-  for (let t = 0, r = s.length; t < r; t++) {
-    const i = s[t];
+  for (let t = 0, r = o.length; t < r; t++) {
+    const i = o[t];
     Array.isArray(i.material) ? e.push(...i.material) : e.push(i.material);
   }
   return e;
 }
-function Cr(s, e, t) {
-  if (s.length === 0) {
+function Ar(o, e, t) {
+  if (o.length === 0) {
     e.setIndex(null);
     const r = e.attributes;
     for (const i in r)
       e.deleteAttribute(i);
     for (const i in t.attributes)
-      e.setAttribute(t.attributes[i], new P(new Float32Array(0), 4, !1));
+      e.setAttribute(t.attributes[i], new O(new Float32Array(0), 4, !1));
   } else
-    br(s, t, e);
+    xr(o, t, e);
   for (const r in e.attributes)
     e.attributes[r].needsUpdate = !0;
 }
@@ -786,14 +787,14 @@ class Fr {
   }
   _getDummyMesh() {
     if (!this._dummyMesh) {
-      const e = new Et(), t = new q();
-      t.setAttribute("position", new P(new Float32Array(9), 3)), this._dummyMesh = new mt(t, e);
+      const e = new Dt(), t = new ee();
+      t.setAttribute("position", new O(new Float32Array(9), 3)), this._dummyMesh = new Pt(t, e);
     }
     return this._dummyMesh;
   }
   _getMeshes() {
     const e = [];
-    return Mr(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;
   }
@@ -802,68 +803,68 @@ class Fr {
       attributes: this.attributes,
       applyWorldTransforms: this.applyWorldTransforms
     };
-    for (let o = 0, a = t.length; o < a; o++) {
-      const l = t[o], h = l.uuid;
-      r.delete(h);
-      let d = e.get(h);
-      (!d || !d.isCompatible(l, this.attributes)) && (d && d.dispose(), d = new Sr(), e.set(h, d)), d.updateFrom(l, i) && this.generateMissingAttributes && Tr(d, this.attributes);
+    for (let s = 0, a = t.length; s < a; s++) {
+      const l = t[s], u = l.uuid;
+      r.delete(u);
+      let d = e.get(u);
+      (!d || !d.isCompatible(l, this.attributes)) && (d && d.dispose(), d = new _r(), e.set(u, d)), d.updateFrom(l, i) && this.generateMissingAttributes && yr(d, this.attributes);
     }
-    r.forEach((o) => {
-      e.delete(o);
+    r.forEach((s) => {
+      e.delete(s);
     });
   }
   setObjects(e) {
     Array.isArray(e) ? this.objects = [...e] : this.objects = [e];
   }
-  generate(e = new q()) {
-    const { useGroups: t, overwriteIndex: r, _intermediateGeometry: i, _geometryMergeSets: o } = this, a = this._getMeshes(), l = [], h = [], d = o.get(e) || [];
+  generate(e = new ee()) {
+    const { useGroups: t, overwriteIndex: r, _intermediateGeometry: i, _geometryMergeSets: s } = this, a = this._getMeshes(), l = [], u = [], d = s.get(e) || [];
     this._updateIntermediateGeometries();
-    let f = !1;
-    a.length !== d.length && (f = !0);
+    let h = !1;
+    a.length !== d.length && (h = !0);
     for (let n = 0, x = a.length; n < x; n++) {
       const m = a[n], g = i.get(m.uuid);
-      h.push(g);
+      u.push(g);
       const c = d[n];
-      !c || c.uuid !== g.uuid ? (l.push(!1), f = !0) : c.version !== g.version ? l.push(!1) : l.push(!0);
+      !c || c.uuid !== g.uuid ? (l.push(!1), h = !0) : c.version !== g.version ? l.push(!1) : l.push(!0);
     }
-    Cr(h, e, { useGroups: t, forceUpdate: f, skipAssigningAttributes: l, overwriteIndex: r }), f && e.dispose(), o.set(e, h.map((n) => ({
+    Ar(u, e, { useGroups: t, forceUpdate: h, skipAssigningAttributes: l, overwriteIndex: r }), h && e.dispose(), s.set(e, u.map((n) => ({
       version: n.version,
       uuid: n.uuid
     })));
-    let u = Ce;
-    return f ? u = It : l.includes(!1) && (u = wt), {
-      changeType: u,
-      materials: Ar(a),
+    let f = Fe;
+    return h ? f = Tt : l.includes(!1) && (f = yt), {
+      changeType: f,
+      materials: Mr(a),
       geometry: e
     };
   }
 }
-function Dr(s) {
+function Cr(o) {
   const e = /* @__PURE__ */ new Set();
-  for (let t = 0, r = s.length; t < r; t++) {
-    const i = s[t];
-    for (const o in i) {
-      const a = i[o];
+  for (let t = 0, r = o.length; t < r; t++) {
+    const i = o[t];
+    for (const s in i) {
+      const a = i[s];
       a && a.isTexture && e.add(a);
     }
   }
   return Array.from(e);
 }
-function Pr(s) {
+function Dr(o) {
   const e = [], t = /* @__PURE__ */ new Set();
-  for (let i = 0, o = s.length; i < o; i++)
-    s[i].traverse((a) => {
+  for (let i = 0, s = o.length; i < s; i++)
+    o[i].traverse((a) => {
       a.visible && (a.isRectAreaLight || a.isSpotLight || a.isPointLight || a.isDirectionalLight) && (e.push(a), a.iesMap && t.add(a.iesMap));
     });
-  const r = Array.from(t).sort((i, o) => i.uuid < o.uuid ? 1 : i.uuid > o.uuid ? -1 : 0);
+  const r = Array.from(t).sort((i, s) => i.uuid < s.uuid ? 1 : i.uuid > s.uuid ? -1 : 0);
   return { lights: e, iesTextures: r };
 }
-class Er {
+class Pr {
   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 q(), this.staticGeometryGenerator = new Fr(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 ee(), this.staticGeometryGenerator = new Fr(e), this._bvhWorker = null, this._pendingGenerate = null, this._buildAsync = !1;
   }
   setObjects(e) {
     this.staticGeometryGenerator.setObjects(e);
@@ -883,82 +884,39 @@ class Er {
     }
   }
   generate(e = null) {
-    const { staticGeometryGenerator: t, geometry: r, attributes: i } = this, o = t.objects;
-    t.attributes = i, o.forEach((u) => {
-      u.traverse((n) => {
+    const { staticGeometryGenerator: t, geometry: r, attributes: i } = this, s = t.objects;
+    t.attributes = i, s.forEach((f) => {
+      f.traverse((n) => {
         n.isSkinnedMesh && n.skeleton && n.skeleton.update();
       });
     });
-    const a = t.generate(r), l = a.materials, h = Dr(l), { lights: d, iesTextures: f } = Pr(o);
-    if (a.changeType !== Ce && yr(r, l, l), this.generateBVH) {
+    const a = t.generate(r), l = a.materials, u = Cr(l), { lights: d, iesTextures: h } = Dr(s);
+    if (a.changeType !== Fe && br(r, l, l), this.generateBVH) {
       if (this.bvh instanceof Promise)
         throw new Error("PathTracingSceneGenerator: BVH is already building asynchronously.");
-      if (a.changeType === It) {
-        const u = {
-          strategy: rr,
+      if (a.changeType === Tt) {
+        const f = {
+          strategy: er,
           maxLeafTris: 1,
           indirect: !0,
           onProgress: e,
           ...this.bvhOptions
         };
-        this._buildAsync ? this.bvh = this._bvhWorker.generate(r, u) : this.bvh = new ar(r, u);
-      } else a.changeType === wt && this.bvh.refit();
+        this._buildAsync ? this.bvh = this._bvhWorker.generate(r, f) : this.bvh = new tr(r, f);
+      } else a.changeType === yt && this.bvh.refit();
     }
     return {
-      bvhChanged: a.changeType !== Ce,
+      bvhChanged: a.changeType !== Fe,
       bvh: this.bvh,
       lights: d,
-      iesTextures: f,
+      iesTextures: h,
       geometry: r,
       materials: l,
-      textures: h,
-      objects: o
+      textures: u,
+      objects: s
     };
   }
 }
-const kr = new kt(-1, 1, 1, -1, 0, 1);
-class Or extends q {
-  constructor() {
-    super(), this.setAttribute("position", new We([-1, 3, 0, -1, -1, 0, 3, -1, 0], 3)), this.setAttribute("uv", new We([0, 2, 0, 0, 2, 0], 2));
-  }
-}
-const zr = new Or();
-class Z {
-  /**
-   * Constructs a new full screen quad.
-   *
-   * @param {?Material} material - The material to render te full screen quad with.
-   */
-  constructor(e) {
-    this._mesh = new mt(zr, e);
-  }
-  /**
-   * Frees the GPU-related resources allocated by this instance. Call this
-   * method whenever the instance is no longer used in your app.
-   */
-  dispose() {
-    this._mesh.geometry.dispose();
-  }
-  /**
-   * Renders the full screen quad.
-   *
-   * @param {WebGLRenderer} renderer - The renderer.
-   */
-  render(e) {
-    e.render(this._mesh, kr);
-  }
-  /**
-   * The quad's material.
-   *
-   * @type {?Material}
-   */
-  get material() {
-    return this._mesh.material;
-  }
-  set material(e) {
-    this._mesh.material = e;
-  }
-}
 class Pe extends ge {
   set needsUpdate(e) {
     super.needsUpdate = !0, this.dispatchEvent({
@@ -987,10 +945,10 @@ class Pe extends ge {
     return !1;
   }
 }
-class Nr extends Pe {
+class Er extends Pe {
   constructor(e) {
     super({
-      blending: ie,
+      blending: se,
       uniforms: {
         target1: { value: null },
         target2: { value: null },
@@ -1044,9 +1002,9 @@ class Nr extends Pe {
     }), this.setValues(e);
   }
 }
-function ue(s = 1) {
+function fe(o = 1) {
   let e = "uint";
-  return s > 1 && (e = "uvec" + s), /* glsl */
+  return o > 1 && (e = "uvec" + o), /* glsl */
   `
 		${e} sobolReverseBits( ${e} x ) {
 
@@ -1084,9 +1042,9 @@ function ue(s = 1) {
 		}
 	`;
 }
-function he(s = 1) {
-  let e = "uint", t = "float", r = "", i = ".r", o = "1u";
-  return s > 1 && (e = "uvec" + s, t = "vec" + s, r = s + "", s === 2 ? (i = ".rg", o = "uvec2( 1u, 2u )") : s === 3 ? (i = ".rgb", o = "uvec3( 1u, 2u, 3u )") : (i = "", o = "uvec4( 1u, 2u, 3u, 4u )")), /* glsl */
+function he(o = 1) {
+  let e = "uint", t = "float", r = "", i = ".r", s = "1u";
+  return o > 1 && (e = "uvec" + o, t = "vec" + o, r = o + "", o === 2 ? (i = ".rg", s = "uvec2( 1u, 2u )") : o === 3 ? (i = ".rgb", s = "uvec3( 1u, 2u, 3u )") : (i = "", s = "uvec4( 1u, 2u, 3u, 4u )")), /* glsl */
   `
 
 		${t} sobol${r}( int effect ) {
@@ -1099,7 +1057,7 @@ function he(s = 1) {
 			${t} sobol_pt = sobolGetTexturePoint( shuffled_index )${i};
 			${e} result = ${e}( sobol_pt * 16777216.0 );
 
-			${e} seed2 = sobolHashCombine( seed, ${o} );
+			${e} seed2 = sobolHashCombine( seed, ${s} );
 			result = nestedUniformScrambleBase2( result, seed2 );
 
 			return SOBOL_FACTOR * ${t}( result >> 8 );
@@ -1107,7 +1065,7 @@ function he(s = 1) {
 		}
 	`;
 }
-const Rt = (
+const wt = (
   /* glsl */
   `
 
@@ -1115,10 +1073,10 @@ const Rt = (
 	const float SOBOL_FACTOR = 1.0 / 16777216.0;
 	const uint SOBOL_MAX_POINTS = 256u * 256u;
 
-	${ue(1)}
-	${ue(2)}
-	${ue(3)}
-	${ue(4)}
+	${fe(1)}
+	${fe(2)}
+	${fe(3)}
+	${fe(4)}
 
 	uint sobolHash( uint x ) {
 
@@ -1133,7 +1091,7 @@ const Rt = (
 	}
 
 `
-), Hr = (
+), Or = (
   /* glsl */
   `
 
@@ -1214,7 +1172,7 @@ const Rt = (
 	}
 
 `
-), Br = (
+), kr = (
   /* glsl */
   `
 
@@ -1261,12 +1219,12 @@ const Rt = (
 
 `
 );
-class Wr extends Pe {
+class Nr extends Pe {
   constructor() {
     super({
-      blending: ie,
+      blending: se,
       uniforms: {
-        resolution: { value: new $() }
+        resolution: { value: new X() }
       },
       vertexShader: (
         /* glsl */
@@ -1285,8 +1243,8 @@ class Wr extends Pe {
         /* glsl */
         `
 
-				${Rt}
-				${Hr}
+				${wt}
+				${Or}
 
 				varying vec2 vUv;
 				uniform vec2 resolution;
@@ -1301,9 +1259,9 @@ class Wr extends Pe {
     });
   }
 }
-class Lr {
+class zr {
   generate(e, t = 256) {
-    const r = new ae(t, t, {
+    const r = new ie(t, t, {
       type: R,
       format: I,
       minFilter: T,
@@ -1311,11 +1269,11 @@ class Lr {
       generateMipmaps: !1
     }), i = e.getRenderTarget();
     e.setRenderTarget(r);
-    const o = new Z(new Wr());
-    return o.material.resolution.set(t, t), o.render(e), e.setRenderTarget(i), o.dispose(), r;
+    const s = new Y(new Nr());
+    return s.material.resolution.set(t, t), s.render(e), e.setRenderTarget(i), s.dispose(), r;
   }
 }
-class Ur extends pt {
+class Hr extends dt {
   set bokehSize(e) {
     this.fStop = this.getFocalLength() / e;
   }
@@ -1329,132 +1287,132 @@ class Ur extends pt {
     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 Vr {
+class Br {
   constructor() {
     this.bokehSize = 0, this.apertureBlades = 0, this.apertureRotation = 0, this.focusDistance = 10, this.anamorphicRatio = 1;
   }
   updateFrom(e) {
-    e instanceof Ur ? (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 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);
   }
 }
-function _e(s) {
-  const e = new Uint16Array(s.length);
-  for (let t = 0, r = s.length; t < r; ++t)
-    e[t] = k.toHalfFloat(s[t]);
+function _e(o) {
+  const e = new Uint16Array(o.length);
+  for (let t = 0, r = o.length; t < r; ++t)
+    e[t] = N.toHalfFloat(o[t]);
   return e;
 }
-function Qe(s, e, t = 0, r = s.length) {
-  let i = t, o = t + r - 1;
-  for (; i < o; ) {
-    const a = i + o >> 1;
-    s[a] < e ? i = a + 1 : o = a;
+function Xe(o, e, t = 0, r = o.length) {
+  let i = t, s = t + r - 1;
+  for (; i < s; ) {
+    const a = i + s >> 1;
+    o[a] < e ? i = a + 1 : s = a;
   }
   return i - t;
 }
-function Gr(s, e, t) {
-  return 0.2126 * s + 0.7152 * e + 0.0722 * t;
+function Wr(o, e, t) {
+  return 0.2126 * o + 0.7152 * e + 0.0722 * t;
 }
-function qr(s, e = D) {
-  const t = s.clone();
-  t.source = new Ot({ ...t.image });
-  const { width: r, height: i, data: o } = t.image;
-  let a = o;
+function Lr(o, e = E) {
+  const t = o.clone();
+  t.source = new Et({ ...t.image });
+  const { width: r, height: i, data: s } = t.image;
+  let a = s;
   if (t.type !== e) {
-    e === D ? a = new Uint16Array(o.length) : a = new Float32Array(o.length);
+    e === E ? a = new Uint16Array(s.length) : a = new Float32Array(s.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, 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));
+    s instanceof Int8Array || s instanceof Int16Array || s instanceof Int32Array ? l = 2 ** (8 * s.BYTES_PER_ELEMENT - 1) - 1 : l = 2 ** (8 * s.BYTES_PER_ELEMENT) - 1;
+    for (let u = 0, d = s.length; u < d; u++) {
+      let h = s[u];
+      t.type === E && (h = N.fromHalfFloat(s[u])), t.type !== R && t.type !== E && (h /= l), e === E && (a[u] = N.toHalfFloat(h));
     }
     t.image.data = a, t.type = e;
   }
   if (t.flipY) {
     const l = a;
     a = a.slice();
-    for (let h = 0; h < i; h++)
+    for (let u = 0; u < i; u++)
       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];
+        const h = i - u - 1, f = 4 * (u * r + d), n = 4 * (h * r + d);
+        a[n + 0] = l[f + 0], a[n + 1] = l[f + 1], a[n + 2] = l[f + 2], a[n + 3] = l[f + 3];
       }
     t.flipY = !1, t.image.data = a;
   }
   return t;
 }
-class $r {
+class Ur {
   constructor() {
-    const e = new M(_e(new Float32Array([0, 0, 0, 0])), 1, 1);
-    e.type = D, e.format = I, e.minFilter = C, e.magFilter = C, e.wrapS = z, e.wrapT = z, e.generateMipmaps = !1, e.needsUpdate = !0;
-    const t = new M(_e(new Float32Array([0, 1])), 1, 2);
-    t.type = D, t.format = me, t.minFilter = C, t.magFilter = C, t.generateMipmaps = !1, t.needsUpdate = !0;
-    const r = new M(_e(new Float32Array([0, 0, 1, 1])), 2, 2);
-    r.type = D, r.format = me, r.minFilter = C, r.magFilter = C, r.generateMipmaps = !1, r.needsUpdate = !0, this.map = e, this.marginalWeights = t, this.conditionalWeights = r, this.totalSum = 0;
+    const e = new F(_e(new Float32Array([0, 0, 0, 0])), 1, 1);
+    e.type = E, e.format = I, e.minFilter = D, e.magFilter = D, e.wrapS = H, e.wrapT = H, e.generateMipmaps = !1, e.needsUpdate = !0;
+    const t = new F(_e(new Float32Array([0, 1])), 1, 2);
+    t.type = E, t.format = pe, t.minFilter = D, t.magFilter = D, t.generateMipmaps = !1, t.needsUpdate = !0;
+    const r = new F(_e(new Float32Array([0, 0, 1, 1])), 2, 2);
+    r.type = E, r.format = pe, r.minFilter = D, r.magFilter = D, r.generateMipmaps = !1, r.needsUpdate = !0, this.map = e, this.marginalWeights = t, this.conditionalWeights = r, this.totalSum = 0;
   }
   dispose() {
     this.marginalWeights.dispose(), this.conditionalWeights.dispose(), this.map.dispose();
   }
   updateFrom(e) {
-    const t = qr(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), d = new Float32Array(i);
-    let f = 0, u = 0;
+    const t = Lr(e);
+    t.wrapS = H, t.wrapT = B;
+    const { width: r, height: i, data: s } = t.image, a = new Float32Array(r * i), l = new Float32Array(r * i), u = new Float32Array(i), d = new Float32Array(i);
+    let h = 0, f = 0;
     for (let c = 0; c < i; c++) {
       let p = 0;
       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 = Gr(y, w, E);
-        p += H, f += H, a[b] = H, l[b] = p;
+        const b = c * r + v, y = N.fromHalfFloat(s[4 * b + 0]), w = N.fromHalfFloat(s[4 * b + 1]), k = N.fromHalfFloat(s[4 * b + 2]), W = Wr(y, w, k);
+        p += W, h += W, a[b] = W, l[b] = p;
       }
       if (p !== 0)
         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;
+      f += p, u[c] = p, d[c] = f;
     }
-    if (u !== 0)
-      for (let c = 0, p = h.length; c < p; c++)
-        h[c] /= u, d[c] /= u;
+    if (f !== 0)
+      for (let c = 0, p = u.length; c < p; c++)
+        u[c] /= f, d[c] /= f;
     const n = new Uint16Array(i), x = new Uint16Array(r * i);
     for (let c = 0; c < i; c++) {
-      const p = (c + 1) / i, v = Qe(d, p);
-      n[c] = k.toHalfFloat((v + 0.5) / i);
+      const p = (c + 1) / i, v = Xe(d, p);
+      n[c] = N.toHalfFloat((v + 0.5) / i);
     }
     for (let c = 0; c < i; c++)
       for (let p = 0; p < r; p++) {
-        const v = c * r + p, b = (p + 1) / r, y = Qe(l, b, c * r, r);
-        x[v] = k.toHalfFloat((y + 0.5) / r);
+        const v = c * r + p, b = (p + 1) / r, y = Xe(l, b, c * r, r);
+        x[v] = N.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: x }, g.needsUpdate = !0, this.totalSum = f, 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 = h, this.map = t;
   }
 }
-const Se = 6, jr = 0, Yr = 1, Xr = 2, Qr = 3, Kr = 4, A = new F(), S = new F(), Ke = new O(), j = new zt(), Ze = new F(), Y = new F(), Zr = new F(0, 1, 0);
-class Jr {
+const Se = 6, Gr = 0, Vr = 1, qr = 2, $r = 3, jr = 4, C = new P(), A = new P(), Qe = new z(), Q = new Ot(), Ke = new P(), K = new P(), Yr = new P(0, 1, 0);
+class Xr {
   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;
+    const e = new F(new Float32Array(4), 1, 1);
+    e.format = I, e.type = R, e.wrapS = B, e.wrapT = B, e.generateMipmaps = !1, e.minFilter = T, e.magFilter = T, this.tex = e, this.count = 0;
   }
   updateFrom(e, t = []) {
-    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 r = this.tex, i = Math.max(e.length * Se, 1), s = Math.ceil(Math.sqrt(i));
+    r.image.width !== s && (r.dispose(), r.image.data = new Float32Array(s * s * 4), r.image.width = s, r.image.height = s);
     const a = r.image.data;
-    for (let h = 0, d = e.length; h < d; h++) {
-      const f = e[h], u = h * Se * 4;
+    for (let u = 0, d = e.length; u < d; u++) {
+      const h = e[u], f = u * Se * 4;
       let n = 0;
       for (let m = 0; m < Se * 4; m++)
-        a[u + m] = 0;
-      f.getWorldPosition(S), a[u + n++] = S.x, a[u + n++] = S.y, a[u + n++] = S.z;
-      let x = jr;
-      if (f.isRectAreaLight && f.isCircular ? x = Yr : f.isSpotLight ? x = Xr : f.isDirectionalLight ? x = Qr : f.isPointLight && (x = Kr), 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(j), f.isRectAreaLight)
-        A.set(f.width, 0, 0).applyQuaternion(j), a[u + n++] = A.x, a[u + n++] = A.y, a[u + n++] = A.z, n++, S.set(0, f.height, 0).applyQuaternion(j), a[u + n++] = S.x, a[u + n++] = S.y, a[u + n++] = S.z, a[u + n++] = A.cross(S).length() * (f.isCircular ? Math.PI / 4 : 1);
-      else if (f.isSpotLight) {
-        const m = f.radius || 0;
-        Ze.setFromMatrixPosition(f.matrixWorld), Y.setFromMatrixPosition(f.target.matrixWorld), Ke.lookAt(Ze, Y, Zr), j.setFromRotationMatrix(Ke), A.set(1, 0, 0).applyQuaternion(j), a[u + n++] = A.x, a[u + n++] = A.y, a[u + n++] = A.z, n++, S.set(0, 1, 0).applyQuaternion(j), a[u + n++] = S.x, a[u + n++] = S.y, a[u + n++] = S.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 = S.setFromMatrixPosition(f.target.matrixWorld);
-        Y.subVectors(m, g).normalize(), a[u + n++] = Y.x, a[u + n++] = Y.y, a[u + n++] = Y.z;
+        a[f + m] = 0;
+      h.getWorldPosition(A), a[f + n++] = A.x, a[f + n++] = A.y, a[f + n++] = A.z;
+      let x = Gr;
+      if (h.isRectAreaLight && h.isCircular ? x = Vr : h.isSpotLight ? x = qr : h.isDirectionalLight ? x = $r : h.isPointLight && (x = jr), a[f + n++] = x, a[f + n++] = h.color.r, a[f + n++] = h.color.g, a[f + n++] = h.color.b, a[f + n++] = h.intensity, h.getWorldQuaternion(Q), h.isRectAreaLight)
+        C.set(h.width, 0, 0).applyQuaternion(Q), a[f + n++] = C.x, a[f + n++] = C.y, a[f + n++] = C.z, n++, A.set(0, h.height, 0).applyQuaternion(Q), a[f + n++] = A.x, a[f + n++] = A.y, a[f + n++] = A.z, a[f + n++] = C.cross(A).length() * (h.isCircular ? Math.PI / 4 : 1);
+      else if (h.isSpotLight) {
+        const m = h.radius || 0;
+        Ke.setFromMatrixPosition(h.matrixWorld), K.setFromMatrixPosition(h.target.matrixWorld), Qe.lookAt(Ke, K, Yr), Q.setFromRotationMatrix(Qe), C.set(1, 0, 0).applyQuaternion(Q), a[f + n++] = C.x, a[f + n++] = C.y, a[f + n++] = C.z, n++, A.set(0, 1, 0).applyQuaternion(Q), a[f + n++] = A.x, a[f + n++] = A.y, a[f + n++] = A.z, a[f + n++] = Math.PI * m * m, a[f + n++] = m, a[f + n++] = h.decay, a[f + n++] = h.distance, a[f + n++] = Math.cos(h.angle), a[f + n++] = Math.cos(h.angle * (1 - h.penumbra)), a[f + n++] = h.iesMap ? t.indexOf(h.iesMap) : -1;
+      } else if (h.isPointLight) {
+        const m = C.setFromMatrixPosition(h.matrixWorld);
+        a[f + n++] = m.x, a[f + n++] = m.y, a[f + n++] = m.z, n++, n += 4, n += 1, a[f + n++] = h.decay, a[f + n++] = h.distance;
+      } else if (h.isDirectionalLight) {
+        const m = C.setFromMatrixPosition(h.matrixWorld), g = A.setFromMatrixPosition(h.target.matrixWorld);
+        K.subVectors(m, g).normalize(), a[f + n++] = K.x, a[f + n++] = K.y, a[f + n++] = K.z;
       }
     }
     this.count = e.length;
@@ -1462,12 +1420,12 @@ class Jr {
     return this.hash !== l ? (this.hash = l, r.needsUpdate = !0, !0) : !1;
   }
 }
-function Je(s, e, t, r, i) {
+function Ze(o, e, t, r, i) {
   if (e > r)
     throw new Error();
-  const o = s.length / e, a = s.constructor.BYTES_PER_ELEMENT * 8;
+  const s = o.length / e, a = o.constructor.BYTES_PER_ELEMENT * 8;
   let l = 1;
-  switch (s.constructor) {
+  switch (o.constructor) {
     case Uint8Array:
     case Uint16Array:
     case Uint32Array:
@@ -1479,52 +1437,52 @@ function Je(s, e, t, r, i) {
       l = 2 ** (a - 1) - 1;
       break;
   }
-  for (let h = 0; h < o; h++) {
-    const d = 4 * h, f = e * h;
-    for (let u = 0; u < r; u++)
-      t[i + d + u] = e >= u + 1 ? s[f + u] / l : 0;
+  for (let u = 0; u < s; u++) {
+    const d = 4 * u, h = e * u;
+    for (let f = 0; f < r; f++)
+      t[i + d + f] = e >= f + 1 ? o[h + f] / l : 0;
   }
 }
-class ea extends Nt {
+class Qr extends kt {
   constructor() {
     super(), this._textures = [], this.type = R, this.format = I, this.internalFormat = "RGBA32F";
   }
   updateAttribute(e, t) {
     const r = this._textures[e];
     r.updateFrom(t);
-    const i = r.image, o = this.image;
-    if (i.width !== o.width || i.height !== o.height)
+    const i = r.image, s = this.image;
+    if (i.width !== s.width || i.height !== s.height)
       throw new Error("FloatAttributeTextureArray: Attribute must be the same dimensions when updating single layer.");
-    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, f), this.dispose(), this.needsUpdate = !0;
+    const { width: a, height: l, data: u } = s, h = a * l * 4 * e;
+    let f = t.itemSize;
+    f === 3 && (f = 4), Ze(r.image.data, f, u, 4, h), this.dispose(), this.needsUpdate = !0;
   }
   setAttributes(e) {
     const t = e[0].count, r = e.length;
-    for (let u = 0, n = r; u < n; u++)
-      if (e[u].count !== t)
+    for (let f = 0, n = r; f < n; f++)
+      if (e[f].count !== t)
         throw new Error("FloatAttributeTextureArray: All attributes must have the same item count.");
     const i = this._textures;
     for (; i.length < r; ) {
-      const u = new yt();
-      i.push(u);
+      const f = new xt();
+      i.push(f);
     }
     for (; i.length > r; )
       i.pop();
-    for (let u = 0, n = r; u < n; u++)
-      i[u].updateFrom(e[u]);
+    for (let f = 0, n = r; f < n; f++)
+      i[f].updateFrom(e[f]);
     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: d, height: f } = l;
-    for (let u = 0, n = r; u < n; u++) {
-      const x = i[u], g = d * f * 4 * u;
-      let c = e[u].itemSize;
-      c === 3 && (c = 4), Je(x.image.data, c, h, 4, g);
+    const { data: u, width: d, height: h } = l;
+    for (let f = 0, n = r; f < n; f++) {
+      const x = i[f], g = d * h * 4 * f;
+      let c = e[f].itemSize;
+      c === 3 && (c = 4), Ze(x.image.data, c, u, 4, g);
     }
     this.dispose(), this.needsUpdate = !0;
   }
 }
-class ta extends ea {
+class Kr extends Qr {
   updateNormalAttribute(e) {
     this.updateAttribute(0, e);
   }
@@ -1541,44 +1499,44 @@ class ta extends ea {
     this.setAttributes([e, t, r, i]);
   }
 }
-function Ee(s, e) {
-  return s.uuid < e.uuid ? 1 : s.uuid > e.uuid ? -1 : 0;
+function Ee(o, e) {
+  return o.uuid < e.uuid ? 1 : o.uuid > e.uuid ? -1 : 0;
 }
-function Fe(s) {
-  return `${s.source.uuid}:${s.colorSpace}`;
+function Ce(o) {
+  return `${o.source.uuid}:${o.colorSpace}`;
 }
-function ra(s) {
+function Zr(o) {
   const e = /* @__PURE__ */ new Set(), t = [];
-  for (let r = 0, i = s.length; r < i; r++) {
-    const o = s[r], a = Fe(o);
-    e.has(a) || (e.add(a), t.push(o));
+  for (let r = 0, i = o.length; r < i; r++) {
+    const s = o[r], a = Ce(s);
+    e.has(a) || (e.add(a), t.push(s));
   }
   return t;
 }
-function aa(s) {
-  const e = s.map((r) => r.iesMap || null).filter((r) => r), t = new Set(e);
+function Jr(o) {
+  const e = o.map((r) => r.iesMap || null).filter((r) => r), t = new Set(e);
   return Array.from(t).sort(Ee);
 }
-function ia(s) {
+function ea(o) {
   const e = /* @__PURE__ */ new Set();
-  for (let r = 0, i = s.length; r < i; r++) {
-    const o = s[r];
-    for (const a in o) {
-      const l = o[a];
+  for (let r = 0, i = o.length; r < i; r++) {
+    const s = o[r];
+    for (const a in s) {
+      const l = s[a];
       l && l.isTexture && e.add(l);
     }
   }
   const t = Array.from(e);
-  return ra(t).sort(Ee);
+  return Zr(t).sort(Ee);
 }
-function sa(s) {
+function ta(o) {
   const e = [];
-  return s.traverse((t) => {
+  return o.traverse((t) => {
     t.visible && (t.isRectAreaLight || t.isSpotLight || t.isPointLight || t.isDirectionalLight) && e.push(t);
   }), e.sort(Ee);
 }
-const _t = 45, et = _t * 4;
-class oa {
+const It = 45, Je = It * 4;
+class ra {
   constructor() {
     this._features = {};
   }
@@ -1592,22 +1550,22 @@ class oa {
     this._features = {};
   }
 }
-class na extends M {
+class aa extends F {
   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 oa();
+    super(new Float32Array(4), 1, 1), this.format = I, this.type = R, this.wrapS = B, this.wrapT = B, this.minFilter = T, this.magFilter = T, this.generateMipmaps = !1, this.features = new ra();
   }
   updateFrom(e, t) {
     function r(m, g, c = -1) {
       if (g in m && m[g]) {
-        const p = Fe(m[g]);
-        return u[p];
+        const p = Ce(m[g]);
+        return f[p];
       } else
         return c;
     }
     function i(m, g, c) {
       return g in m ? m[g] : c;
     }
-    function o(m, g, c, p) {
+    function s(m, g, c, p) {
       const v = m[g] && m[g].isTexture ? m[g] : null;
       if (v) {
         v.matrixAutoUpdate && v.updateMatrix();
@@ -1618,19 +1576,19 @@ class na extends M {
       return 8;
     }
     let a = 0;
-    const l = e.length * _t, h = Math.ceil(Math.sqrt(l)) || 1, { image: d, features: f } = this, u = {};
+    const l = e.length * It, u = Math.ceil(Math.sqrt(l)) || 1, { image: d, features: h } = this, f = {};
     for (let m = 0, g = t.length; m < g; m++)
-      u[Fe(t[m])] = m;
-    d.width !== h && (this.dispose(), d.data = new Float32Array(h * h * 4), d.width = h, d.height = h);
+      f[Ce(t[m])] = m;
+    d.width !== u && (this.dispose(), d.data = new Float32Array(u * u * 4), d.width = u, d.height = u);
     const n = d.data;
-    f.reset();
+    h.reset();
     for (let m = 0, g = e.length; m < g; m++) {
       const c = e[m];
       if (c.isFogVolumeMaterial) {
-        f.setUsed("FOG");
-        for (let b = 0; b < et; b++)
+        h.setUsed("FOG");
+        for (let b = 0; b < Je; 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;
+        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 += Je;
         continue;
       }
       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);
@@ -1641,66 +1599,66 @@ class na extends M {
         n[a++] = 0;
       else
         switch (c.side) {
-          case Wt:
+          case Ht:
             n[a++] = 1;
             break;
-          case Bt:
+          case zt:
             n[a++] = -1;
             break;
-          case Ht:
+          case Nt:
             n[a++] = 0;
             break;
         }
-      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);
+      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 += s(c, "map", n, a), a += s(c, "metalnessMap", n, a), a += s(c, "roughnessMap", n, a), a += s(c, "transmissionMap", n, a), a += s(c, "emissiveMap", n, a), a += s(c, "normalMap", n, a), a += s(c, "clearcoatMap", n, a), a += s(c, "clearcoatNormalMap", n, a), a += s(c, "clearcoatRoughnessMap", n, a), a += s(c, "sheenColorMap", n, a), a += s(c, "sheenRoughnessMap", n, a), a += s(c, "iridescenceMap", n, a), a += s(c, "iridescenceThicknessMap", n, a), a += s(c, "specularColorMap", n, a), a += s(c, "specularIntensityMap", n, a);
     }
     const x = De(n.buffer);
     return this.hash !== x ? (this.hash = x, this.needsUpdate = !0, !0) : !1;
   }
 }
-const tt = new se();
-function la(s) {
-  return s ? `${s.uuid}:${s.version}` : null;
+const et = new oe();
+function ia(o) {
+  return o ? `${o.uuid}:${o.version}` : null;
 }
-function ca(s, e) {
+function sa(o, e) {
   for (const t in e)
-    t in s && (s[t] = e[t]);
+    t in o && (o[t] = e[t]);
 }
-class rt extends Lt {
+class tt extends Bt {
   constructor(e, t, r) {
     const i = {
       format: I,
       type: Me,
-      minFilter: C,
-      magFilter: C,
-      wrapS: z,
-      wrapT: z,
+      minFilter: D,
+      magFilter: D,
+      wrapS: H,
+      wrapT: H,
       generateMipmaps: !1,
       ...r
     };
-    super(e, t, 1, i), ca(this.texture, i), this.texture.setTextures = (...a) => {
+    super(e, t, 1, i), sa(this.texture, i), this.texture.setTextures = (...a) => {
       this.setTextures(...a);
     }, this.hashes = [null];
-    const o = new Z(new ua());
-    this.fsQuad = o;
+    const s = new Y(new oa());
+    this.fsQuad = s;
   }
   setTextures(e, t, r = this.width, i = this.height) {
-    const o = e.getRenderTarget(), a = e.toneMapping, l = e.getClearAlpha();
-    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 = Ut;
-    const d = this.fsQuad, f = this.hashes;
-    let u = !1;
-    for (let n = 0, x = h; n < x; n++) {
-      const m = t[n], g = la(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);
+    const s = e.getRenderTarget(), a = e.toneMapping, l = e.getClearAlpha();
+    e.getClearColor(et);
+    const u = t.length || 1;
+    (r !== this.width || i !== this.height || this.depth !== u) && (this.setSize(r, i, u), this.hashes = new Array(u).fill(null)), e.setClearColor(0, 0), e.toneMapping = Wt;
+    const d = this.fsQuad, h = this.hashes;
+    let f = !1;
+    for (let n = 0, x = u; n < x; n++) {
+      const m = t[n], g = ia(m);
+      m && (h[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, h[n] = g, f = !0);
     }
-    return d.material.map = null, e.setClearColor(tt, l), e.setRenderTarget(o), e.toneMapping = a, u;
+    return d.material.map = null, e.setClearColor(et, l), e.setRenderTarget(s), e.toneMapping = a, f;
   }
   dispose() {
     super.dispose(), this.fsQuad.dispose();
   }
 }
-class ua extends ge {
+class oa extends ge {
   get map() {
     return this.uniforms.map.value;
   }
@@ -1739,60 +1697,60 @@ class ua extends ge {
     });
   }
 }
-function ha(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;
+function na(o, e = Math.random()) {
+  for (let t = o.length - 1; t > 0; t--) {
+    const r = Math.floor(e() * (t + 1)), i = o[t];
+    o[t] = o[r], o[r] = i;
   }
-  return s;
+  return o;
 }
-class fa {
+class la {
   constructor(e, t, r = Math.random) {
-    const i = e ** t, o = new Uint16Array(i);
+    const i = e ** t, s = new Uint16Array(i);
     let a = i;
     for (let l = 0; l < i; l++)
-      o[l] = l;
+      s[l] = l;
     this.samples = new Float32Array(t), this.strataCount = e, this.reset = function() {
       for (let l = 0; l < i; l++)
-        o[l] = l;
+        s[l] = l;
       a = 0;
     }, this.reshuffle = function() {
       a = 0;
     }, this.next = function() {
       const { samples: l } = this;
-      a >= o.length && (ha(o, r), this.reshuffle());
-      let h = o[a++];
+      a >= s.length && (na(s, r), this.reshuffle());
+      let u = s[a++];
       for (let d = 0; d < t; d++)
-        l[d] = (h % e + r()) / e, h = Math.floor(h / e);
+        l[d] = (u % e + r()) / e, u = Math.floor(u / e);
       return l;
     };
   }
 }
-class da {
+class ca {
   constructor(e, t, r = Math.random) {
     let i = 0;
-    for (const h of t)
-      i += h;
-    const o = new Float32Array(i), a = [];
+    for (const u of t)
+      i += u;
+    const s = new Float32Array(i), a = [];
     let l = 0;
-    for (const h of t) {
-      const d = new fa(e, h, r);
-      d.samples = new Float32Array(o.buffer, l, d.samples.length), l += d.samples.length * 4, a.push(d);
+    for (const u of t) {
+      const d = new la(e, u, r);
+      d.samples = new Float32Array(s.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)
-        h.next();
-      return o;
+    this.samples = s, this.strataCount = e, this.next = function() {
+      for (const u of a)
+        u.next();
+      return s;
     }, this.reshuffle = function() {
-      for (const h of a)
-        h.reshuffle();
+      for (const u of a)
+        u.reshuffle();
     }, this.reset = function() {
-      for (const h of a)
-        h.reset();
+      for (const u of a)
+        u.reset();
     };
   }
 }
-class ma {
+class ua {
   constructor(e = 0) {
     this.m = 2147483648, this.a = 1103515245, this.c = 12345, this.seed = e;
   }
@@ -1803,15 +1761,15 @@ class ma {
     return this.nextInt() / (this.m - 1);
   }
 }
-class pa extends M {
+class fa extends F {
   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 ma(), 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 ua(), 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 da(r, o, this.random);
+    const s = new Array(e * t).fill(4), a = new ca(r, s, this.random);
     i.width = t, i.height = e, i.data = a.samples, this.sampler = a, this.dispose(), this.next();
   }
   next() {
@@ -1821,51 +1779,51 @@ class pa extends M {
     this.sampler.reset(), this.generator.seed = 0;
   }
 }
-function ga(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 ha(o, e = Math.random) {
+  for (let t = o.length - 1; t > 0; t--) {
+    const r = ~~((e() - 1e-6) * t), i = o[t];
+    o[t] = o[r], o[r] = i;
   }
 }
-function va(s, e) {
-  s.fill(0);
+function da(o, e) {
+  o.fill(0);
   for (let t = 0; t < e; t++)
-    s[t] = 1;
+    o[t] = 1;
 }
-class at {
+class rt {
   constructor(e) {
     this.count = 0, this.size = -1, this.sigma = -1, this.radius = -1, this.lookupTable = null, this.score = null, this.binaryPattern = null, this.resize(e), this.setSigma(1.5);
   }
   findVoid() {
     const { score: e, binaryPattern: t } = this;
     let r = 1 / 0, i = -1;
-    for (let o = 0, a = t.length; o < a; o++) {
-      if (t[o] !== 0)
+    for (let s = 0, a = t.length; s < a; s++) {
+      if (t[s] !== 0)
         continue;
-      const l = e[o];
-      l < r && (r = l, i = o);
+      const l = e[s];
+      l < r && (r = l, i = s);
     }
     return i;
   }
   findCluster() {
     const { score: e, binaryPattern: t } = this;
     let r = -1 / 0, i = -1;
-    for (let o = 0, a = t.length; o < a; o++) {
-      if (t[o] !== 1)
+    for (let s = 0, a = t.length; s < a; s++) {
+      if (t[s] !== 1)
         continue;
-      const l = e[o];
-      l > r && (r = l, i = o);
+      const l = e[s];
+      l > r && (r = l, i = s);
     }
     return i;
   }
   setSigma(e) {
     if (e === this.sigma)
       return;
-    const t = ~~(Math.sqrt(20 * e ** 2) + 1), r = 2 * t + 1, i = new Float32Array(r * r), o = e * e;
+    const t = ~~(Math.sqrt(20 * e ** 2) + 1), r = 2 * t + 1, i = new Float32Array(r * r), s = e * e;
     for (let a = -t; a <= t; a++)
       for (let l = -t; l <= t; l++) {
-        const h = (t + l) * r + a + t, d = a * a + l * l;
-        i[h] = Math.E ** (-d / (2 * o));
+        const u = (t + l) * r + a + t, d = a * a + l * l;
+        i[u] = Math.E ** (-d / (2 * s));
       }
     this.lookupTable = i, this.sigma = e, this.radius = t;
   }
@@ -1875,7 +1833,7 @@ class at {
   invert() {
     const { binaryPattern: e, score: t, size: r } = this;
     t.fill(0);
-    for (let i = 0, o = e.length; i < o; i++)
+    for (let i = 0, s = e.length; i < s; i++)
       if (e[i] === 0) {
         const a = ~~(i / r), l = i - a * r;
         this.updateScore(l, a, 1), e[i] = 1;
@@ -1883,16 +1841,16 @@ class at {
         e[i] = 0;
   }
   updateScore(e, t, r) {
-    const { size: i, score: o, lookupTable: a } = this, l = this.radius, h = 2 * l + 1;
+    const { size: i, score: s, lookupTable: a } = this, l = this.radius, u = 2 * l + 1;
     for (let d = -l; d <= l; d++)
-      for (let f = -l; f <= l; f++) {
-        const u = (l + f) * h + d + l, n = a[u];
+      for (let h = -l; h <= l; h++) {
+        const f = (l + h) * u + d + l, n = a[f];
         let x = e + d;
         x = x < 0 ? i + x : x % i;
-        let m = t + f;
+        let m = t + h;
         m = m < 0 ? i + m : m % i;
         const g = m * i + x;
-        o[g] += r * n;
+        s[g] += r * n;
       }
   }
   addPointIndex(e) {
@@ -1909,9 +1867,9 @@ 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 xa {
+class ma {
   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);
+    this.random = Math.random, this.sigma = 1.5, this.size = 64, this.majorityPointsRatio = 0.1, this.samples = new rt(1), this.savedSamples = new rt(1);
   }
   generate() {
     const {
@@ -1919,76 +1877,76 @@ class xa {
       savedSamples: t,
       sigma: r,
       majorityPointsRatio: i,
-      size: o
+      size: s
     } = this;
-    e.resize(o), e.setSigma(r);
-    const a = Math.floor(o * o * i), l = e.binaryPattern;
-    va(l, a), ga(l, this.random);
-    for (let u = 0, n = l.length; u < n; u++)
-      l[u] === 1 && e.addPointIndex(u);
+    e.resize(s), e.setSigma(r);
+    const a = Math.floor(s * s * i), l = e.binaryPattern;
+    da(l, a), ha(l, this.random);
+    for (let f = 0, n = l.length; f < n; f++)
+      l[f] === 1 && e.addPointIndex(f);
     for (; ; ) {
-      const u = e.findCluster();
-      e.removePointIndex(u);
+      const f = e.findCluster();
+      e.removePointIndex(f);
       const n = e.findVoid();
-      if (u === n) {
-        e.addPointIndex(u);
+      if (f === n) {
+        e.addPointIndex(f);
         break;
       }
       e.addPointIndex(n);
     }
-    const h = new Uint32Array(o * o);
+    const u = new Uint32Array(s * s);
     t.copy(e);
     let d;
     for (d = e.count - 1; d >= 0; ) {
-      const u = e.findCluster();
-      e.removePointIndex(u), h[u] = d, d--;
+      const f = e.findCluster();
+      e.removePointIndex(f), u[f] = d, d--;
     }
-    const f = o * o;
-    for (d = t.count; d < f / 2; ) {
-      const u = t.findVoid();
-      t.addPointIndex(u), h[u] = d, d++;
+    const h = s * s;
+    for (d = t.count; d < h / 2; ) {
+      const f = t.findVoid();
+      t.addPointIndex(f), u[f] = d, d++;
     }
-    for (t.invert(); d < f; ) {
-      const u = t.findCluster();
-      t.removePointIndex(u), h[u] = d, d++;
+    for (t.invert(); d < h; ) {
+      const f = t.findCluster();
+      t.removePointIndex(f), u[f] = d, d++;
     }
-    return { data: h, maxValue: f };
+    return { data: u, maxValue: h };
   }
 }
-function ba(s) {
-  return s >= 3 ? 4 : s;
+function pa(o) {
+  return o >= 3 ? 4 : o;
 }
-function ya(s) {
-  switch (s) {
+function ga(o) {
+  switch (o) {
     case 1:
-      return me;
+      return pe;
     case 2:
-      return dt;
+      return ht;
     default:
       return I;
   }
 }
-class Ta extends M {
+class va extends F {
   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 xa();
+    const e = this.channels, t = this.size, r = new ma();
     r.channels = e, r.size = t;
-    const i = ba(e), o = ya(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 i = pa(e), s = ga(i);
+    (this.image.width !== t || s !== this.format) && (this.image.width = t, this.image.height = t, this.image.data = new Float32Array(t ** 2 * i), this.format = s, this.dispose());
     const a = this.image.data;
-    for (let l = 0, h = e; l < h; l++) {
-      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;
+    for (let l = 0, u = e; l < u; l++) {
+      const d = r.generate(), h = d.data, f = d.maxValue;
+      for (let n = 0, x = h.length; n < x; n++) {
+        const m = h[n] / f;
         a[n * i + l] = m;
       }
     }
     this.needsUpdate = !0;
   }
 }
-const wa = (
+const xa = (
   /* glsl */
   `
 
@@ -2003,7 +1961,7 @@ const wa = (
 	};
 
 `
-), Ia = (
+), ba = (
   /* glsl */
   `
 
@@ -2018,7 +1976,7 @@ const wa = (
 	};
 
 `
-), Ra = (
+), ya = (
   /* glsl */
   `
 
@@ -2107,7 +2065,7 @@ const wa = (
 	}
 
 `
-), _a = (
+), Ta = (
   /* glsl */
   `
 
@@ -2317,7 +2275,7 @@ const wa = (
 	}
 
 `
-), Sa = (
+), wa = (
   /* glsl */
   `
 
@@ -2382,7 +2340,7 @@ const wa = (
 	};
 
 `
-), Ma = (
+), Ia = (
   /* glsl */
   `
 
@@ -2452,7 +2410,7 @@ const wa = (
 
 	}
 `
-), Aa = (
+), Ra = (
   /* glsl */
   `
 
@@ -2670,7 +2628,7 @@ const wa = (
 	}
 
 `
-), Ca = (
+), _a = (
   /* glsl */
   `
 
@@ -2758,7 +2716,7 @@ const wa = (
 
 
 `
-), Fa = (
+), Sa = (
   /* glsl */
   `
 
@@ -2864,7 +2822,7 @@ const wa = (
 	}
 
 `
-), Da = (
+), Ma = (
   /* glsl */
   `
 
@@ -2947,7 +2905,7 @@ const wa = (
 	}
 
 `
-), Pa = (
+), Aa = (
   /* glsl */
   `
 
@@ -3011,7 +2969,7 @@ const wa = (
 	}
 
 `
-), Ea = (
+), Fa = (
   /*glsl */
   `
 
@@ -3037,7 +2995,7 @@ const wa = (
 	}
 
 `
-), St = (
+), Rt = (
   /* glsl */
   `
 
@@ -3155,7 +3113,7 @@ const wa = (
 
 	}
 `
-), it = (
+), at = (
   /* glsl */
   `
 
@@ -3214,7 +3172,7 @@ const wa = (
 
 	}
 `
-), ka = (
+), Ca = (
   /* glsl */
   `
 
@@ -3266,7 +3224,7 @@ const wa = (
 	}
 
 `
-), Oa = (
+), Da = (
   /* glsl */
   `
 
@@ -3707,7 +3665,7 @@ const wa = (
 	}
 
 `
-), za = (
+), Pa = (
   /* glsl */
   `
 
@@ -3731,7 +3689,7 @@ const wa = (
 	}
 
 `
-), Na = (
+), Ea = (
   /* glsl */
   `
 
@@ -3835,7 +3793,7 @@ const wa = (
 	}
 
 `
-), Ha = (
+), Oa = (
   /* glsl */
   `
 
@@ -3972,7 +3930,7 @@ const wa = (
 	}
 
 `
-), Ba = (
+), ka = (
   /* glsl */
   `
 
@@ -4072,7 +4030,7 @@ const wa = (
 	}
 
 `
-), Wa = (
+), Na = (
   /* glsl */
   `
 
@@ -4136,7 +4094,7 @@ bool bvhIntersectFogVolumeHit(
 }
 
 `
-), La = (
+), za = (
   /* glsl */
   `
 
@@ -4316,7 +4274,7 @@ bool bvhIntersectFogVolumeHit(
 	}
 
 `
-), Ua = (
+), Ha = (
   /* glsl */
   `
 
@@ -4402,7 +4360,7 @@ bool bvhIntersectFogVolumeHit(
 	}
 
 `
-), Va = (
+), Ba = (
   /*glsl*/
   `
 
@@ -4501,7 +4459,7 @@ bool bvhIntersectFogVolumeHit(
 	}
 
 `
-), Ga = (
+), Wa = (
   /* glsl */
   `
 
@@ -4826,7 +4784,7 @@ bool bvhIntersectFogVolumeHit(
 
 	}
 `
-), qa = (
+), La = (
   /* glsl */
   `
 
@@ -4878,7 +4836,7 @@ bool bvhIntersectFogVolumeHit(
 	}
 
 `
-), $a = (
+), Ua = (
   /* glsl */
   `
 
@@ -4929,7 +4887,7 @@ bool bvhIntersectFogVolumeHit(
 
 `
 );
-class ja extends Pe {
+class Ga extends Pe {
   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);
   }
@@ -4959,42 +4917,42 @@ class ja extends Pe {
       },
       uniforms: {
         // path trace uniforms
-        resolution: { value: new $() },
+        resolution: { value: new X() },
         opacity: { value: 1 },
         bounces: { value: 10 },
         transmissiveBounces: { value: 10 },
         filterGlossyFactor: { value: 0 },
         // camera uniforms
-        physicalCamera: { value: new Vr() },
-        cameraWorldMatrix: { value: new O() },
-        invProjectionMatrix: { value: new O() },
+        physicalCamera: { value: new Br() },
+        cameraWorldMatrix: { value: new z() },
+        invProjectionMatrix: { value: new z() },
         // scene uniforms
-        bvh: { value: new cr() },
-        attributesArray: { value: new ta() },
-        materialIndexAttribute: { value: new bt() },
-        materials: { value: new na() },
-        textures: { value: new rt().texture },
+        bvh: { value: new lr() },
+        attributesArray: { value: new Kr() },
+        materialIndexAttribute: { value: new vt() },
+        materials: { value: new aa() },
+        textures: { value: new tt().texture },
         // light uniforms
-        lights: { value: new Jr() },
-        iesProfiles: { value: new rt(360, 180, {
-          type: D,
-          wrapS: N,
-          wrapT: N
+        lights: { value: new Xr() },
+        iesProfiles: { value: new tt(360, 180, {
+          type: E,
+          wrapS: B,
+          wrapT: B
         }).texture },
         environmentIntensity: { value: 1 },
-        environmentRotation: { value: new O() },
-        envMapInfo: { value: new $r() },
+        environmentRotation: { value: new z() },
+        envMapInfo: { value: new Ur() },
         // background uniforms
         backgroundBlur: { value: 0 },
         backgroundMap: { value: null },
         backgroundAlpha: { value: 1 },
         backgroundIntensity: { value: 1 },
-        backgroundRotation: { value: new O() },
+        backgroundRotation: { value: new z() },
         // randomness uniforms
         seed: { value: 0 },
         sobolTexture: { value: null },
-        stratifiedTexture: { value: new pa() },
-        stratifiedOffsetTexture: { value: new Ta(64, 1) }
+        stratifiedTexture: { value: new fa() },
+        stratifiedOffsetTexture: { value: new va(64, 1) }
       },
       vertexShader: (
         /* glsl */
@@ -5027,26 +4985,26 @@ class ja extends Pe {
 
 				// bvh intersection
 				${fr}
-				${mr}
 				${dr}
+				${hr}
 
 				// uniform structs
+				${xa}
+				${ya}
+				${ba}
+				${Ta}
 				${wa}
-				${Ra}
-				${Ia}
-				${_a}
-				${Sa}
 
 				// random
 				#if RANDOM_TYPE == 2 	// Stratified List
 
-					${ka}
+					${Ca}
 
 				#elif RANDOM_TYPE == 1 	// Sobol
 
-					${it}
-					${Rt}
-					${Br}
+					${at}
+					${wt}
+					${kr}
 
 					#define rand(v) sobol(v)
 					#define rand2(v) sobol2(v)
@@ -5055,7 +5013,7 @@ class ja extends Pe {
 
 				#else 					// PCG
 
-				${it}
+				${at}
 
 					// Using the sobol functions seems to break the the compiler on MacOS
 					// - specifically the "sobolReverseBits" function.
@@ -5071,11 +5029,11 @@ class ja extends Pe {
 				#endif
 
 				// common
-				${Ea}
 				${Fa}
-				${St}
-				${Da}
-				${Pa}
+				${Sa}
+				${Rt}
+				${Ma}
+				${Aa}
 
 				// environment
 				uniform EquirectHdrInfo envMapInfo;
@@ -5131,16 +5089,16 @@ class ja extends Pe {
 				float lightsDenom;
 
 				// sampling
-				${Ca}
-				${Ma}
-				${Aa}
+				${_a}
+				${Ia}
+				${Ra}
 
-				${Wa}
 				${Na}
-				${Ba}
-				${Ha}
-				${za}
+				${Ea}
+				${ka}
 				${Oa}
+				${Pa}
+				${Da}
 
 				float applyFilteredGlossy( float roughness, float accumulatedRoughness ) {
 
@@ -5172,12 +5130,12 @@ class ja extends Pe {
 
 				}
 
-				${qa}
-				${Ua}
-				${$a}
 				${La}
-				${Va}
-				${Ga}
+				${Ha}
+				${Ua}
+				${za}
+				${Ba}
+				${Wa}
 
 				void main() {
 
@@ -5474,51 +5432,51 @@ class ja extends Pe {
     }), this.setValues(e);
   }
 }
-function* Ya() {
+function* Va() {
   const {
-    _renderer: s,
+    _renderer: o,
     _fsQuad: e,
     _blendQuad: t,
     _primaryTarget: r,
     _blendTargets: i,
-    _sobolTarget: o,
+    _sobolTarget: s,
     _subframe: a,
     alpha: l,
-    material: h
-  } = this, d = new K(), f = new K(), u = t.material;
+    material: u
+  } = this, d = new te(), h = new te(), f = 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 = gt);
+    l ? (f.opacity = this._opacityFactor / (this.samples + 1), u.blending = se, u.opacity = 1) : (u.opacity = this._opacityFactor / (this.samples + 1), u.blending = mt);
     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), ve = Math.ceil(b * p), ke = Math.floor(m * v), Oe = Math.floor(g * b), xe = Math.ceil(H / y), be = Math.ceil(ve / w);
-    for (let oe = 0; oe < w; oe++)
-      for (let ne = 0; ne < y; ne++) {
-        const ze = s.getRenderTarget(), Mt = s.autoClear, At = s.getScissorTest();
-        s.getScissor(d), s.getViewport(f);
-        let ye = ne, Ne = oe;
+    u.resolution.set(v * c, b * p), u.sobolTexture = s.texture, u.stratifiedTexture.init(20, u.bounces + u.transmissiveBounces + 5), u.stratifiedTexture.next(), u.seed++;
+    const y = this.tiles.x || 1, w = this.tiles.y || 1, k = y * w, W = Math.ceil(v * c), ve = Math.ceil(b * p), Oe = Math.floor(m * v), ke = Math.floor(g * b), xe = Math.ceil(W / y), be = Math.ceil(ve / w);
+    for (let ne = 0; ne < w; ne++)
+      for (let le = 0; le < y; le++) {
+        const Ne = o.getRenderTarget(), _t = o.autoClear, St = o.getScissorTest();
+        o.getScissor(d), o.getViewport(h);
+        let ye = le, ze = ne;
         if (!this.stableTiles) {
           const Te = this._currentTile % (y * w);
-          ye = Te % y, Ne = ~~(Te / y), this._currentTile = Te + 1;
+          ye = Te % y, ze = ~~(Te / y), this._currentTile = Te + 1;
         }
-        const He = w - Ne - 1;
+        const He = w - ze - 1;
         r.scissor.set(
-          ke + ye * xe,
-          Oe + He * be,
-          Math.min(xe, H - ye * xe),
+          Oe + ye * xe,
+          ke + He * be,
+          Math.min(xe, W - ye * xe),
           Math.min(be, ve - He * be)
         ), r.viewport.set(
-          ke,
           Oe,
-          H,
+          ke,
+          W,
           ve
-        ), s.setRenderTarget(r), s.setScissorTest(!0), s.autoClear = !1, e.render(s), s.setViewport(f), s.setScissor(d), s.setScissorTest(At), s.setRenderTarget(ze), s.autoClear = Mt, l && (u.target1 = n.texture, u.target2 = r.texture, s.setRenderTarget(x), t.render(s), s.setRenderTarget(ze)), this.samples += 1 / E, ne === y - 1 && oe === w - 1 && (this.samples = Math.round(this.samples)), yield;
+        ), o.setRenderTarget(r), o.setScissorTest(!0), o.autoClear = !1, e.render(o), o.setViewport(h), o.setScissor(d), o.setScissorTest(St), o.setRenderTarget(Ne), o.autoClear = _t, l && (f.target1 = n.texture, f.target2 = r.texture, o.setRenderTarget(x), t.render(o), o.setRenderTarget(Ne)), this.samples += 1 / k, le === y - 1 && ne === w - 1 && (this.samples = Math.round(this.samples)), yield;
       }
     [n, x] = [x, n];
   }
 }
-const st = new se();
-class ot {
+const it = new oe();
+class st {
   get material() {
     return this._fsQuad.material;
   }
@@ -5538,19 +5496,19 @@ class ot {
     return !!this._compilePromise;
   }
   constructor(e) {
-    this.camera = null, this.tiles = new $(3, 3), this.stableNoise = !1, this.stableTiles = !0, this.samples = 0, this._subframe = new K(0, 0, 1, 1), this._opacityFactor = 1, this._renderer = e, this._alpha = !1, this._fsQuad = new Z(new ja()), this._blendQuad = new Z(new Nr()), this._task = null, this._currentTile = 0, this._compilePromise = null, this._sobolTarget = new Lr().generate(e), this._primaryTarget = new ae(1, 1, {
+    this.camera = null, this.tiles = new X(3, 3), this.stableNoise = !1, this.stableTiles = !0, this.samples = 0, this._subframe = new te(0, 0, 1, 1), this._opacityFactor = 1, this._renderer = e, this._alpha = !1, this._fsQuad = new Y(new Ga()), this._blendQuad = new Y(new Er()), this._task = null, this._currentTile = 0, this._compilePromise = null, this._sobolTarget = new zr().generate(e), this._primaryTarget = new ie(1, 1, {
       format: I,
       type: R,
       magFilter: T,
       minFilter: T
     }), this._blendTargets = [
-      new ae(1, 1, {
+      new ie(1, 1, {
         format: I,
         type: R,
         magFilter: T,
         minFilter: T
       }),
-      new ae(1, 1, {
+      new ie(1, 1, {
         format: I,
         type: R,
         magFilter: T,
@@ -5582,15 +5540,15 @@ class ot {
     this._primaryTarget.dispose(), this._blendTargets[0].dispose(), this._blendTargets[1].dispose(), this._sobolTarget.dispose(), this._fsQuad.dispose(), this._blendQuad.dispose(), this._task = null;
   }
   reset() {
-    const { _renderer: e, _primaryTarget: t, _blendTargets: r } = this, i = e.getRenderTarget(), o = e.getClearAlpha();
-    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());
+    const { _renderer: e, _primaryTarget: t, _blendTargets: r } = this, i = e.getRenderTarget(), s = e.getClearAlpha();
+    e.getClearColor(it), 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(it, s), 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 = Ya.call(this)), this._task.next());
+    this.material.onBeforeRender(), !this.isCompiling && (this._task || (this._task = Va.call(this)), this._task.next());
   }
 }
-const G = new $(), nt = new $(), fe = new Vt(), de = new se();
-class Xa extends M {
+const $ = new X(), ot = new X(), de = new Lt(), me = new oe();
+class qa extends F {
   constructor(e = 512, t = 512) {
     super(
       new Float32Array(e * t * 4),
@@ -5598,41 +5556,41 @@ class Xa extends M {
       t,
       I,
       R,
-      vt,
-      z,
-      N,
-      C,
-      C
+      pt,
+      H,
+      B,
+      D,
+      D
     ), this.generationCallback = null;
   }
   update() {
     this.dispose(), this.needsUpdate = !0;
     const { data: e, width: t, height: r } = this.image;
     for (let i = 0; i < t; i++)
-      for (let o = 0; o < r; o++) {
-        nt.set(t, r), G.set(i / t, o / r), G.x -= 0.5, G.y = 1 - G.y, fe.theta = G.x * 2 * Math.PI, fe.phi = G.y * Math.PI, fe.radius = 1, this.generationCallback(fe, G, nt, de);
-        const l = 4 * (o * t + i);
-        e[l + 0] = de.r, e[l + 1] = de.g, e[l + 2] = de.b, e[l + 3] = 1;
+      for (let s = 0; s < r; s++) {
+        ot.set(t, r), $.set(i / t, s / r), $.x -= 0.5, $.y = 1 - $.y, de.theta = $.x * 2 * Math.PI, de.phi = $.y * Math.PI, de.radius = 1, this.generationCallback(de, $, ot, me);
+        const l = 4 * (s * t + i);
+        e[l + 0] = me.r, e[l + 1] = me.g, e[l + 2] = me.b, e[l + 3] = 1;
       }
   }
   copy(e) {
     return super.copy(e), this.generationCallback = e.generationCallback, this;
   }
 }
-const lt = new F();
-class Qa extends Xa {
+const nt = new P();
+class $a extends qa {
   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);
-      const a = lt.y * 0.5 + 0.5;
-      o.lerpColors(this.bottomColor, this.topColor, a ** this.exponent);
+    super(e, e), this.topColor = new oe().set(16777215), this.bottomColor = new oe().set(0), this.exponent = 2, this.generationCallback = (t, r, i, s) => {
+      nt.setFromSpherical(t);
+      const a = nt.y * 0.5 + 0.5;
+      s.lerpColors(this.bottomColor, this.topColor, a ** this.exponent);
     };
   }
   copy(e) {
     return super.copy(e), this.topColor.copy(e.topColor), this.bottomColor.copy(e.bottomColor), this;
   }
 }
-class Ka extends ge {
+class ja extends ge {
   get map() {
     return this.uniforms.map.value;
   }
@@ -5719,7 +5677,7 @@ class Ka extends ge {
     }), this.setValues(e);
   }
 }
-class Za extends ge {
+class Ya extends ge {
   constructor() {
     super({
       uniforms: {
@@ -5749,7 +5707,7 @@ class Za extends ge {
 				#include <common>
 				#include <cube_uv_reflection_fragment>
 
-				${St}
+				${Rt}
 
 				void main() {
 
@@ -5762,38 +5720,38 @@ class Za extends ge {
     }), this.depthWrite = !1, this.depthTest = !1;
   }
 }
-class ct {
+class lt {
   constructor(e) {
-    this._renderer = e, this._quad = new Z(new Za());
+    this._renderer = e, this._quad = new Y(new Ya());
   }
   generate(e, t = null, r = null) {
     if (!e.isCubeTexture)
       throw new Error("CubeToEquirectMaterial: Source can only be cube textures.");
-    const i = e.images[0], o = this._renderer, a = this._quad;
+    const i = e.images[0], s = this._renderer, a = this._quad;
     t === null && (t = 4 * i.height), r === null && (r = 2 * i.height);
-    const l = new ae(t, r, {
+    const l = new ie(t, r, {
       type: R,
       colorSpace: i.colorSpace
-    }), 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;
+    }), u = i.height, d = Math.log2(u) - 2, h = 1 / u, f = 1 / (3 * Math.max(Math.pow(2, d), 112));
+    a.material.defines.CUBEUV_MAX_MIP = `${d}.0`, a.material.defines.CUBEUV_TEXEL_WIDTH = f, a.material.defines.CUBEUV_TEXEL_HEIGHT = h, a.material.uniforms.envMap.value = e, a.material.uniforms.flipEnvMap.value = e.isRenderTargetTexture ? 1 : -1, a.material.needsUpdate = !0;
+    const n = s.getRenderTarget(), x = s.autoClear;
+    s.autoClear = !0, s.setRenderTarget(l), a.render(s), s.setRenderTarget(n), s.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();
+    s.readRenderTargetPixels(l, 0, 0, t, r, g), l.dispose();
     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 = Gt, c.magFilter = C, c.wrapS = z, c.wrapT = z, c.mapping = vt, c.needsUpdate = !0, c;
+      m[p] = N.toHalfFloat(g[p]);
+    const c = new F(m, t, r, I, E);
+    return c.minFilter = Ut, c.magFilter = D, c.wrapS = H, c.wrapT = H, c.mapping = pt, c.needsUpdate = !0, c;
   }
   dispose() {
     this._quad.dispose();
   }
 }
-function Ja(s) {
-  return s.extensions.get("EXT_float_blend");
+function Xa(o) {
+  return o.extensions.get("EXT_float_blend");
 }
-const X = new $();
-class ei {
+const Z = new X();
+class Qa {
   get multipleImportanceSampling() {
     return !!this._pathTracer.material.defines.FEATURE_MIS;
   }
@@ -5837,17 +5795,17 @@ class ei {
     return !!this._pathTracer.isCompiling;
   }
   constructor(e) {
-    this._renderer = e, this._generator = new Er(), this._pathTracer = new ot(e), this._queueReset = !1, this._clock = new qt(), this._compilePromise = null, this._lowResPathTracer = new ot(e), this._lowResPathTracer.tiles.set(1, 1), this._quad = new Z(new Ka({
+    this._renderer = e, this._generator = new Pr(), this._pathTracer = new st(e), this._queueReset = !1, this._clock = new Gt(), this._compilePromise = null, this._lowResPathTracer = new st(e), this._lowResPathTracer.tiles.set(1, 1), this._quad = new Y(new ja({
       map: null,
       transparent: !0,
-      blending: ie,
+      blending: se,
       premultipliedAlpha: e.getContextAttributes().premultipliedAlpha
-    })), this._materials = null, this._previousEnvironment = null, this._previousBackground = null, this._internalBackground = null, this.renderDelay = 100, this.minSamples = 5, this.fadeDuration = 500, this.enablePathTracing = !0, this.pausePathTracing = !1, this.dynamicLowRes = !1, this.lowResScale = 0.25, this.renderScale = 1, this.synchronizeRenderSize = !0, this.rasterizeScene = !0, this.renderToCanvas = !0, this.textureSize = new $(1024, 1024), this.rasterizeSceneCallback = (t, r) => {
+    })), this._materials = null, this._previousEnvironment = null, this._previousBackground = null, this._internalBackground = null, this.renderDelay = 100, this.minSamples = 5, this.fadeDuration = 500, this.enablePathTracing = !0, this.pausePathTracing = !1, this.dynamicLowRes = !1, this.lowResScale = 0.25, this.renderScale = 1, this.synchronizeRenderSize = !0, this.rasterizeScene = !0, this.renderToCanvas = !0, this.textureSize = new X(1024, 1024), this.rasterizeSceneCallback = (t, r) => {
       this._renderer.render(t, r);
     }, this.renderToCanvasCallback = (t, r, i) => {
-      const o = r.autoClear;
-      r.autoClear = !1, i.render(r), r.autoClear = o;
-    }, this.setScene(new $t(), new pt());
+      const s = r.autoClear;
+      r.autoClear = !1, i.render(r), r.autoClear = s;
+    }, this.setScene(new Vt(), new dt());
   }
   setBVHWorker(e) {
     this._generator.setBVHWorker(e);
@@ -5856,10 +5814,10 @@ class ei {
     e.updateMatrixWorld(!0), t.updateMatrixWorld();
     const i = this._generator;
     if (i.setObjects(e), this._buildAsync)
-      return i.generateAsync(r.onProgress).then((o) => this._updateFromResults(e, t, o));
+      return i.generateAsync(r.onProgress).then((s) => this._updateFromResults(e, t, s));
     {
-      const o = i.generate();
-      return this._updateFromResults(e, t, o);
+      const s = i.generate();
+      return this._updateFromResults(e, t, s);
     }
   }
   setSceneAsync(...e) {
@@ -5875,24 +5833,24 @@ class ei {
     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 = ia(r);
-    e.textures.setTextures(t, o, i.x, i.y), e.materials.updateFrom(r, o), this.reset();
+    const e = this._pathTracer.material, t = this._renderer, r = this._materials, i = this.textureSize, s = ea(r);
+    e.textures.setTextures(t, s, i.x, i.y), e.materials.updateFrom(r, s), this.reset();
   }
   updateLights() {
-    const e = this.scene, t = this._renderer, r = this._pathTracer.material, i = sa(e), o = aa(i);
-    r.lights.updateFrom(i, o), r.iesProfiles.setTextures(t, o), this.reset();
+    const e = this.scene, t = this._renderer, r = this._pathTracer.material, i = ta(e), s = Jr(i);
+    r.lights.updateFrom(i, s), r.iesProfiles.setTextures(t, s), this.reset();
   }
   updateEnvironment() {
     const e = this.scene, t = this._pathTracer.material;
     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 Qa(16);
+      this._colorBackground = this._colorBackground || new $a(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) {
       if (e.background !== this._previousBackground) {
-        const r = new ct(this._renderer).generate(e.background);
+        const r = new lt(this._renderer).generate(e.background);
         this._internalBackground = r, t.backgroundMap = r, t.backgroundAlpha = 1;
       }
     } else
@@ -5900,7 +5858,7 @@ class ei {
     if (t.environmentIntensity = e.environmentIntensity ?? 1, t.environmentRotation.makeRotationFromEuler(e.environmentRotation).invert(), this._previousEnvironment !== e.environment)
       if (e.environment !== null)
         if (e.environment.isCubeTexture) {
-          const r = new ct(this._renderer).generate(e.environment);
+          const r = new lt(this._renderer).generate(e.environment);
           t.envMapInfo.updateFrom(r);
         } else
           t.envMapInfo.updateFrom(e.environment);
@@ -5911,34 +5869,34 @@ class ei {
   _updateFromResults(e, t, r) {
     const {
       materials: i,
-      geometry: o,
+      geometry: s,
       bvh: a,
       bvhChanged: l
     } = r;
     this._materials = i;
     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
-    ), d.materialIndexAttribute.updateFrom(o.attributes.materialIndex)), this._previousScene = e, this.scene = e, this.camera = t, this.updateCamera(), this.updateMaterials(), this.updateEnvironment(), this.updateLights(), r;
+      s.attributes.normal,
+      s.attributes.tangent,
+      s.attributes.uv,
+      s.attributes.color
+    ), d.materialIndexAttribute.updateFrom(s.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 e = this._lowResPathTracer, t = this._pathTracer, r = this._renderer, i = this._clock, s = this._quad;
+    this._updateScale(), this._queueReset && (t.reset(), e.reset(), this._queueReset = !1, s.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 || !Ja(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.pausePathTracing && this.enablePathTracing && this.renderDelay <= l && !this.isCompiling && t.update(), t.alpha = t.material.backgroundAlpha !== 1 || !Xa(r), e.alpha = t.alpha, this.renderToCanvas) {
+      const u = this._renderer, d = this.minSamples;
+      if (l >= this.renderDelay && this.samples >= this.minSamples && (this.fadeDuration !== 0 ? s.material.opacity = Math.min(s.material.opacity + a / this.fadeDuration, 1) : s.material.opacity = 1), !this.enablePathTracing || this.samples < d || s.material.opacity < 1) {
         if (this.dynamicLowRes && !this.isCompiling) {
           e.samples < 1 && (e.material = t.material, e.update());
-          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;
+          const h = s.material.opacity;
+          s.material.opacity = 1 - s.material.opacity, s.material.map = e.target.texture, s.render(u), s.material.opacity = h;
         }
         (!this.dynamicLowRes && this.rasterizeScene || this.dynamicLowRes && this.isCompiling) && this.rasterizeSceneCallback(this.scene, this.camera);
       }
-      this.enablePathTracing && o.material.opacity > 0 && (o.material.opacity < 1 && (o.material.blending = this.dynamicLowRes ? jt : gt), o.material.map = t.target.texture, this.renderToCanvasCallback(t.target, h, o), o.material.blending = ie);
+      this.enablePathTracing && s.material.opacity > 0 && (s.material.opacity < 1 && (s.material.blending = this.dynamicLowRes ? qt : mt), s.material.map = t.target.texture, this.renderToCanvasCallback(t.target, u, s), s.material.blending = se);
     }
   }
   reset() {
@@ -5949,30 +5907,30 @@ class ei {
   }
   _updateScale() {
     if (this.synchronizeRenderSize) {
-      this._renderer.getDrawingBufferSize(X);
-      const e = Math.floor(this.renderScale * X.x), t = Math.floor(this.renderScale * X.y);
-      if (this._pathTracer.getSize(X), X.x !== e || X.y !== t) {
+      this._renderer.getDrawingBufferSize(Z);
+      const e = Math.floor(this.renderScale * Z.x), t = Math.floor(this.renderScale * Z.y);
+      if (this._pathTracer.getSize(Z), Z.x !== e || Z.y !== t) {
         const r = this.lowResScale;
         this._pathTracer.setSize(e, t), this._lowResPathTracer.setSize(Math.floor(e * r), Math.floor(t * r));
       }
     }
   }
 }
-function ut(s) {
-  return typeof s == "object" && s !== null && "getInternalRenderer" in s && typeof s.getInternalRenderer == "function";
+function ct(o) {
+  return typeof o == "object" && o !== null && "getInternalRenderer" in o && typeof o.getInternalRenderer == "function";
 }
-function ee(s) {
-  return s !== null && typeof s == "object" && "getInternalRenderer" in s && typeof s.getInternalRenderer == "function";
+function j(o) {
+  return o !== null && typeof o == "object" && "getInternalRenderer" in o && typeof o.getInternalRenderer == "function";
 }
-const pe = class pe {
+const M = class M {
   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.convertedEnvTexture = null, this.resumable = !1, this.lastCameraMoveTime = -1 / 0, this.cameraDirty = !1, this.events = new ir(), this.settings = {
-      samples: sr,
+    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.convertedEnvTexture = null, this.resumable = !1, this.lastCameraMoveTime = -1 / 0, this.cameraDirty = !1, this.events = new rr(), this.rasterFadeTarget = null, this.fadeQuad = null, this.fadeToneMapping = null, this.fadeSupported = !0, this.settings = {
+      samples: ar,
       bounces: 4,
       // Reduce bounces for better performance
       transmissiveBounces: 2,
       // Reduce transmissive bounces
-      renderScale: 0.5,
+      renderScale: 1,
       // Start with lower resolution for better performance
       lowResScale: 0.5,
       dynamicLowRes: !0,
@@ -5980,24 +5938,28 @@ const pe = class pe {
     };
   }
   /**
-   * 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.
+   * Hand the scene to the path tracer with the raster-only contact-shadow
+   * helpers hidden and the tracer-only ground floor shown. The `ShadowMaterial`
+   * catcher (and the baked disc) are raster shadow-map tricks the tracer can't
+   * use — ingesting them double-darkens or floats the contact area — so they're
+   * hidden; the PATH_TRACING_FLOOR_FLAG disc is the mirror image, a real matte
+   * surface kept invisible in the raster view and flipped on only here so the
+   * tracer has something physical to cast a contact shadow onto (otherwise the
+   * model floats in the traced render). The generator only reads currently-
+   * visible nodes, and both sets are restored right after the ingest so the
+   * raster fallback keeps its clean invisible-floor look.
    */
   ingestSceneWithoutShadowHelpers(e, t) {
-    var i;
-    const r = [];
-    e.traverse((o) => {
-      var a;
-      (a = o.userData) != null && a[or] && o.visible && r.push(o);
-    }), r.forEach((o) => o.visible = !1);
+    var s;
+    const r = [], i = [];
+    e.traverse((a) => {
+      var l, u;
+      (l = a.userData) != null && l[ir] && a.visible ? r.push(a) : (u = a.userData) != null && u[sr] && !a.visible && i.push(a);
+    }), r.forEach((a) => a.visible = !1), i.forEach((a) => a.visible = !0);
     try {
-      (i = this.pathTracer) == null || i.setScene(e, t);
+      (s = this.pathTracer) == null || s.setScene(e, t);
     } finally {
-      r.forEach((o) => o.visible = !0);
+      r.forEach((a) => a.visible = !0), i.forEach((a) => a.visible = !1);
     }
   }
   /**
@@ -6012,32 +5974,32 @@ const pe = class pe {
     if (!i)
       return null;
     i.drawImage(t, 0, 0);
-    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 J.DataTexture(
+    const s = i.getImageData(0, 0, r.width, r.height), a = new Float32Array(s.data.length);
+    for (let u = 0; u < s.data.length; u++)
+      a[u] = s.data[u] / 255;
+    const l = new _.DataTexture(
       a,
       r.width,
       r.height,
-      J.RGBAFormat,
-      J.FloatType
+      _.RGBAFormat,
+      _.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;
   }
   async initialize(e) {
     try {
-      return this.renderer = e.renderer, this.enabled = e.enabled, this.isSupported() ? _.ok(void 0) : _.err(
-        new B(
+      return this.renderer = e.renderer, this.enabled = e.enabled, this.isSupported() ? S.ok(void 0) : S.err(
+        new L(
           "Path tracing is not supported in this environment",
-          W.PATH_TRACING_INIT_FAILED,
+          U.PATH_TRACING_INIT_FAILED,
           { reason: "WebGL2 or required extensions not available" }
         )
       );
     } catch (t) {
-      return _.err(
-        new B(
+      return S.err(
+        new L(
           "Failed to initialize path tracing",
-          W.PATH_TRACING_INIT_FAILED,
+          U.PATH_TRACING_INIT_FAILED,
           { originalError: t }
         )
       );
@@ -6045,25 +6007,25 @@ const pe = class pe {
   }
   createPathTracer() {
     if (this.disposed)
-      return _.err(
-        new B(
+      return S.err(
+        new L(
           "Instance is disposed",
-          W.INVALID_STATE
+          U.INVALID_STATE
         )
       );
     try {
-      const e = ee(this.renderer) ? this.renderer.getInternalRenderer() : null;
-      return e ? (this.pathTracer = new ei(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, e.setRenderTarget(null), _.ok(void 0)) : _.err(
-        new B(
+      const e = j(this.renderer) ? this.renderer.getInternalRenderer() : null;
+      return e ? (this.pathTracer = new Qa(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, e.setRenderTarget(null), S.ok(void 0)) : S.err(
+        new L(
           "Renderer not ready, will retry",
-          W.RENDERER_NOT_INITIALIZED
+          U.RENDERER_NOT_INITIALIZED
         )
       );
     } catch (e) {
-      return _.err(
-        new B(
+      return S.err(
+        new L(
           "Failed to create path tracer",
-          W.PATH_TRACING_INIT_FAILED,
+          U.PATH_TRACING_INIT_FAILED,
           { originalError: e }
         )
       );
@@ -6072,7 +6034,7 @@ const pe = class pe {
   setEnabled(e) {
     if (this.enabled !== e && (this.enabled = e, !e)) {
       this.resumable = !1, this.reset(), this.sceneInitialized = !1;
-      const t = ee(this.renderer) ? this.renderer.getInternalRenderer() : null;
+      const t = j(this.renderer) ? this.renderer.getInternalRenderer() : null;
       t && (t.autoClear = !0);
     }
   }
@@ -6093,10 +6055,10 @@ const pe = class pe {
   }
   async render(e, t) {
     if (this.disposed)
-      return _.ok(void 0);
+      return S.ok(void 0);
     const r = this.renderer;
     if (!r)
-      return _.ok(void 0);
+      return S.ok(void 0);
     if (!this.enabled)
       return this.renderWhileDisabled(e, t);
     if (!this.pathTracer) {
@@ -6107,19 +6069,19 @@ const pe = class pe {
     try {
       const i = this.extractThreeObjects(e, t);
       if (!i)
-        return _.err(
-          new B(
+        return S.err(
+          new L(
             "Could not extract Three.js scene or camera",
-            W.INVALID_PARAMETER
+            U.INVALID_PARAMETER
           )
         );
-      const { threeScene: o, threeCamera: a } = i;
+      const { threeScene: s, threeCamera: a } = i;
       if (!this.sceneInitialized) {
         const l = await this.initializeSceneForPathTracing(
           r,
           e,
           t,
-          o,
+          s,
           a
         );
         if (l)
@@ -6127,10 +6089,10 @@ const pe = class pe {
       }
       return this.sceneInitialized ? this.accumulateSample(r, e, t) : r.render(e, t);
     } catch (i) {
-      return _.err(
-        new B(
+      return S.err(
+        new L(
           "Failed to render with path tracing",
-          W.RENDER_FAILED,
+          U.RENDER_FAILED,
           { originalError: i }
         )
       );
@@ -6144,15 +6106,15 @@ const pe = class pe {
    * while still waiting for the renderer, or after giving up and disabling.
    */
   ensurePathTracerCreated(e, t, r) {
-    var o;
+    var s;
     this.createAttempts++;
     const i = this.createPathTracer();
-    return i.ok ? (this.createAttempts = 0, null) : (this.createAttempts < this.maxCreateAttempts && ((o = i.error) == null ? void 0 : o.message) === "Renderer not ready, will retry" || (this.disableAfterSelfPause("gave-up"), this.createAttempts = 0), e.render(t, r));
+    return i.ok ? (this.createAttempts = 0, null) : (this.createAttempts < this.maxCreateAttempts && ((s = i.error) == null ? void 0 : s.message) === "Renderer not ready, will retry" || (this.disableAfterSelfPause("gave-up"), this.createAttempts = 0), e.render(t, r));
   }
   /** Unwraps the Three.js scene/camera from their adapters, or null if either fails. */
   extractThreeObjects(e, t) {
     let r = null, i = null;
-    return ut(e) && (r = e.getInternalRenderer()), ut(t) && (i = t.getInternalRenderer()), !r || !i ? null : { threeScene: r, threeCamera: i };
+    return ct(e) && (r = e.getInternalRenderer()), ct(t) && (i = t.getInternalRenderer()), !r || !i ? null : { threeScene: r, threeCamera: i };
   }
   /**
    * First-frame setup: waits for an environment texture, converts an
@@ -6162,47 +6124,47 @@ const pe = class pe {
    * Result when render() should return it immediately instead — still
    * waiting, or the environment shape isn't one the tracer can use.
    */
-  async initializeSceneForPathTracing(e, t, r, i, o) {
+  async initializeSceneForPathTracing(e, t, r, i, s) {
     var a;
     try {
       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, l && l.isCubeTexture) {
-        const h = i.environment;
+        const u = i.environment;
         i.environment = l;
         try {
-          this.ingestSceneWithoutShadowHelpers(i, o), this.sceneInitialized = !0;
+          this.ingestSceneWithoutShadowHelpers(i, s), this.sceneInitialized = !0;
         } finally {
-          i.environment = h;
+          i.environment = u;
         }
-      } else if (l && l.mapping === J.EquirectangularReflectionMapping) {
-        let h = l;
+      } else if (l && l.mapping === _.EquirectangularReflectionMapping) {
+        let u = l;
         if (l.image instanceof HTMLImageElement)
           if (this.convertedEnvTexture)
-            h = this.convertedEnvTexture;
+            u = this.convertedEnvTexture;
           else {
-            const f = this.convertToDataTexture(l);
-            if (!f)
+            const h = this.convertToDataTexture(l);
+            if (!h)
               throw new Error("Failed to convert environment texture to DataTexture");
-            this.convertedEnvTexture = f, h = f;
+            this.convertedEnvTexture = h, u = h;
           }
         const d = i.environment;
-        i.environment = h;
+        i.environment = u;
         try {
-          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;
+          const h = l.image;
+          h && !("data" in h && h.data) && h instanceof HTMLImageElement && !h.complete && await new Promise((f) => {
+            h.onload = () => {
+              l.needsUpdate = !0, f();
+            }, h.onerror = () => {
+              f();
+            }, h.complete && f();
+          }), this.ingestSceneWithoutShadowHelpers(i, s), this.sceneInitialized = !0, i.environment = d;
+        } catch (h) {
+          throw i.environment = d, h;
         }
-      } else if (((a = i.environment) == null ? void 0 : a.mapping) === J.EquirectangularReflectionMapping)
-        this.ingestSceneWithoutShadowHelpers(i, o), this.sceneInitialized = !0;
+      } else if (((a = i.environment) == null ? void 0 : a.mapping) === _.EquirectangularReflectionMapping)
+        this.ingestSceneWithoutShadowHelpers(i, s), this.sceneInitialized = !0;
       else
         return this.disableAfterSelfPause("gave-up"), e.render(t, r);
     } catch (l) {
@@ -6216,29 +6178,140 @@ const pe = class pe {
    * feedback, accumulates a tracer sample, and detects completion.
    */
   accumulateSample(e, t, r) {
-    var o, a;
+    var s, a;
     if (this.sampleCount === 0)
       try {
-        (o = this.pathTracer) == null || o.updateLights();
+        (s = this.pathTracer) == null || s.updateLights();
       } catch (l) {
         console.warn("Failed to update lights for path tracing:", l);
       }
     const i = e.render(t, r);
-    return i.ok ? performance.now() - this.lastCameraMoveTime < pe.CAMERA_SETTLE_MS ? _.ok(void 0) : (this.cameraDirty && (this.cameraDirty = !1, (a = this.pathTracer) == null || a.updateCamera()), this.accumulateOneSample(), this.sampleCount++, this.sampleCount === this.settings.samples ? this.captureCompletedFrame() : _.ok(void 0)) : i;
+    if (!i.ok)
+      return i;
+    if (performance.now() - this.lastCameraMoveTime < M.CAMERA_SETTLE_MS)
+      return S.ok(void 0);
+    if (this.cameraDirty && (this.cameraDirty = !1, (a = this.pathTracer) == null || a.updateCamera()), this.fadeSupported && this.sampleCount === 0 && this.runFadeStep(() => this.captureRasterFade(e, t, r)), this.accumulateOneSample(), this.sampleCount++, this.fadeSupported && this.sampleCount < M.FADE_SAMPLES) {
+      const l = 1 - this.pathTracedLayerOpacity(this.sampleCount);
+      this.runFadeStep(() => this.renderRasterFade(l));
+    }
+    return this.sampleCount === this.settings.samples ? this.captureCompletedFrame() : S.ok(void 0);
+  }
+  /** Run a cosmetic dissolve step, disabling the dissolve for the rest of the
+   * session if it throws — it must never take the render down with it. */
+  runFadeStep(e) {
+    try {
+      e();
+    } catch (t) {
+      console.warn("Path-tracing startup dissolve unavailable; showing samples directly:", t), this.fadeSupported = !1;
+    }
+  }
+  /** Opacity of the path-traced layer over the raster snapshot as accumulation
+   * progresses: 0 for the opening (noisiest) samples, eased up to a low preview
+   * cap while the image is still grainy — so the tracer's noise never reads
+   * above the cap — then released to fully opaque as it resolves. */
+  pathTracedLayerOpacity(e) {
+    const t = M.FADE_HOLD_SAMPLES, r = M.FADE_SAMPLES, i = M.FADE_PREVIEW_OPACITY, s = t + (r - t) * M.FADE_RELEASE_FRACTION;
+    return e < s ? i * M.smoothstep(t, s, e) : i + (1 - i) * M.smoothstep(s, r, e);
+  }
+  static smoothstep(e, t, r) {
+    const i = Math.min(1, Math.max(0, (r - e) / (t - e)));
+    return i * i * (3 - 2 * i);
+  }
+  /** Render the current raster frame into a linear offscreen target to fade out
+   * over the resolving path-traced image. It is captured pre-tone-mapping
+   * (three only tone-maps when drawing to the canvas, never to a target), so the
+   * fade shader applies the renderer's tone mapping + sRGB itself and the
+   * snapshot matches the frame on screen instead of coming out dark. */
+  captureRasterFade(e, t, r) {
+    const i = j(this.renderer) ? this.renderer.getInternalRenderer() : null;
+    if (!i)
+      return;
+    const s = i.getDrawingBufferSize(new _.Vector2());
+    this.rasterFadeTarget ? (this.rasterFadeTarget.width !== s.x || this.rasterFadeTarget.height !== s.y) && this.rasterFadeTarget.setSize(s.x, s.y) : (this.rasterFadeTarget = new _.WebGLRenderTarget(s.x, s.y, { type: _.HalfFloatType }), this.rasterFadeTarget.texture.colorSpace = _.LinearSRGBColorSpace);
+    const a = i.getRenderTarget();
+    i.setRenderTarget(this.rasterFadeTarget), e.render(t, r), i.setRenderTarget(a);
+  }
+  /** Composite the captured raster over the on-canvas path-traced frame at the
+   * given opacity (1 = pure raster, 0 = fully revealed path tracing). */
+  renderRasterFade(e) {
+    var a, l;
+    const t = j(this.renderer) ? this.renderer.getInternalRenderer() : null;
+    if (!t || !this.rasterFadeTarget)
+      return;
+    (!this.fadeQuad || this.fadeToneMapping !== t.toneMapping) && ((l = (a = this.fadeQuad) == null ? void 0 : a.material) == null || l.dispose(), this.fadeToneMapping = t.toneMapping, this.fadeQuad = new Y(this.createFadeMaterial(t.toneMapping)));
+    const r = this.fadeQuad.material;
+    r.uniforms.tRaster.value = this.rasterFadeTarget.texture, r.uniforms.uOpacity.value = e;
+    const i = t.autoClear, s = t.getRenderTarget();
+    t.setRenderTarget(null), t.autoClear = !1;
+    try {
+      this.fadeQuad.render(t);
+    } finally {
+      t.autoClear = i, t.setRenderTarget(s);
+    }
+  }
+  /** A fade material that tone-maps + sRGB-encodes a linear snapshot exactly the
+   * way the renderer would when drawing to the canvas (mirrors OutputPass), then
+   * applies the fade alpha — so the dissolve's first frame matches the on-screen
+   * raster instead of the darker un-tone-mapped image. */
+  createFadeMaterial(e) {
+    const t = {
+      [_.LinearToneMapping]: "LINEAR_TONE_MAPPING",
+      [_.ReinhardToneMapping]: "REINHARD_TONE_MAPPING",
+      [_.CineonToneMapping]: "CINEON_TONE_MAPPING",
+      [_.ACESFilmicToneMapping]: "ACES_FILMIC_TONE_MAPPING",
+      [_.AgXToneMapping]: "AGX_TONE_MAPPING",
+      [_.NeutralToneMapping]: "NEUTRAL_TONE_MAPPING"
+    }, r = {}, i = t[e];
+    return i && (r[i] = ""), new _.ShaderMaterial({
+      defines: r,
+      uniforms: {
+        tRaster: { value: null },
+        uOpacity: { value: 1 }
+      },
+      vertexShader: `
+        varying vec2 vUv;
+        void main() { vUv = uv; gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 ); }
+      `,
+      fragmentShader: `
+        uniform sampler2D tRaster;
+        uniform float uOpacity;
+        varying vec2 vUv;
+        void main() {
+          vec3 color = texture2D( tRaster, vUv ).rgb;
+          #ifdef LINEAR_TONE_MAPPING
+            color = LinearToneMapping( color );
+          #elif defined( REINHARD_TONE_MAPPING )
+            color = ReinhardToneMapping( color );
+          #elif defined( CINEON_TONE_MAPPING )
+            color = CineonToneMapping( color );
+          #elif defined( ACES_FILMIC_TONE_MAPPING )
+            color = ACESFilmicToneMapping( color );
+          #elif defined( AGX_TONE_MAPPING )
+            color = AgXToneMapping( color );
+          #elif defined( NEUTRAL_TONE_MAPPING )
+            color = NeutralToneMapping( color );
+          #endif
+          gl_FragColor = vec4( sRGBTransferOETF( vec4( color, 1.0 ) ).rgb, uOpacity );
+        }
+      `,
+      transparent: !0,
+      depthTest: !1,
+      depthWrite: !1
+    });
   }
   /**
    * Render while path tracing is disabled: keep the final accumulated image on
    * screen if we just completed, otherwise delegate to the standard renderer.
    */
   renderWhileDisabled(e, t) {
-    return this.renderer ? this.sampleCount >= this.settings.samples && this.sampleCount > 0 ? (this.pathTracer && ee(this.renderer) && this.renderer.getInternalRenderer().setRenderTarget(null), _.ok(void 0)) : this.renderer.render(e, t) : _.ok(void 0);
+    return this.renderer ? this.sampleCount >= this.settings.samples && this.sampleCount > 0 ? (this.pathTracer && j(this.renderer) && this.renderer.getInternalRenderer().setRenderTarget(null), S.ok(void 0)) : this.renderer.render(e, t) : S.ok(void 0);
   }
   /**
    * Render a single path-tracing sample into the internal buffer, preserving the
    * renderer's autoClear/render-target state so the standard view stays visible.
    */
   accumulateOneSample() {
-    const e = ee(this.renderer) ? this.renderer.getInternalRenderer() : null;
+    const e = j(this.renderer) ? this.renderer.getInternalRenderer() : null;
     if (!e)
       throw new Error("Three.js renderer not available");
     const t = e.autoClear, r = e.getRenderTarget();
@@ -6252,7 +6325,7 @@ const pe = class pe {
    * stale frame frozen on screen.
    */
   captureCompletedFrame() {
-    const e = ee(this.renderer) ? this.renderer.getInternalRenderer() : null;
+    const e = j(this.renderer) ? this.renderer.getInternalRenderer() : null;
     if (e && this.pathTracer)
       try {
         const t = e.autoClear;
@@ -6262,7 +6335,7 @@ const pe = class pe {
       } catch (t) {
         console.warn("Failed to present path traced result:", t);
       }
-    return this.disableAfterSelfPause("completed"), _.ok(void 0);
+    return this.disableAfterSelfPause("completed"), S.ok(void 0);
   }
   getSampleCount() {
     return this.sampleCount;
@@ -6297,14 +6370,14 @@ const pe = class pe {
       }
       this.pathTracer = null;
     }
-    this.convertedEnvTexture && (this.convertedEnvTexture.dispose(), this.convertedEnvTexture = null), this.sampleCount = 0, this.sceneInitialized = !1, this.createAttempts = 0, this.renderer = null;
+    this.convertedEnvTexture && (this.convertedEnvTexture.dispose(), this.convertedEnvTexture = null), this.fadeQuad && (this.fadeQuad.material.dispose(), this.fadeQuad = null), this.fadeToneMapping = null, this.rasterFadeTarget && (this.rasterFadeTarget.dispose(), this.rasterFadeTarget = null), this.sampleCount = 0, this.sceneInitialized = !1, this.createAttempts = 0, this.renderer = null;
   }
   isSupported() {
     return document.createElement("canvas").getContext("webgl2") !== null;
   }
 };
-pe.CAMERA_SETTLE_MS = 200;
-let ht = pe;
+M.CAMERA_SETTLE_MS = 200, M.FADE_SAMPLES = 256, M.FADE_HOLD_SAMPLES = 4, M.FADE_PREVIEW_OPACITY = 0.3, M.FADE_RELEASE_FRACTION = 0.5;
+let ut = M;
 export {
-  ht as ThreePathTracingService
+  ut as ThreePathTracingService
 };