softbox 4.8.0 → 4.10.0

package/dist/{ThreePathTracingService-yfJv1Gh-.js → ThreePathTracingService-Dj2JP7gs.js}

@@ -1,9 +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 Mt, ByteType as Be, ShortType as At, RGBAFormat as I, RGBAIntegerFormat as Ae, RGIntegerFormat as ft, RedIntegerFormat as Ct, RGFormat as ht, RedFormat as me, BufferAttribute as P, BufferGeometry as Q, Matrix4 as O, Matrix3 as Ft, Vector3 as F, Vector4 as K, MeshBasicMaterial as Dt, Mesh as Pt, ShaderMaterial as ge, NoBlending as ie, WebGLRenderTarget as ae, Vector2 as q, PerspectiveCamera as dt, DataUtils as k, HalfFloatType as D, LinearFilter as C, RepeatWrapping as z, ClampToEdgeWrapping as N, Source as Et, Quaternion as kt, DataArrayTexture as Ot, DoubleSide as zt, BackSide as Nt, FrontSide as Ht, WebGLArrayRenderTarget as Bt, Color as se, NoToneMapping as Wt, NormalBlending as mt, EquirectangularReflectionMapping as pt, Spherical as Lt, LinearMipMapLinearFilter as Ut, Clock as Vt, Scene as Gt, AdditiveBlending as qt } from "three";
-import { g as $t, a as jt, B as We, I as Yt, C as Xt, O as Qt, S as Kt, b as Zt, L as Jt, c as er, M as tr, T as rr, D as ar, d as ir, R as S, e as B, E as W } from "./index-C4Vga5nj.js";
-import { F as Z } from "./Pass-DOcH4lwV.js";
-function sr(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-DOb7Peb_.js";
+function or(o) {
+  switch (o) {
     case 1:
       return "R";
     case 2:
@@ -15,10 +15,10 @@ function sr(s) {
   }
   throw new Error();
 }
-function or(s) {
-  switch (s) {
+function nr(o) {
+  switch (o) {
     case 1:
-      return me;
+      return pe;
     case 2:
       return ht;
     case 3:
@@ -27,10 +27,10 @@ function or(s) {
       return I;
   }
 }
-function Le(s) {
-  switch (s) {
+function Le(o) {
+  switch (o) {
     case 1:
-      return Ct;
+      return Ft;
     case 2:
       return ft;
     case 3:
@@ -39,7 +39,7 @@ function Le(s) {
       return Ae;
   }
 }
-class gt extends M {
+class gt extends F {
   constructor() {
     super(), this.minFilter = T, this.magFilter = T, this.generateMipmaps = !1, this.overrideItemSize = null, this._forcedType = null;
   }
@@ -60,17 +60,17 @@ class gt extends M {
         throw new Error("VertexAttributeTexture: overrideItemSize must divide evenly into buffer length.");
       e.itemSize = t, e.count = i * r / t;
     }
-    const o = e.itemSize, a = e.count, l = e.normalized, f = e.array.constructor, d = f.BYTES_PER_ELEMENT;
-    let h = this._forcedType, u = o;
+    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 (f) {
+      switch (u) {
         case Float32Array:
           h = R;
           break;
         case Uint8Array:
         case Uint16Array:
         case Uint32Array:
-          h = re;
+          h = ae;
           break;
         case Int8Array:
         case Int16Array:
@@ -78,31 +78,31 @@ class gt extends M {
           h = we;
           break;
       }
-    let n, x, m, g, c = sr(o);
+    let n, x, m, g, c = or(s);
     switch (h) {
       case R:
-        m = 1, x = or(o), l && d === 1 ? (g = f, c += "8", f === 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, f.BYTES_PER_ELEMENT * 8 - 1) : 1, x = Le(o), d === 1 ? (g = Int8Array, n = Be) : d === 2 ? (g = Int16Array, n = At) : (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, f.BYTES_PER_ELEMENT * 8 - 1) : 1, x = Le(o), d === 1 ? (g = Uint8Array, n = Me) : d === 2 ? (g = Uint16Array, n = Mt) : (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 vt extends gt {
   constructor() {
-    super(), this._forcedType = re;
+    super(), this._forcedType = ae;
   }
 }
 class xt extends gt {
@@ -110,9 +110,9 @@ class xt extends gt {
     super(), this._forcedType = R;
   }
 }
-class nr {
+class lr {
   constructor() {
-    this.index = new vt(), this.position = new xt(), 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.
@@ -122,16 +122,16 @@ class nr {
    */
   updateFrom(e) {
     const { geometry: t } = e;
-    if (cr(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 = $t(jt(t));
-          this._cachedIndexAttr = new P(i, 1, !1);
+          this._cachedIndexAttr = new O(i, 1, !1);
         }
-      lr(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);
   }
@@ -145,34 +145,34 @@ class nr {
     e && e.dispose(), t && t.dispose(), r && r.dispose(), i && i.dispose();
   }
 }
-function lr(s, e, t) {
-  const r = t.array, i = s.index ? s.index.array : null;
-  for (let o = 0, a = e.length; o < a; o++) {
-    const l = 3 * o, f = 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[f + d] : f + d;
+      r[l + d] = i ? i[u + d] : u + d;
   }
 }
-function cr(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), f = i.byteLength / We, d = 2 * Math.ceil(Math.sqrt(f / 2)), h = new Float32Array(4 * d * d), u = Math.ceil(Math.sqrt(f)), n = new Uint32Array(2 * u * u);
-  for (let x = 0; x < f; x++) {
+  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++)
       h[8 * x + 0 + p] = l[c + 0 + p], h[8 * x + 4 + p] = l[c + 3 + p];
-    if (Yt(g, o)) {
-      const p = Xt(g, o), v = Qt(m, a), b = Jt | 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 = Kt(m, a);
       n[x * 2 + 0] = v, n[x * 2 + 1] = p;
     }
   }
-  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 = 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 ur = (
+const fr = (
   /* glsl */
   `
 
@@ -257,7 +257,7 @@ void ndcToCameraRay(
 
 }
 `
-), fr = (
+), hr = (
   /* glsl */
   `
 
@@ -464,7 +464,7 @@ bool _bvhIntersectFirstHit(
 
 }
 `
-), hr = (
+), dr = (
   /* glsl */
   `
 struct BVH {
@@ -478,317 +478,317 @@ struct BVH {
 };
 `
 );
-function bt(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 X(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 dr(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 mr(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 pr(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 gr(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 vr(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;
-  dr(s);
-  const l = s[0].index !== null, f = l ? mr(s) : -1, d = pr(s);
-  if (gr(t, f, 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(f), 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 h = Object.keys(s[0].attributes);
-  for (let u = 0, n = h.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 = h[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);
+    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 xr(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 f = s.getAttribute("materialIndex");
-  if (!f || f.count !== o) {
+  let u = o.getAttribute("materialIndex");
+  if (!u || u.count !== s) {
     let h;
-    t.length <= 255 ? h = new Uint8Array(o) : h = new Uint16Array(o), f = new P(h, 1, !1), s.deleteAttribute("materialIndex"), s.setAttribute("materialIndex", f);
+    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 = f.array;
+  const d = u.array;
   for (let h = 0; h < l.length; h++) {
-    const u = l[h], n = u.start, x = u.count, m = Math.min(x, a - n), g = Array.isArray(e) ? e[u.materialIndex] : e, c = t.indexOf(g);
+    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 br(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 Ue(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 Ve(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 yr {
+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 = Ue(t), this.primitiveCount = r, this.skeletonHash = Ve(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 === Ue(t) && this.skeletonHash === Ve(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(), Ge = /* @__PURE__ */ new K(), le = /* @__PURE__ */ new F(), Ie = /* @__PURE__ */ new F(), qe = /* @__PURE__ */ new K(), $e = /* @__PURE__ */ new K(), ce = /* @__PURE__ */ new O(), je = /* @__PURE__ */ new O();
-function Ye(s, e, t) {
-  const r = s.skeleton, i = s.geometry, o = r.bones, a = r.boneInverses;
-  qe.fromBufferAttribute(i.attributes.skinIndex, e), $e.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 f = $e.getComponent(l);
-    if (f !== 0) {
+    const u = $e.getComponent(l);
+    if (u !== 0) {
       const d = qe.getComponent(l);
-      je.multiplyMatrices(o[d].matrixWorld, a[d]), Tr(ce, je, f);
+      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], f = s[o];
-    l !== 0 && (Ie.fromBufferAttribute(f, 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 Tr(s, e, t) {
-  const r = s.elements, i = e.elements;
-  for (let o = 0, a = i.length; o < a; o++)
-    r[o] += i[o] * t;
+function 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 wr(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 f = 0; f < o; f++) {
-          const d = i.getComponent(a, f), h = i.getComponent(a + 2, f);
-          i.setComponent(a, f, h), i.setComponent(a + 2, f, 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 Ir(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, f = 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()), f.position || t.setAttribute("position", te(l.position)), o && !f.normal && l.normal && t.setAttribute("normal", te(l.normal)), a && !f.tangent && l.tangent && t.setAttribute("tangent", te(l.tangent)), X(r.index, t.index), X(l.position, f.position), o && X(l.normal, f.normal), a && X(l.tangent, f.tangent);
-  const d = l.position, h = 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 Ft();
-  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), h && U.fromBufferAttribute(h, v), u && (Ge.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), h && Ye(s, v, U), u && Ye(s, v, V)), i && L.applyMatrix4(s.matrixWorld), f.position.setXYZ(v, L.x, L.y, L.z), h && (i && U.applyNormalMatrix(p), f.normal.setXYZ(v, U.x, U.y, U.z)), u && (i && V.transformDirection(s.matrixWorld), f.tangent.setXYZW(v, V.x, V.y, V.z, Ge.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) || (f[b] || t.setAttribute(b, te(l[b])), X(l[b], f[b]), bt(l[b], f[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 && wr(t), t;
+  return o.matrixWorld.determinant() < 0 && Ir(t), t;
 }
-class Rr extends Q {
+class _r extends ee {
   constructor() {
-    super(), this.version = 0, this.hash = null, this._diff = new yr();
+    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 && !X(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) ? (Ir(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, yt = 1, Tt = 2;
-function Sr(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 _r(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 Mr(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
-    vr(s, t, e);
+    xr(o, t, e);
   for (const r in e.attributes)
     e.attributes[r].needsUpdate = !0;
 }
-class Ar {
+class Fr {
   constructor(e) {
     this.objects = null, this.useGroups = !0, this.applyWorldTransforms = !0, this.generateMissingAttributes = !0, this.overwriteIndex = !0, this.attributes = ["position", "normal", "color", "tangent", "uv", "uv2"], this._intermediateGeometry = /* @__PURE__ */ new Map(), this._geometryMergeSets = /* @__PURE__ */ new WeakMap(), this._mergeOrder = [], this._dummyMesh = null, this.setObjects(e || []);
   }
   _getDummyMesh() {
     if (!this._dummyMesh) {
-      const e = new Dt(), t = new Q();
-      t.setAttribute("position", new P(new Float32Array(9), 3)), this._dummyMesh = new Pt(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;
   }
@@ -803,68 +803,68 @@ class Ar {
       attributes: this.attributes,
       applyWorldTransforms: this.applyWorldTransforms
     };
-    for (let o = 0, a = t.length; o < a; o++) {
-      const l = t[o], f = l.uuid;
-      r.delete(f);
-      let d = e.get(f);
-      (!d || !d.isCompatible(l, this.attributes)) && (d && d.dispose(), d = new Rr(), e.set(f, d)), d.updateFrom(l, i) && this.generateMissingAttributes && br(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 = [], f = [], 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 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);
-      f.push(g);
+      u.push(g);
       const c = d[n];
       !c || c.uuid !== g.uuid ? (l.push(!1), h = !0) : c.version !== g.version ? l.push(!1) : l.push(!0);
     }
-    Mr(f, e, { useGroups: t, forceUpdate: h, skipAssigningAttributes: l, overwriteIndex: r }), h && e.dispose(), o.set(e, f.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 h ? u = Tt : l.includes(!1) && (u = yt), {
-      changeType: u,
-      materials: _r(a),
+    let f = Fe;
+    return h ? f = Tt : l.includes(!1) && (f = yt), {
+      changeType: f,
+      materials: Mr(a),
       geometry: e
     };
   }
 }
-function Cr(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 Fr(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 Dr {
+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 Ar(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);
@@ -884,36 +884,36 @@ class Dr {
     }
   }
   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, f = Cr(l), { lights: d, iesTextures: h } = Fr(o);
-    if (a.changeType !== Ce && xr(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 === Tt) {
-        const u = {
+        const f = {
           strategy: er,
           maxLeafTris: 1,
           indirect: !0,
           onProgress: e,
           ...this.bvhOptions
         };
-        this._buildAsync ? this.bvh = this._bvhWorker.generate(r, u) : this.bvh = new tr(r, u);
+        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: h,
       geometry: r,
       materials: l,
-      textures: f,
-      objects: o
+      textures: u,
+      objects: s
     };
   }
 }
@@ -945,10 +945,10 @@ class Pe extends ge {
     return !1;
   }
 }
-class Pr extends Pe {
+class Er extends Pe {
   constructor(e) {
     super({
-      blending: ie,
+      blending: se,
       uniforms: {
         target1: { value: null },
         target2: { value: null },
@@ -1002,9 +1002,9 @@ class Pr 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 ) {
 
@@ -1042,9 +1042,9 @@ function ue(s = 1) {
 		}
 	`;
 }
-function fe(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 ) {
@@ -1057,7 +1057,7 @@ function fe(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 );
@@ -1073,10 +1073,10 @@ const wt = (
 	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 ) {
 
@@ -1091,7 +1091,7 @@ const wt = (
 	}
 
 `
-), Er = (
+), Or = (
   /* glsl */
   `
 
@@ -1212,19 +1212,19 @@ const wt = (
 
 	}
 
-	${fe(1)}
-	${fe(2)}
-	${fe(3)}
-	${fe(4)}
+	${he(1)}
+	${he(2)}
+	${he(3)}
+	${he(4)}
 
 `
 );
-class Or extends Pe {
+class Nr extends Pe {
   constructor() {
     super({
-      blending: ie,
+      blending: se,
       uniforms: {
-        resolution: { value: new q() }
+        resolution: { value: new X() }
       },
       vertexShader: (
         /* glsl */
@@ -1244,7 +1244,7 @@ class Or extends Pe {
         `
 
 				${wt}
-				${Er}
+				${Or}
 
 				varying vec2 vUv;
 				uniform vec2 resolution;
@@ -1261,7 +1261,7 @@ class Or extends Pe {
 }
 class zr {
   generate(e, t = 256) {
-    const r = new ae(t, t, {
+    const r = new ie(t, t, {
       type: R,
       format: I,
       minFilter: T,
@@ -1269,11 +1269,11 @@ class zr {
       generateMipmaps: !1
     }), i = e.getRenderTarget();
     e.setRenderTarget(r);
-    const o = new Z(new Or());
-    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 Nr extends dt {
+class Hr extends dt {
   set bokehSize(e) {
     this.fStop = this.getFocalLength() / e;
   }
@@ -1287,132 +1287,132 @@ class Nr extends dt {
     return super.copy(e, t), this.fStop = e.fStop, this.apertureBlades = e.apertureBlades, this.apertureRotation = e.apertureRotation, this.focusDistance = e.focusDistance, this.anamorphicRatio = e.anamorphicRatio, this;
   }
 }
-class Hr {
+class Br {
   constructor() {
     this.bokehSize = 0, this.apertureBlades = 0, this.apertureRotation = 0, this.focusDistance = 10, this.anamorphicRatio = 1;
   }
   updateFrom(e) {
-    e instanceof Nr ? (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 Se(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 Xe(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 Br(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 Wr(s, e = D) {
-  const t = s.clone();
+function Lr(o, e = E) {
+  const t = o.clone();
   t.source = new Et({ ...t.image });
-  const { width: r, height: i, data: o } = t.image;
-  let a = o;
+  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 f = 0, d = o.length; f < d; f++) {
-      let h = o[f];
-      t.type === D && (h = k.fromHalfFloat(o[f])), t.type !== R && t.type !== D && (h /= l), e === D && (a[f] = k.toHalfFloat(h));
+    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 f = 0; f < i; f++)
+    for (let u = 0; u < i; u++)
       for (let d = 0; d < r; d++) {
-        const h = i - f - 1, u = 4 * (f * r + d), n = 4 * (h * 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 Lr {
+class Ur {
   constructor() {
-    const e = new M(Se(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(Se(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(Se(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 = Wr(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), f = new Float32Array(i), d = new Float32Array(i);
-    let h = 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 = Br(y, w, E);
-        p += H, h += 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, f[c] = p, d[c] = u;
+      f += p, u[c] = p, d[c] = f;
     }
-    if (u !== 0)
-      for (let c = 0, p = f.length; c < p; c++)
-        f[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 = Xe(d, p);
-      n[c] = k.toHalfFloat((v + 0.5) / i);
+      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 = Xe(l, b, c * r, r);
-        x[v] = k.toHalfFloat((y + 0.5) / 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 = h, this.map = t;
   }
 }
-const _e = 6, Ur = 0, Vr = 1, Gr = 2, qr = 3, $r = 4, A = new F(), _ = new F(), Qe = new O(), $ = new kt(), Ke = new F(), j = new F(), jr = new F(0, 1, 0);
-class Yr {
+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 * _e, 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 f = 0, d = e.length; f < d; f++) {
-      const h = e[f], u = f * _e * 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 < _e * 4; m++)
-        a[u + m] = 0;
-      h.getWorldPosition(_), a[u + n++] = _.x, a[u + n++] = _.y, a[u + n++] = _.z;
-      let x = Ur;
-      if (h.isRectAreaLight && h.isCircular ? x = Vr : h.isSpotLight ? x = Gr : h.isDirectionalLight ? x = qr : h.isPointLight && (x = $r), a[u + n++] = x, a[u + n++] = h.color.r, a[u + n++] = h.color.g, a[u + n++] = h.color.b, a[u + n++] = h.intensity, h.getWorldQuaternion($), h.isRectAreaLight)
-        A.set(h.width, 0, 0).applyQuaternion($), a[u + n++] = A.x, a[u + n++] = A.y, a[u + n++] = A.z, n++, _.set(0, h.height, 0).applyQuaternion($), a[u + n++] = _.x, a[u + n++] = _.y, a[u + n++] = _.z, a[u + n++] = A.cross(_).length() * (h.isCircular ? Math.PI / 4 : 1);
+      for (let m = 0; m < Se * 4; m++)
+        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), j.setFromMatrixPosition(h.target.matrixWorld), Qe.lookAt(Ke, j, jr), $.setFromRotationMatrix(Qe), A.set(1, 0, 0).applyQuaternion($), a[u + n++] = A.x, a[u + n++] = A.y, a[u + n++] = A.z, n++, _.set(0, 1, 0).applyQuaternion($), a[u + n++] = _.x, a[u + n++] = _.y, a[u + n++] = _.z, a[u + n++] = Math.PI * m * m, a[u + n++] = m, a[u + n++] = h.decay, a[u + n++] = h.distance, a[u + n++] = Math.cos(h.angle), a[u + n++] = Math.cos(h.angle * (1 - h.penumbra)), a[u + n++] = h.iesMap ? t.indexOf(h.iesMap) : -1;
+        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 = A.setFromMatrixPosition(h.matrixWorld);
-        a[u + n++] = m.x, a[u + n++] = m.y, a[u + n++] = m.z, n++, n += 4, n += 1, a[u + n++] = h.decay, a[u + n++] = h.distance;
+        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 = A.setFromMatrixPosition(h.matrixWorld), g = _.setFromMatrixPosition(h.target.matrixWorld);
-        j.subVectors(m, g).normalize(), a[u + n++] = j.x, a[u + n++] = j.y, a[u + n++] = j.z;
+        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;
@@ -1420,12 +1420,12 @@ class Yr {
     return this.hash !== l ? (this.hash = l, r.needsUpdate = !0, !0) : !1;
   }
 }
-function Ze(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:
@@ -1437,52 +1437,52 @@ function Ze(s, e, t, r, i) {
       l = 2 ** (a - 1) - 1;
       break;
   }
-  for (let f = 0; f < o; f++) {
-    const d = 4 * f, h = e * f;
-    for (let u = 0; u < r; u++)
-      t[i + d + u] = e >= u + 1 ? s[h + 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 Xr extends Ot {
+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: f } = o, h = a * l * 4 * e;
-    let u = t.itemSize;
-    u === 3 && (u = 4), Ze(r.image.data, u, f, 4, h), 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 xt();
-      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: f, width: d, height: h } = l;
-    for (let u = 0, n = r; u < n; u++) {
-      const x = i[u], g = d * h * 4 * u;
-      let c = e[u].itemSize;
-      c === 3 && (c = 4), Ze(x.image.data, c, f, 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 Qr extends Xr {
+class Kr extends Qr {
   updateNormalAttribute(e) {
     this.updateAttribute(0, e);
   }
@@ -1499,44 +1499,44 @@ class Qr extends Xr {
     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 Kr(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 Zr(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 Jr(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 Kr(t).sort(Ee);
+  return Zr(t).sort(Ee);
 }
-function ea(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 It = 45, Je = It * 4;
-class ta {
+class ra {
   constructor() {
     this._features = {};
   }
@@ -1550,22 +1550,22 @@ class ta {
     this._features = {};
   }
 }
-class ra 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 ta();
+    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();
@@ -1576,10 +1576,10 @@ class ra extends M {
       return 8;
     }
     let a = 0;
-    const l = e.length * It, f = Math.ceil(Math.sqrt(l)) || 1, { image: d, features: h } = 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 !== f && (this.dispose(), d.data = new Float32Array(f * f * 4), d.width = f, d.height = f);
+      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;
     h.reset();
     for (let m = 0, g = e.length; m < g; m++) {
@@ -1602,63 +1602,63 @@ class ra extends M {
           case Ht:
             n[a++] = 1;
             break;
-          case Nt:
+          case zt:
             n[a++] = -1;
             break;
-          case zt:
+          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 et = new se();
-function aa(s) {
-  return s ? `${s.uuid}:${s.version}` : null;
+const et = new oe();
+function ia(o) {
+  return o ? `${o.uuid}:${o.version}` : null;
 }
-function ia(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 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), ia(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 sa());
-    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();
+    const s = e.getRenderTarget(), a = e.toneMapping, l = e.getClearAlpha();
     e.getClearColor(et);
-    const f = t.length || 1;
-    (r !== this.width || i !== this.height || this.depth !== f) && (this.setSize(r, i, f), this.hashes = new Array(f).fill(null)), e.setClearColor(0, 0), e.toneMapping = Wt;
+    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 u = !1;
-    for (let n = 0, x = f; n < x; n++) {
-      const m = t[n], g = aa(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, u = !0);
+    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(et, 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 sa extends ge {
+class oa extends ge {
   get map() {
     return this.uniforms.map.value;
   }
@@ -1697,60 +1697,60 @@ class sa extends ge {
     });
   }
 }
-function oa(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 na {
+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 && (oa(o, r), this.reshuffle());
-      let f = o[a++];
+      a >= s.length && (na(s, r), this.reshuffle());
+      let u = s[a++];
       for (let d = 0; d < t; d++)
-        l[d] = (f % e + r()) / e, f = Math.floor(f / e);
+        l[d] = (u % e + r()) / e, u = Math.floor(u / e);
       return l;
     };
   }
 }
-class la {
+class ca {
   constructor(e, t, r = Math.random) {
     let i = 0;
-    for (const f of t)
-      i += f;
-    const o = new Float32Array(i), a = [];
+    for (const u of t)
+      i += u;
+    const s = new Float32Array(i), a = [];
     let l = 0;
-    for (const f of t) {
-      const d = new na(e, f, 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 f of a)
-        f.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 f of a)
-        f.reshuffle();
+      for (const u of a)
+        u.reshuffle();
     }, this.reset = function() {
-      for (const f of a)
-        f.reset();
+      for (const u of a)
+        u.reset();
     };
   }
 }
-class ca {
+class ua {
   constructor(e = 0) {
     this.m = 2147483648, this.a = 1103515245, this.c = 12345, this.seed = e;
   }
@@ -1761,15 +1761,15 @@ class ca {
     return this.nextInt() / (this.m - 1);
   }
 }
-class ua 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 ca(), 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 la(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() {
@@ -1779,16 +1779,16 @@ class ua extends M {
     this.sampler.reset(), this.generator.seed = 0;
   }
 }
-function fa(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 ha(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 rt {
   constructor(e) {
@@ -1797,33 +1797,33 @@ class rt {
   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 f = (t + l) * r + a + t, d = a * a + l * l;
-        i[f] = 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;
   }
@@ -1833,7 +1833,7 @@ class rt {
   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;
@@ -1841,16 +1841,16 @@ class rt {
         e[i] = 0;
   }
   updateScore(e, t, r) {
-    const { size: i, score: o, lookupTable: a } = this, l = this.radius, f = 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 h = -l; h <= l; h++) {
-        const u = (l + h) * f + d + l, n = a[u];
+        const f = (l + h) * u + d + l, n = a[f];
         let x = e + d;
         x = x < 0 ? i + x : x % i;
         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) {
@@ -1867,7 +1867,7 @@ class rt {
     this.resize(e.size), this.score.set(e.score), this.binaryPattern.set(e.binaryPattern), this.setSigma(e.sigma), this.count = e.count;
   }
 }
-class da {
+class ma {
   constructor() {
     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);
   }
@@ -1877,76 +1877,76 @@ class da {
       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;
-    ha(l, a), fa(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 f = 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), f[u] = d, d--;
+      const f = e.findCluster();
+      e.removePointIndex(f), u[f] = d, d--;
     }
-    const h = o * o;
+    const h = s * s;
     for (d = t.count; d < h / 2; ) {
-      const u = t.findVoid();
-      t.addPointIndex(u), f[u] = d, d++;
+      const f = t.findVoid();
+      t.addPointIndex(f), u[f] = d, d++;
     }
     for (t.invert(); d < h; ) {
-      const u = t.findCluster();
-      t.removePointIndex(u), f[u] = d, d++;
+      const f = t.findCluster();
+      t.removePointIndex(f), u[f] = d, d++;
     }
-    return { data: f, maxValue: h };
+    return { data: u, maxValue: h };
   }
 }
-function ma(s) {
-  return s >= 3 ? 4 : s;
+function pa(o) {
+  return o >= 3 ? 4 : o;
 }
-function pa(s) {
-  switch (s) {
+function ga(o) {
+  switch (o) {
     case 1:
-      return me;
+      return pe;
     case 2:
       return ht;
     default:
       return I;
   }
 }
-class ga 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 da();
+    const e = this.channels, t = this.size, r = new ma();
     r.channels = e, r.size = t;
-    const i = ma(e), o = pa(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, f = e; l < f; l++) {
-      const d = r.generate(), h = d.data, u = d.maxValue;
+    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] / u;
+        const m = h[n] / f;
         a[n * i + l] = m;
       }
     }
     this.needsUpdate = !0;
   }
 }
-const va = (
+const xa = (
   /* glsl */
   `
 
@@ -1961,7 +1961,7 @@ const va = (
 	};
 
 `
-), xa = (
+), ba = (
   /* glsl */
   `
 
@@ -1976,7 +1976,7 @@ const va = (
 	};
 
 `
-), ba = (
+), ya = (
   /* glsl */
   `
 
@@ -2065,7 +2065,7 @@ const va = (
 	}
 
 `
-), ya = (
+), Ta = (
   /* glsl */
   `
 
@@ -2275,7 +2275,7 @@ const va = (
 	}
 
 `
-), Ta = (
+), wa = (
   /* glsl */
   `
 
@@ -2340,7 +2340,7 @@ const va = (
 	};
 
 `
-), wa = (
+), Ia = (
   /* glsl */
   `
 
@@ -2410,7 +2410,7 @@ const va = (
 
 	}
 `
-), Ia = (
+), Ra = (
   /* glsl */
   `
 
@@ -2628,7 +2628,7 @@ const va = (
 	}
 
 `
-), Ra = (
+), _a = (
   /* glsl */
   `
 
@@ -2822,7 +2822,7 @@ const va = (
 	}
 
 `
-), _a = (
+), Ma = (
   /* glsl */
   `
 
@@ -2905,7 +2905,7 @@ const va = (
 	}
 
 `
-), Ma = (
+), Aa = (
   /* glsl */
   `
 
@@ -2969,7 +2969,7 @@ const va = (
 	}
 
 `
-), Aa = (
+), Fa = (
   /*glsl */
   `
 
@@ -3224,7 +3224,7 @@ const va = (
 	}
 
 `
-), Fa = (
+), Da = (
   /* glsl */
   `
 
@@ -3665,7 +3665,7 @@ const va = (
 	}
 
 `
-), Da = (
+), Pa = (
   /* glsl */
   `
 
@@ -3689,7 +3689,7 @@ const va = (
 	}
 
 `
-), Pa = (
+), Ea = (
   /* glsl */
   `
 
@@ -3793,7 +3793,7 @@ const va = (
 	}
 
 `
-), Ea = (
+), Oa = (
   /* glsl */
   `
 
@@ -4030,7 +4030,7 @@ const va = (
 	}
 
 `
-), Oa = (
+), Na = (
   /* glsl */
   `
 
@@ -4274,7 +4274,7 @@ bool bvhIntersectFogVolumeHit(
 	}
 
 `
-), Na = (
+), Ha = (
   /* glsl */
   `
 
@@ -4360,7 +4360,7 @@ bool bvhIntersectFogVolumeHit(
 	}
 
 `
-), Ha = (
+), Ba = (
   /*glsl*/
   `
 
@@ -4459,7 +4459,7 @@ bool bvhIntersectFogVolumeHit(
 	}
 
 `
-), Ba = (
+), Wa = (
   /* glsl */
   `
 
@@ -4784,7 +4784,7 @@ bool bvhIntersectFogVolumeHit(
 
 	}
 `
-), Wa = (
+), La = (
   /* glsl */
   `
 
@@ -4836,7 +4836,7 @@ bool bvhIntersectFogVolumeHit(
 	}
 
 `
-), La = (
+), Ua = (
   /* glsl */
   `
 
@@ -4887,7 +4887,7 @@ bool bvhIntersectFogVolumeHit(
 
 `
 );
-class Ua 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);
   }
@@ -4917,42 +4917,42 @@ class Ua extends Pe {
       },
       uniforms: {
         // path trace uniforms
-        resolution: { value: new q() },
+        resolution: { value: new X() },
         opacity: { value: 1 },
         bounces: { value: 10 },
         transmissiveBounces: { value: 10 },
         filterGlossyFactor: { value: 0 },
         // camera uniforms
-        physicalCamera: { value: new Hr() },
-        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 nr() },
-        attributesArray: { value: new Qr() },
+        bvh: { value: new lr() },
+        attributesArray: { value: new Kr() },
         materialIndexAttribute: { value: new vt() },
-        materials: { value: new ra() },
+        materials: { value: new aa() },
         textures: { value: new tt().texture },
         // light uniforms
-        lights: { value: new Yr() },
+        lights: { value: new Xr() },
         iesProfiles: { value: new tt(360, 180, {
-          type: D,
-          wrapS: N,
-          wrapT: N
+          type: E,
+          wrapS: B,
+          wrapT: B
         }).texture },
         environmentIntensity: { value: 1 },
-        environmentRotation: { value: new O() },
-        envMapInfo: { value: new Lr() },
+        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 ua() },
-        stratifiedOffsetTexture: { value: new ga(64, 1) }
+        stratifiedTexture: { value: new fa() },
+        stratifiedOffsetTexture: { value: new va(64, 1) }
       },
       vertexShader: (
         /* glsl */
@@ -4984,16 +4984,16 @@ class Ua extends Pe {
 				#include <common>
 
 				// bvh intersection
-				${ur}
-				${hr}
 				${fr}
+				${dr}
+				${hr}
 
 				// uniform structs
-				${va}
-				${ba}
 				${xa}
 				${ya}
+				${ba}
 				${Ta}
+				${wa}
 
 				// random
 				#if RANDOM_TYPE == 2 	// Stratified List
@@ -5029,11 +5029,11 @@ class Ua extends Pe {
 				#endif
 
 				// common
-				${Aa}
+				${Fa}
 				${Sa}
 				${Rt}
-				${_a}
 				${Ma}
+				${Aa}
 
 				// environment
 				uniform EquirectHdrInfo envMapInfo;
@@ -5089,16 +5089,16 @@ class Ua extends Pe {
 				float lightsDenom;
 
 				// sampling
-				${Ra}
-				${wa}
+				${_a}
 				${Ia}
+				${Ra}
 
+				${Na}
+				${Ea}
+				${ka}
 				${Oa}
 				${Pa}
-				${ka}
-				${Ea}
 				${Da}
-				${Fa}
 
 				float applyFilteredGlossy( float roughness, float accumulatedRoughness ) {
 
@@ -5130,12 +5130,12 @@ class Ua extends Pe {
 
 				}
 
-				${Wa}
-				${Na}
 				${La}
-				${za}
 				${Ha}
+				${Ua}
+				${za}
 				${Ba}
+				${Wa}
 
 				void main() {
 
@@ -5434,48 +5434,48 @@ class Ua extends Pe {
 }
 function* Va() {
   const {
-    _renderer: s,
+    _renderer: o,
     _fsQuad: e,
     _blendQuad: t,
     _primaryTarget: r,
     _blendTargets: i,
-    _sobolTarget: o,
+    _sobolTarget: s,
     _subframe: a,
     alpha: l,
-    material: f
-  } = this, d = new K(), h = 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), f.blending = ie, f.opacity = 1) : (f.opacity = this._opacityFactor / (this.samples + 1), f.blending = mt);
+    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;
-    f.resolution.set(v * c, b * p), f.sobolTexture = o.texture, f.stratifiedTexture.init(20, f.bounces + f.transmissiveBounces + 5), f.stratifiedTexture.next(), f.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(), St = s.autoClear, _t = s.getScissorTest();
-        s.getScissor(d), s.getViewport(h);
-        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(h), s.setScissor(d), s.setScissorTest(_t), s.setRenderTarget(ze), s.autoClear = St, 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 it = new se();
+const it = new oe();
 class st {
   get material() {
     return this._fsQuad.material;
@@ -5496,19 +5496,19 @@ class st {
     return !!this._compilePromise;
   }
   constructor(e) {
-    this.camera = null, this.tiles = new q(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 Ua()), this._blendQuad = new Z(new Pr()), this._task = null, this._currentTile = 0, this._compilePromise = null, this._sobolTarget = new zr().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,
@@ -5540,15 +5540,15 @@ class st {
     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(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, 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 = Va.call(this)), this._task.next());
   }
 }
-const G = new q(), ot = new q(), he = new Lt(), de = new se();
-class Ga 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),
@@ -5557,40 +5557,40 @@ class Ga extends M {
       I,
       R,
       pt,
-      z,
-      N,
-      C,
-      C
+      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++) {
-        ot.set(t, r), G.set(i / t, o / r), G.x -= 0.5, G.y = 1 - G.y, he.theta = G.x * 2 * Math.PI, he.phi = G.y * Math.PI, he.radius = 1, this.generationCallback(he, G, ot, 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 nt = new F();
-class qa extends Ga {
+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) => {
+    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;
-      o.lerpColors(this.bottomColor, this.topColor, a ** this.exponent);
+      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 $a extends ge {
+class ja extends ge {
   get map() {
     return this.uniforms.map.value;
   }
@@ -5677,7 +5677,7 @@ class $a extends ge {
     }), this.setValues(e);
   }
 }
-class ja extends ge {
+class Ya extends ge {
   constructor() {
     super({
       uniforms: {
@@ -5722,36 +5722,36 @@ class ja extends ge {
 }
 class lt {
   constructor(e) {
-    this._renderer = e, this._quad = new Z(new ja());
+    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
-    }), f = i.height, d = Math.log2(f) - 2, h = 1 / f, 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 = h, 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 = Ut, c.magFilter = C, c.wrapS = z, c.wrapT = z, c.mapping = pt, 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 Ya(s) {
-  return s.extensions.get("EXT_float_blend");
+function Xa(o) {
+  return o.extensions.get("EXT_float_blend");
 }
-const Y = new q();
-class Xa {
+const Z = new X();
+class Qa {
   get multipleImportanceSampling() {
     return !!this._pathTracer.material.defines.FEATURE_MIS;
   }
@@ -5795,17 +5795,17 @@ class Xa {
     return !!this._pathTracer.isCompiling;
   }
   constructor(e) {
-    this._renderer = e, this._generator = new Dr(), this._pathTracer = new st(e), this._queueReset = !1, this._clock = new Vt(), this._compilePromise = null, this._lowResPathTracer = new st(e), this._lowResPathTracer.tiles.set(1, 1), this._quad = new Z(new $a({
+    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 q(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 Gt(), new dt());
+      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);
@@ -5814,10 +5814,10 @@ class Xa {
     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) {
@@ -5833,19 +5833,19 @@ class Xa {
     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 = Jr(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 = ea(e), o = Zr(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) {
@@ -5869,34 +5869,34 @@ class Xa {
   _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 || !Ya(r), e.alpha = t.alpha, this.renderToCanvas) {
-      const f = 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 h = o.material.opacity;
-          o.material.opacity = 1 - o.material.opacity, o.material.map = e.target.texture, o.render(f), o.material.opacity = h;
+          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 ? qt : mt), o.material.map = t.target.texture, this.renderToCanvasCallback(t.target, f, 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() {
@@ -5907,30 +5907,30 @@ class Xa {
   }
   _updateScale() {
     if (this.synchronizeRenderSize) {
-      this._renderer.getDrawingBufferSize(Y);
-      const e = Math.floor(this.renderScale * Y.x), t = Math.floor(this.renderScale * Y.y);
-      if (this._pathTracer.getSize(Y), Y.x !== e || Y.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 ct(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 rr(), this.settings = {
+    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,
@@ -5938,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[ir] && 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);
     }
   }
   /**
@@ -5970,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 f = 0; f < o.data.length; f++)
-      a[f] = o.data[f] / 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() ? S.ok(void 0) : S.err(
-        new B(
+        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 S.err(
-        new B(
+        new L(
           "Failed to initialize path tracing",
-          W.PATH_TRACING_INIT_FAILED,
+          U.PATH_TRACING_INIT_FAILED,
           { originalError: t }
         )
       );
@@ -6004,24 +6008,24 @@ const pe = class pe {
   createPathTracer() {
     if (this.disposed)
       return S.err(
-        new B(
+        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 Xa(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 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 S.err(
-        new B(
+        new L(
           "Failed to create path tracer",
-          W.PATH_TRACING_INIT_FAILED,
+          U.PATH_TRACING_INIT_FAILED,
           { originalError: e }
         )
       );
@@ -6030,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);
     }
   }
@@ -6066,18 +6070,18 @@ const pe = class pe {
       const i = this.extractThreeObjects(e, t);
       if (!i)
         return S.err(
-          new B(
+          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)
@@ -6086,9 +6090,9 @@ const pe = class pe {
       return this.sceneInitialized ? this.accumulateSample(r, e, t) : r.render(e, t);
     } catch (i) {
       return S.err(
-        new B(
+        new L(
           "Failed to render with path tracing",
-          W.RENDER_FAILED,
+          U.RENDER_FAILED,
           { originalError: i }
         )
       );
@@ -6102,10 +6106,10 @@ 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) {
@@ -6120,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 f = 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 = f;
+          i.environment = u;
         }
-      } else if (l && l.mapping === J.EquirectangularReflectionMapping) {
-        let f = l;
+      } else if (l && l.mapping === _.EquirectangularReflectionMapping) {
+        let u = l;
         if (l.image instanceof HTMLImageElement)
           if (this.convertedEnvTexture)
-            f = this.convertedEnvTexture;
+            u = this.convertedEnvTexture;
           else {
             const h = this.convertToDataTexture(l);
             if (!h)
               throw new Error("Failed to convert environment texture to DataTexture");
-            this.convertedEnvTexture = h, f = h;
+            this.convertedEnvTexture = h, u = h;
           }
         const d = i.environment;
-        i.environment = f;
+        i.environment = u;
         try {
           const h = l.image;
-          h && !("data" in h && h.data) && h instanceof HTMLImageElement && !h.complete && await new Promise((u) => {
+          h && !("data" in h && h.data) && h instanceof HTMLImageElement && !h.complete && await new Promise((f) => {
             h.onload = () => {
-              l.needsUpdate = !0, u();
+              l.needsUpdate = !0, f();
             }, h.onerror = () => {
-              u();
-            }, h.complete && u();
-          }), this.ingestSceneWithoutShadowHelpers(i, o), this.sceneInitialized = !0, i.environment = d;
+              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) {
@@ -6174,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 ? S.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() : S.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), S.ok(void 0)) : this.renderer.render(e, t) : S.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();
@@ -6210,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;
@@ -6255,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 ut = 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 {
   ut as ThreePathTracingService
 };