@voluma/vlam 0.3.0 → 0.3.4

package/dist/unified.js

@@ -1,15 +1,15 @@
 var je = Object.defineProperty;
-var Oe = (r, n, e) => n in r ? je(r, n, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[n] = e;
-var s = (r, n, e) => Oe(r, typeof n != "symbol" ? n + "" : n, e);
+var We = (t, n, e) => n in t ? je(t, n, { enumerable: !0, configurable: !0, writable: !0, value: e }) : t[n] = e;
+var s = (t, n, e) => We(t, typeof n != "symbol" ? n + "" : n, e);
 import * as l from "three/webgpu";
-import { uniform as w, storage as C, Fn as we, If as ze, float as R, instanceIndex as ce, int as ve, ivec2 as We, textureLoad as ee, mat3 as Ae, vec3 as D, vec4 as M, bool as Ie, colorSpaceToWorking as Ne, varying as oe, positionGeometry as ge, modelViewMatrix as Ce, cameraProjectionMatrix as _e, mix as ae, vec2 as z, Discard as qe, texture as te, screenUV as re } from "three/tsl";
-import { S as ke, o as He, p as Ke, q as ne, s as Xe, t as Ye, d as Ze, u as $e, w as Qe, m as Je, b as et, D as tt, c as rt, W as st, C as it, i as ot, j as at, y as nt, r as ct } from "./relighting-CSQF3UcL.js";
-import { RadixSorter as lt } from "./radix-sorter-R0FCSqKu.js";
-import { i as ut } from "./splat-budget-DuVZspPQ.js";
-import { a as dt } from "./webgpu-limits-Y3CI_6_6.js";
-const ue = class ue {
+import { uniform as x, storage as k, Fn as ye, If as ze, float as A, instanceIndex as ue, int as Se, ivec2 as Ie, textureLoad as ee, mat3 as Re, vec3 as R, vec4 as C, bool as Ne, colorSpaceToWorking as _e, varying as te, positionGeometry as we, modelViewMatrix as Ae, cameraProjectionMatrix as qe, mix as ce, vec2 as I, Discard as He, texture as re, screenUV as se } from "three/tsl";
+import { S as De, o as Ke, p as Xe, q as le, s as Ye, t as Ze, d as $e, u as Qe, w as Je, m as et, b as tt, D as rt, c as st, W as it, C as ot, i as at, j as nt, y as ct, r as lt } from "./relighting-Tiwep8yd.js";
+import { RadixSorter as ut } from "./radix-sorter-BrbUg_CV.js";
+import { i as dt } from "./splat-budget-DuVZspPQ.js";
+import { a as ht } from "./webgpu-limits-Y3CI_6_6.js";
+const he = class he {
   constructor(n) {
-    /** World-space center xyz; w is the drawable flag (1 draw, 0 modifier-hidden). */
+    /** World-space center xyz; w is display opacity (`visibility × source opacity ×` RAD modifier ratio). */
     s(this, "centers");
     /** Resolved color and opacity per work slot. */
     s(this, "colors");
@@ -23,8 +23,8 @@ const ue = class ue {
     s(this, "isotropicScreenRadius");
     s(this, "mirrors");
     this.capacity = n;
-    const e = n + ue.SCRATCH_SLOTS;
-    this.centers = new l.StorageBufferAttribute(new Float32Array(e * 4), 4), this.colors = new l.StorageBufferAttribute(new Float32Array(e * 4), 4), this.covarianceA = new l.StorageBufferAttribute(new Float32Array(e * 4), 4), this.covarianceB = new l.StorageBufferAttribute(new Float32Array(e * 4), 4), this.isotropicMix = new l.StorageBufferAttribute(new Float32Array(e), 1), this.isotropicScreenRadius = new l.StorageBufferAttribute(new Float32Array(e), 1), this.mirrors = new ke([
+    const e = n + he.SCRATCH_SLOTS;
+    this.centers = new l.StorageBufferAttribute(new Float32Array(e * 4), 4), this.colors = new l.StorageBufferAttribute(new Float32Array(e * 4), 4), this.covarianceA = new l.StorageBufferAttribute(new Float32Array(e * 4), 4), this.covarianceB = new l.StorageBufferAttribute(new Float32Array(e * 4), 4), this.isotropicMix = new l.StorageBufferAttribute(new Float32Array(e), 1), this.isotropicScreenRadius = new l.StorageBufferAttribute(new Float32Array(e), 1), this.mirrors = new De([
       this.centers,
       this.colors,
       this.covarianceA,
@@ -57,9 +57,9 @@ const ue = class ue {
  * same, silently, and cannot disturb a drawn slot: admission never allocates
  * past `capacity` and the draw's `instanceCount` never covers it.
  */
-s(ue, "SCRATCH_SLOTS", 256);
-let le = ue;
-class ht {
+s(he, "SCRATCH_SLOTS", 256);
+let de = he;
+class ft {
   constructor(n) {
     /** World-space `xyzw` center buffer, one element per unified work slot. */
     s(this, "centers");
@@ -73,92 +73,94 @@ class ht {
     /** Shared target for this source's gathered range. */
     s(this, "workBuffer");
     s(this, "capacity");
-    s(this, "activeCount", w(0));
-    s(this, "targetOffset", w(0));
-    s(this, "sourceMatrix", w(new l.Matrix4()));
-    s(this, "cameraViewMatrix", w(new l.Matrix4()));
-    s(this, "opacity", w(1));
+    s(this, "activeCount", x(0));
+    s(this, "targetOffset", x(0));
+    s(this, "sourceMatrix", x(new l.Matrix4()));
+    s(this, "cameraViewMatrix", x(new l.Matrix4()));
+    s(this, "opacity", x(1));
     s(this, "pass");
     const {
       capacity: e,
-      sourceCapacity: o,
+      sourceCapacity: i,
       sourceIndex: a,
       centersTexture: c,
-      colorsTexture: g,
-      covarianceATexture: b,
+      colorsTexture: S,
+      covarianceATexture: B,
       covarianceBTexture: u,
-      dataTextureWidth: p
-    } = n, T = n.sh ?? null, V = n.modifiers ?? [], P = n.channels ?? /* @__PURE__ */ new Map(), m = n.localCameraPosition ?? w(new l.Vector3());
-    this.workBuffer = n.workBuffer ?? new le(e), this.capacity = this.workBuffer.capacity, this.centers = this.workBuffer.centers, this.colors = this.workBuffer.colors, this.covarianceA = this.workBuffer.covarianceA, this.covarianceB = this.workBuffer.covarianceB, this.isotropicMix = this.workBuffer.isotropicMix, this.isotropicScreenRadius = this.workBuffer.isotropicScreenRadius;
-    const v = C(a, "uint", o), A = C(this.centers, "vec4", e), k = C(this.colors, "vec4", e), t = C(this.covarianceA, "vec4", e), i = C(this.covarianceB, "vec4", e), d = C(this.isotropicMix, "float", e), B = C(this.isotropicScreenRadius, "float", e);
-    this.pass = we(() => {
-      ze(R(ce).lessThan(this.activeCount), () => {
-        const y = ve(v.element(ce)), f = We(
-          y.mod(ve(p)),
-          y.div(ve(p))
-        ), S = ee(c, f).xyz, x = ce.add(this.targetOffset.toUint()), F = ee(b, f), U = ee(u, f), L = Ae(
-          D(F.x, F.y, F.z),
-          D(F.y, F.w, U.x),
-          D(F.z, U.x, U.y)
-        ), E = ee(g, f), W = T === null ? E : M(
-          E.rgb.add(
-            He(
-              T,
+      dataTextureWidth: f
+    } = n, D = n.sh ?? null, V = n.modifiers ?? [], T = n.channels ?? /* @__PURE__ */ new Map(), y = n.localCameraPosition ?? x(new l.Vector3());
+    this.workBuffer = n.workBuffer ?? new de(e), this.capacity = this.workBuffer.capacity, this.centers = this.workBuffer.centers, this.colors = this.workBuffer.colors, this.covarianceA = this.workBuffer.covarianceA, this.covarianceB = this.workBuffer.covarianceB, this.isotropicMix = this.workBuffer.isotropicMix, this.isotropicScreenRadius = this.workBuffer.isotropicScreenRadius;
+    const p = k(a, "uint", i), M = k(this.centers, "vec4", e), P = k(this.colors, "vec4", e), r = k(this.covarianceA, "vec4", e), o = k(this.covarianceB, "vec4", e), d = k(this.isotropicMix, "float", e), w = k(this.isotropicScreenRadius, "float", e);
+    this.pass = ye(() => {
+      ze(A(ue).lessThan(this.activeCount), () => {
+        const b = Se(p.element(ue)), m = Ie(
+          b.mod(Se(f)),
+          b.div(Se(f))
+        ), g = ee(c, m).xyz, v = ue.add(this.targetOffset.toUint()), F = ee(B, m), G = ee(u, m), E = Re(
+          R(F.x, F.y, F.z),
+          R(F.y, F.w, G.x),
+          R(F.z, G.x, G.y)
+        ), L = ee(S, m), O = D === null ? L : C(
+          L.rgb.add(
+            Ke(
+              D,
               { covarianceBTexture: u },
-              f,
-              S.sub(m).normalize()
+              m,
+              g.sub(y).normalize()
             )
           ).clamp(0, 1),
-          E.a
-        ), j = this.sourceMatrix.mul(M(S, 1)).xyz, h = Ke(V, m, {
-          index: y,
-          localCenter: S,
-          color: W,
-          makeWorldCenter: () => j,
-          makeViewCenter: () => this.cameraViewMatrix.mul(M(j, 1)).xyz,
+          L.a
+        ), W = this.sourceMatrix.mul(C(g, 1)).xyz, h = Xe(V, y, {
+          index: b,
+          localCenter: g,
+          color: O,
+          makeWorldCenter: () => W,
+          makeViewCenter: () => this.cameraViewMatrix.mul(C(W, 1)).xyz,
           makeNormal: () => {
-            const G = L.inverse(), H = m.sub(S), ie = G.mul(G.mul(H)).normalize();
-            return ie.mul(ie.dot(H).sign());
+            const U = E.inverse(), X = y.sub(g), ne = U.mul(U.mul(X)).normalize();
+            return ne.mul(ne.dot(X).sign());
           },
-          makeChannel: (G) => {
-            const H = P.get(G);
-            if (!H)
+          makeChannel: (U) => {
+            const X = T.get(U);
+            if (!X)
               throw new Error(
-                `UnifiedSplatMesh: source modifier reads undefined channel "${G}".`
+                `UnifiedSplatMesh: source modifier reads undefined channel "${U}".`
               );
-            return ee(H.texture, f).r;
+            return ee(X.texture, m).r;
           }
-        }), I = h.offset === null ? S : S.add(h.offset), N = h.visible === null ? Ie(!0) : h.visible, Z = this.sourceMatrix.mul(M(I, 1)).xyz;
-        A.element(x).assign(M(Z, N.select(R(1), R(0))));
-        const $ = n.srgbOutput ? h.color : ne(Ne(h.color, l.SRGBColorSpace)), de = n.lodAlpha ? ne($.a.mul(2)) : ne($.a);
-        k.element(x).assign(M($.rgb, N.select(de.mul(this.opacity), R(0))));
-        const se = h.rotation === null ? L : h.rotation.mul(L).mul(h.rotation.transpose());
-        let K = ne(se);
+        }), j = h.offset === null ? g : g.add(h.offset), N = h.visible === null ? Ne(!0) : h.visible, _ = this.sourceMatrix.mul(C(j, 1)).xyz, q = le(O.a), fe = le(h.color.a), ie = N.select(A(1), A(0)), Y = n.srgbOutput ? h.color : le(_e(h.color, l.SRGBColorSpace));
+        if (n.lodAlpha) {
+          const U = q.greaterThan(0).select(fe.div(q.max(1e-8)), A(1));
+          M.element(v).assign(C(_, ie.mul(this.opacity).mul(U))), P.element(v).assign(C(Y.rgb, q.mul(2)));
+        } else
+          M.element(v).assign(C(_, ie.mul(this.opacity))), P.element(v).assign(C(Y.rgb, Y.a));
+        const oe = h.rotation === null ? E : h.rotation.mul(E).mul(h.rotation.transpose());
+        let z = le(oe);
         if (h.isotropicCovarianceMix !== null) {
-          const G = h.isotropicVarianceScale ?? R(Xe);
-          K = Ye(
-            K,
-            D(0, 0, 1),
+          const U = h.isotropicVarianceScale ?? A(Ye);
+          z = Ze(
+            z,
+            R(0, 0, 1),
             h.isotropicCovarianceMix,
-            G
+            U
           );
         }
-        const _ = this.sourceMatrix.toMat3(), X = _.mul(K).mul(_.transpose()), O = h.scaleSquared === null ? X : X.mul(h.scaleSquared), q = O.mul(D(1, 0, 0)), Q = O.mul(D(0, 1, 0)), he = O.mul(D(0, 0, 1));
-        t.element(x).assign(M(q.x, q.y, q.z, Q.y)), i.element(x).assign(M(Q.z, he.z, 0, 0)), d.element(x).assign(h.isotropicCovarianceMix === null ? R(0) : h.isotropicCovarianceMix), B.element(x).assign(
-          h.isotropicCovarianceMix === null ? R(0) : h.isotropicScreenRadiusPx ?? R(0)
+        const Z = this.sourceMatrix.toMat3(), H = Z.mul(z).mul(Z.transpose()), K = h.scaleSquared === null ? H : H.mul(h.scaleSquared), $ = K.mul(R(1, 0, 0)), ae = K.mul(R(0, 1, 0)), pe = K.mul(R(0, 0, 1));
+        r.element(v).assign(C($.x, $.y, $.z, ae.y)), o.element(v).assign(C(ae.z, pe.z, 0, 0)), d.element(v).assign(h.isotropicCovarianceMix === null ? A(0) : h.isotropicCovarianceMix), w.element(v).assign(
+          h.isotropicCovarianceMix === null ? A(0) : h.isotropicScreenRadiusPx ?? A(0)
         );
       });
-    })().compute(o, [256]);
+    })().compute(i, [256]);
   }
   /** Gathers a source's active pool slots into a contiguous work-buffer range. */
-  gather(n, e, o, a, c = new l.Matrix4(), g = 1) {
-    if (e < 0 || o < 0 || o + e > this.capacity)
+  gather(n, e, i, a, c = new l.Matrix4(), S = 1) {
+    if (e < 0 || i < 0 || i + e > this.capacity)
       throw new Error("WorkBufferGather: requested range exceeds work-buffer capacity.");
-    this.activeCount.value = e, this.targetOffset.value = o, this.sourceMatrix.value.copy(a);
-    const b = typeof c == "number" ? new l.Matrix4() : c;
-    this.cameraViewMatrix.value.copy(b), this.opacity.value = Math.max(
+    this.activeCount.value = e, this.targetOffset.value = i, this.sourceMatrix.value.copy(a);
+    const B = typeof c == "number" ? new l.Matrix4() : c;
+    this.cameraViewMatrix.value.copy(B), this.opacity.value = Math.max(
       0,
-      typeof c == "number" ? c : g
+      typeof c == "number" ? c : S
     ), this.pass.count = e, n.compute(this.pass), this.workBuffer.releaseCpuMirrors(n);
   }
   /**
@@ -187,112 +189,112 @@ class ht {
     this.pass.dispose();
   }
 }
-function Pe(r) {
-  const n = new l.NodeMaterial(), e = C(r.centers, "vec4", r.capacity), o = C(r.order, "float", r.capacity), a = C(r.colors, "vec4", r.capacity), c = C(r.covarianceA, "vec4", r.capacity), g = C(r.covarianceB, "vec4", r.capacity), b = C(r.isotropicMix, "float", r.capacity), u = C(r.isotropicScreenRadius, "float", r.capacity), p = oe(M(1, 1, 1, 1), "vWorkColor"), T = oe(ge.xy, "vWorkQuadPosition"), V = oe(R(1), "vWorkOpacityCompensation"), P = oe(R(0), "vWorkAdjustedStdDev");
-  return n.vertexNode = we(() => {
-    const m = o.element(ce).toInt(), v = e.element(m), A = v.xyz, k = v.w.greaterThan(0.5);
-    p.assign(a.element(m));
-    const t = Ce.mul(M(A, 1)).toVar(), i = _e.mul(t).toVar(), d = c.element(m), B = g.element(m), y = Ae(
-      D(d.x, d.y, d.z),
-      D(d.y, d.w, B.x),
-      D(d.z, B.x, B.y)
-    ), f = R(1).div(t.z), S = f.mul(f), x = D(
-      r.focal.x.mul(f),
+function ke(t) {
+  const n = new l.NodeMaterial(), e = k(t.centers, "vec4", t.capacity), i = k(t.order, "float", t.capacity), a = k(t.colors, "vec4", t.capacity), c = k(t.covarianceA, "vec4", t.capacity), S = k(t.covarianceB, "vec4", t.capacity), B = k(t.isotropicMix, "float", t.capacity), u = k(t.isotropicScreenRadius, "float", t.capacity), f = te(C(1, 1, 1, 1), "vWorkColor"), D = te(we.xy, "vWorkQuadPosition"), V = te(A(1), "vWorkOpacityCompensation"), T = te(A(1), "vWorkDisplayOpacity"), y = te(A(0), "vWorkAdjustedStdDev");
+  return n.vertexNode = ye(() => {
+    const p = i.element(ue).toInt(), M = e.element(p), P = M.xyz, r = M.w.greaterThan(0);
+    T.assign(M.w), f.assign(a.element(p));
+    const o = Ae.mul(C(P, 1)).toVar(), d = qe.mul(o).toVar(), w = c.element(p), b = S.element(p), m = Re(
+      R(w.x, w.y, w.z),
+      R(w.y, w.w, b.x),
+      R(w.z, b.x, b.y)
+    ), g = A(1).div(o.z), v = g.mul(g), F = R(
+      t.focal.x.mul(g),
       0,
-      r.focal.x.negate().mul(t.x).mul(S)
-    ), F = D(
+      t.focal.x.negate().mul(o.x).mul(v)
+    ), G = R(
       0,
-      r.focal.y.mul(f),
-      r.focal.y.negate().mul(t.y).mul(S)
-    ), U = Ce.toMat3().transpose(), L = U.mul(x), E = U.mul(F), W = L.dot(y.mul(L)), j = E.dot(y.mul(E)), h = L.dot(y.mul(E)), I = t.z.negate().max(1e-4), N = r.dofFocusDistance.max(1e-4), Z = r.dofAperture.max(0).mul(0.5).div(N).atan(), $ = I.sub(N).abs().div(I), de = r.focal.x.mul(Z.tan()), se = $.mul(de), K = se.mul(se).min(R(Ze)), _ = W.add(r.projectedLowPassVariance).add(K), X = j.add(r.projectedLowPassVariance).add(K), O = h, q = b.element(m), Q = _.mul(X).sub(O.mul(O)).max(1e-9), he = W.mul(j).sub(h.mul(h)).max(0), G = W.add(r.projectedLowPassVariance).mul(j.add(r.projectedLowPassVariance)).sub(h.mul(h)).max(1e-9), H = he.div(Q).sqrt(), ie = G.div(Q).sqrt(), De = r.antialias.max(r.compensateProjectedLowPass), Te = ae(ie, H, De);
-    V.assign(ae(Te, R(1), q));
-    const xe = _.add(X).mul(0.5), ye = z(_.sub(X).mul(0.5), O).length();
-    let Y = xe.add(ye), J = xe.sub(ye).max(0);
-    const be = $e(Y, J, q);
-    Y = be.lambda1, J = be.lambda2;
-    const Be = Qe(
-      Y,
+      t.focal.y.mul(g),
+      t.focal.y.negate().mul(o.y).mul(v)
+    ), E = Ae.toMat3().transpose(), L = E.mul(F), O = E.mul(G), W = L.dot(m.mul(L)), h = O.dot(m.mul(O)), j = L.dot(m.mul(O)), N = o.z.negate().max(1e-4), _ = t.dofFocusDistance.max(1e-4), q = t.dofAperture.max(0).mul(0.5).div(_).atan(), fe = N.sub(_).abs().div(N), ie = t.focal.x.mul(q.tan()), Y = fe.mul(ie), oe = Y.mul(Y).min(A($e)), z = W.add(t.projectedLowPassVariance).add(oe), Z = h.add(t.projectedLowPassVariance).add(oe), H = j, K = B.element(p), $ = z.mul(Z).sub(H.mul(H)).max(1e-9), ae = W.mul(h).sub(j.mul(j)).max(0), pe = W.add(t.projectedLowPassVariance).mul(h.add(t.projectedLowPassVariance)).sub(j.mul(j)).max(1e-9), U = ae.div($).sqrt(), X = pe.div($).sqrt(), ne = t.antialias.max(t.compensateProjectedLowPass), Fe = ce(X, U, ne);
+    V.assign(ce(Fe, A(1), K));
+    const be = z.add(Z).mul(0.5), Be = I(z.sub(Z).mul(0.5), H).length();
+    let Q = be.add(Be), J = be.sub(Be).max(0);
+    const Me = Qe(Q, J, K);
+    Q = Me.lambda1, J = Me.lambda2;
+    const Ce = Je(
+      Q,
       J,
-      q,
-      u.element(m),
-      r.maxStdDev
+      K,
+      u.element(p),
+      t.maxStdDev
     );
-    Y = Be.lambda1, J = Be.lambda2;
-    const Fe = p.a.mul(4).sub(3).min(5), fe = p.a.greaterThan(1).select(r.maxStdDev.add(Fe.sub(1).mul(0.7)), r.maxStdDev);
-    P.assign(fe);
-    const pe = z(O, Y.sub(_)).add(z(1e-6, 0)).normalize(), Me = r.minSplatSizePx, Le = pe.mul(Y.sqrt().mul(fe).min(1024).max(Me)), Ue = z(pe.y, pe.x.negate()).mul(
-      J.sqrt().mul(fe).min(1024).max(Me)
-    ), Ee = Le.mul(ge.x).add(Ue.mul(ge.y)), Ve = i.xy.div(i.w), Ge = M(
-      Ve.add(Ee.mul(2).div(r.viewport)),
-      i.z.div(i.w),
+    Q = Ce.lambda1, J = Ce.lambda2;
+    const Le = f.a.mul(4).sub(3).min(5), me = f.a.greaterThan(1).select(t.maxStdDev.add(Le.sub(1).mul(0.7)), t.maxStdDev);
+    y.assign(me);
+    const ve = I(H, Q.sub(z)).add(I(1e-6, 0)).normalize(), Pe = t.minSplatSizePx, Ue = ve.mul(Q.sqrt().mul(me).min(1024).max(Pe)), Ee = I(ve.y, ve.x.negate()).mul(
+      J.sqrt().mul(me).min(1024).max(Pe)
+    ), Ve = Ue.mul(we.x).add(Ee.mul(we.y)), Ge = d.xy.div(d.w), Oe = C(
+      Ge.add(Ve.mul(2).div(t.viewport)),
+      d.z.div(d.w),
       1
-    ), me = i.w.mul(1.2);
-    return i.z.greaterThan(me.negate()).and(i.x.abs().lessThan(me)).and(i.y.abs().lessThan(me)).and(k).select(Ge, M(0, 0, 2, 1));
-  })(), n.fragmentNode = we(() => {
-    const m = T.dot(T);
-    qe(m.greaterThan(1));
-    const v = m.mul(P.mul(P).mul(-0.5)).exp(), A = p.a.mul(4).sub(3).min(5), k = A.mul(A).sub(1).mul(1 / Math.E).exp(), t = v.oneMinus().pow(k).oneMinus(), d = p.a.greaterThan(1).select(t, v.mul(p.a)).mul(V), B = te(r.relightMap, re), y = r.relightSoftness.div(r.viewport.x.max(1)), f = r.relightSoftness.div(r.viewport.y.max(1)), S = B, x = te(r.relightMap, re.add(z(y, 0))), F = te(r.relightMap, re.add(z(y.negate(), 0))), U = te(r.relightMap, re.add(z(0, f))), L = te(r.relightMap, re.add(z(0, f.negate()))), E = S.a.add(x.a).add(F.a).add(U.a).add(L.a).max(1e-4), W = S.rgb.mul(S.a).add(x.rgb.mul(x.a)).add(F.rgb.mul(F.a)).add(U.rgb.mul(U.a)).add(L.rgb.mul(L.a)).div(E), j = E.mul(0.2), h = M(W, j), I = r.relightSoftness.greaterThan(0.5).select(h, B), N = ae(
-      D(r.relightBackground),
-      I.rgb.mul(r.relightBrightness),
-      I.a
-    ), Z = ae(p.rgb, p.rgb.mul(N), r.relightBlend);
-    return M(Z.mul(d), d);
+    ), ge = d.w.mul(1.2);
+    return d.z.greaterThan(ge.negate()).and(d.x.abs().lessThan(ge)).and(d.y.abs().lessThan(ge)).and(r).select(Oe, C(0, 0, 2, 1));
+  })(), n.fragmentNode = ye(() => {
+    const p = D.dot(D);
+    He(p.greaterThan(1));
+    const M = p.mul(y.mul(y).mul(-0.5)).exp(), P = f.a.mul(4).sub(3).min(5), r = P.mul(P).sub(1).mul(1 / Math.E).exp(), o = M.oneMinus().pow(r).oneMinus(), w = f.a.greaterThan(1).select(o, M.mul(f.a)).mul(V).mul(T), b = re(t.relightMap, se), m = t.relightSoftness.div(t.viewport.x.max(1)), g = t.relightSoftness.div(t.viewport.y.max(1)), v = b, F = re(t.relightMap, se.add(I(m, 0))), G = re(t.relightMap, se.add(I(m.negate(), 0))), E = re(t.relightMap, se.add(I(0, g))), L = re(t.relightMap, se.add(I(0, g.negate()))), O = v.a.add(F.a).add(G.a).add(E.a).add(L.a).max(1e-4), W = v.rgb.mul(v.a).add(F.rgb.mul(F.a)).add(G.rgb.mul(G.a)).add(E.rgb.mul(E.a)).add(L.rgb.mul(L.a)).div(O), h = O.mul(0.2), j = C(W, h), N = t.relightSoftness.greaterThan(0.5).select(j, b), _ = ce(
+      R(t.relightBackground),
+      N.rgb.mul(t.relightBrightness),
+      N.a
+    ), q = ce(f.rgb, f.rgb.mul(_), t.relightBlend);
+    return C(q.mul(w), w);
   })(), n.transparent = !0, n.depthTest = !0, n.depthWrite = !1, n.side = l.DoubleSide, n.blending = l.CustomBlending, n.blendSrc = l.OneFactor, n.blendDst = l.OneMinusSrcAlphaFactor, n.blendSrcAlpha = l.OneFactor, n.blendDstAlpha = l.OneMinusSrcAlphaFactor, n.toneMapped = !1, n;
 }
-const ft = 16, pt = 72;
-function Re(r) {
-  if (!Number.isFinite(r) || r < 0)
+const pt = 16, mt = 72;
+function Te(t) {
+  if (!Number.isFinite(t) || t < 0)
     throw new RangeError("Splat capacity must be a non-negative finite number.");
 }
-function mt(r) {
-  return Re(r), Math.floor(r) * ft;
+function vt(t) {
+  return Te(t), Math.floor(t) * pt;
 }
-function vt(r) {
-  return Re(r), Math.floor(r) * pt;
+function gt(t) {
+  return Te(t), Math.floor(t) * mt;
 }
-function Mt(r) {
-  return vt(r) * 2;
+function Ct(t) {
+  return gt(t) * 2;
 }
-function Se(r) {
+function xe(t) {
   var n;
-  return ((n = r.backend) == null ? void 0 : n.isWebGPUBackend) === !0;
+  return ((n = t.backend) == null ? void 0 : n.isWebGPUBackend) === !0;
 }
-class Ct extends l.Mesh {
-  constructor(e, o, a = {}) {
-    if (!Se(e))
+class Pt extends l.Mesh {
+  constructor(e, i, a = {}) {
+    if (!xe(e))
       throw new Error(
         "UnifiedSplatMesh requires a WebGPU backend (renderer.backend.isWebGPUBackend). On WebGL2 use standalone SplatMesh draws or static MergedSplatMesh."
       );
-    dt(e, mt(o), o);
-    const c = new le(o), g = w(new l.Vector2()), b = w(new l.Vector2()), u = w(3), p = w(0), T = w(0), V = w(0.3), P = w(0), m = w(10), v = w(0), A = Je(), k = w(0), t = w(et), i = w(tt), d = w(rt), B = new l.StorageInstancedBufferAttribute(new Float32Array(o), 1), y = new l.InstancedBufferGeometry();
-    y.setIndex([0, 1, 2, 0, 2, 3]), y.setAttribute(
+    ht(e, vt(i), i);
+    const c = new de(i), S = x(new l.Vector2()), B = x(new l.Vector2()), u = x(3), f = x(0), D = x(0), V = x(0.3), T = x(0), y = x(10), p = x(0), M = et(), P = x(0), r = x(tt), o = x(rt), d = x(st), w = new l.StorageInstancedBufferAttribute(new Float32Array(i), 1), b = new l.InstancedBufferGeometry();
+    b.setIndex([0, 1, 2, 0, 2, 3]), b.setAttribute(
       "position",
       new l.BufferAttribute(new Float32Array([-1, -1, 0, 1, -1, 0, 1, 1, 0, -1, 1, 0]), 3)
-    ), y.instanceCount = 0;
+    ), b.instanceCount = 0;
     super(
-      y,
-      Pe({
-        capacity: o,
+      b,
+      ke({
+        capacity: i,
         centers: c.centers,
         colors: c.colors,
         covarianceA: c.covarianceA,
         covarianceB: c.covarianceB,
         isotropicMix: c.isotropicMix,
         isotropicScreenRadius: c.isotropicScreenRadius,
-        order: B,
-        focal: g,
-        viewport: b,
+        order: w,
+        focal: S,
+        viewport: B,
         maxStdDev: u,
-        minSplatSizePx: p,
-        antialias: T,
+        minSplatSizePx: f,
+        antialias: D,
         projectedLowPassVariance: V,
-        compensateProjectedLowPass: P,
-        dofFocusDistance: m,
-        dofAperture: v,
-        relightMap: A,
-        relightBlend: k,
-        relightBrightness: t,
-        relightBackground: i,
+        compensateProjectedLowPass: T,
+        dofFocusDistance: y,
+        dofAperture: p,
+        relightMap: M,
+        relightBlend: P,
+        relightBrightness: r,
+        relightBackground: o,
         relightSoftness: d
       })
     );
@@ -359,26 +361,26 @@ class Ct extends l.Mesh {
     s(this, "overflowedSourceCount", 0);
     s(this, "overflowedSplatCount", 0);
     s(this, "disposed", !1);
-    const f = new Uint32Array(o);
-    for (let x = 0; x < o; x++) f[x] = x;
-    this.workBuffer = c, this.focal = g, this.viewport = b, this.maxStdDev = u, this.minSplatSizePx = p, this.antialias = T, this.projectedLowPassVariance = V, this.compensateProjectedLowPass = P, this.dofFocusDistance = m, this.dofAperture = v, this.relightPlaceholder = A, this.relightMap = A, this.relightBlend = k, this.relightBrightness = t, this.relightBackground = i, this.relightSoftness = d, this.srgbOutput = a.srgbOutput ?? !1, this.sortScheduler = new st(void 0, ut()), this.orderAttribute = B, this.workSourceIndex = new l.StorageBufferAttribute(f, 1), this.mirrors = new ke([this.workSourceIndex, this.orderAttribute]), this.renderer = e;
-    const S = {
+    const m = new Uint32Array(i);
+    for (let v = 0; v < i; v++) m[v] = v;
+    this.workBuffer = c, this.focal = S, this.viewport = B, this.maxStdDev = u, this.minSplatSizePx = f, this.antialias = D, this.projectedLowPassVariance = V, this.compensateProjectedLowPass = T, this.dofFocusDistance = y, this.dofAperture = p, this.relightPlaceholder = M, this.relightMap = M, this.relightBlend = P, this.relightBrightness = r, this.relightBackground = o, this.relightSoftness = d, this.srgbOutput = a.srgbOutput ?? !1, this.sortScheduler = new it(void 0, dt()), this.orderAttribute = w, this.workSourceIndex = new l.StorageBufferAttribute(m, 1), this.mirrors = new De([this.workSourceIndex, this.orderAttribute]), this.renderer = e;
+    const g = {
       renderer: e,
-      capacity: o,
+      capacity: i,
       centersBuffer: c.centers,
-      splatIndexAttribute: B,
+      splatIndexAttribute: w,
       sourceIndexAttribute: this.workSourceIndex
     };
-    this.sorter = a.sortStrategy === "exact" ? new lt({ ...S, exactDepth: !0 }) : new it(S), this.frustumCulled = !1, this.matrixAutoUpdate = !1, this.matrix.identity(), this.matrixWorld.identity();
+    this.sorter = a.sortStrategy === "exact" ? new ut({ ...g, exactDepth: !0 }) : new ot(g), this.frustumCulled = !1, this.matrixAutoUpdate = !1, this.matrix.identity(), this.matrixWorld.identity();
   }
   /** Fixed work-buffer splat capacity chosen at construction. */
   get capacity() {
     return this.workBuffer.capacity;
   }
   /** Registers a source. The caller keeps ownership and may still query it. */
-  addSource(e, o = {}) {
-    if (this.assertNotDisposed("addSource"), this.sources.some((g) => g.source === e)) return;
-    const a = e.getUnifiedSourceView(), c = o.visible ?? e.visible;
+  addSource(e, i = {}) {
+    if (this.assertNotDisposed("addSource"), this.sources.some((S) => S.source === e)) return;
+    const a = e.getUnifiedSourceView(), c = i.visible ?? e.visible;
     if (a.hasSourcePlacement)
       throw new Error(
         "UnifiedSplatMesh: a MergedSplatMesh is already a unified pool with its own global sort; add its sources individually, or draw the mesh directly."
@@ -399,18 +401,18 @@ class Ct extends l.Mesh {
       throw new Error("UnifiedSplatMesh: every source must use the same antialias setting.");
     if (this.sourceProjectedFilterProfile === null) {
       this.sourceProjectedFilterProfile = a.projectedFilterProfile;
-      const g = a.projectedFilterProfile === "lcc";
-      this.projectedLowPassVariance.value = g ? 0.1 : 0.3, this.compensateProjectedLowPass.value = g ? 1 : 0;
+      const S = a.projectedFilterProfile === "lcc";
+      this.projectedLowPassVariance.value = S ? 0.1 : 0.3, this.compensateProjectedLowPass.value = S ? 1 : 0;
     } else if (this.sourceProjectedFilterProfile !== a.projectedFilterProfile)
       throw new Error("UnifiedSplatMesh: every source must use the same projected filter profile.");
     this.sources.push({
       source: e,
       gather: this.createGather(a),
       graphRevision: a.graphRevision,
-      priority: o.priority ?? 0,
-      opacity: o.opacity ?? 1,
+      priority: i.priority ?? 0,
+      opacity: i.opacity ?? 1,
       visible: c,
-      cacheModifiers: o.cacheModifiers ?? !1,
+      cacheModifiers: i.cacheModifiers ?? !1,
       originalVisible: e.visible,
       lastGather: null,
       view: null,
@@ -428,8 +430,8 @@ class Ct extends l.Mesh {
    */
   invalidateSource(e) {
     this.assertNotDisposed("invalidateSource");
-    const o = this.sources.find((a) => a.source === e);
-    return o ? (o.lastGather = null, !0) : !1;
+    const i = this.sources.find((a) => a.source === e);
+    return i ? (i.lastGather = null, !0) : !1;
   }
   /** Number of whole sources omitted in the most recent update due to capacity. */
   get droppedSourceCount() {
@@ -439,19 +441,25 @@ class Ct extends l.Mesh {
   get droppedSplatCount() {
     return this.overflowedSplatCount;
   }
-  /** Updates a source's resolved opacity without rebuilding its gather pipeline. */
-  setSourceOpacity(e, o) {
+  /**
+   * Sets whole-source display opacity without rebuilding the gather pipeline.
+   *
+   * This scales the completed fragment after RAD merged-vs-leaf classification
+   * and falloff. It must never alter LOD selection or splat shape; hosts such as
+   * marker crossfades rely on that. Values `<= 0` skip drawing the source.
+   */
+  setSourceOpacity(e, i) {
     this.assertNotDisposed("setSourceOpacity");
     const a = this.sources.find((c) => c.source === e);
     if (!a) throw new Error("UnifiedSplatMesh: source is not registered.");
-    a.opacity = o;
+    a.opacity = i;
   }
   /** Shows or hides a source without changing its residency. */
-  setSourceVisible(e, o) {
+  setSourceVisible(e, i) {
     this.assertNotDisposed("setSourceVisible");
     const a = this.sources.find((c) => c.source === e);
     if (!a) throw new Error("UnifiedSplatMesh: source is not registered.");
-    a.visible = o, a.source.setUnifiedPickVisibility(o);
+    a.visible = i, a.source.setUnifiedPickVisibility(i);
   }
   /**
    * Core projected-2D depth of field on the unified draw pass (not gather).
@@ -459,8 +467,8 @@ class Ct extends l.Mesh {
    */
   setDepthOfField(e) {
     this.assertNotDisposed("setDepthOfField");
-    const o = ot(e, this.getDepthOfField());
-    this.dofFocusDistance.value = o.focusDistance, this.dofAperture.value = o.aperture;
+    const i = at(e, this.getDepthOfField());
+    this.dofFocusDistance.value = i.focusDistance, this.dofAperture.value = i.aperture;
   }
   /** Current core DoF uniforms (`aperture === 0` means off). */
   getDepthOfField() {
@@ -479,8 +487,8 @@ class Ct extends l.Mesh {
       this.relightBlend.value = 0, this.relightMap !== this.relightPlaceholder && (this.relightMap = this.relightPlaceholder, this.rebuildDrawMaterial());
       return;
     }
-    const o = at(e, this.getRelighting());
-    this.relightBlend.value = o.blend, this.relightBrightness.value = o.brightness, this.relightBackground.value = o.background, this.relightSoftness.value = o.softness, e.map !== this.relightMap && (this.relightMap = e.map, this.rebuildDrawMaterial());
+    const i = nt(e, this.getRelighting());
+    this.relightBlend.value = i.blend, this.relightBrightness.value = i.brightness, this.relightBackground.value = i.background, this.relightSoftness.value = i.softness, e.map !== this.relightMap && (this.relightMap = e.map, this.rebuildDrawMaterial());
   }
   /** Current relight numeric uniforms (`blend === 0` means off). */
   getRelighting() {
@@ -507,31 +515,31 @@ class Ct extends l.Mesh {
    * serializes its own picks and shared renderer state is restored
    * synchronously before any await.
    */
-  async pick(e, o, a) {
+  async pick(e, i, a) {
     if (this.disposed) return null;
     const c = this.sources.filter((u) => u.visible).map((u) => u.source);
     if (c.length === 0) return null;
-    const g = await Promise.all(
+    const S = await Promise.all(
       c.map(async (u) => {
-        const p = await u.pick(e, o, this.renderer, a);
-        return p === null ? null : { source: u, point: p.point, distance: p.distance };
+        const f = await u.pick(e, i, this.renderer, a);
+        return f === null ? null : { source: u, point: f.point, distance: f.distance };
       })
     );
     if (this.disposed) return null;
-    let b = null;
-    for (const u of g) {
+    let B = null;
+    for (const u of S) {
       if (u === null) continue;
-      const p = this.sources.find((T) => T.source === u.source);
-      p === void 0 || !p.visible || (b === null || u.distance < b.distance) && (b = u);
+      const f = this.sources.find((D) => D.source === u.source);
+      f === void 0 || !f.visible || (B === null || u.distance < B.distance) && (B = u);
     }
-    return b;
+    return B;
   }
   /** Unregisters a source and restores its standalone draw visibility. */
   removeSource(e) {
     this.assertNotDisposed("removeSource");
-    const o = this.sources.findIndex((c) => c.source === e);
-    if (o < 0) return !1;
-    const [a] = this.sources.splice(o, 1);
+    const i = this.sources.findIndex((c) => c.source === e);
+    if (i < 0) return !1;
+    const [a] = this.sources.splice(i, 1);
     return a && (a.gather.dispose(), a.source.visible = a.originalVisible, a.source.setUnifiedPickVisibility(null), a.lastGather = null), this.previousLayout = this.previousLayout.filter((c) => c.source !== e), this.previousLayoutBySource.delete(e), this.sources.length === 0 && (this.sourceMaxStdDev = null, this.sourceAntialias = null, this.sourceProjectedFilterProfile = null, this.previousLayout = [], this.previousLayoutBySource.clear()), !0;
   }
   /** Updates source LODs, gathers their active splats, then globally sorts them. */
@@ -543,119 +551,119 @@ class Ct extends l.Mesh {
    * Mirrors and portals use this instead of rendering the hidden source meshes
    * individually, so their reflection keeps one global transparent order.
    */
-  renderView(e, o, a = null) {
+  renderView(e, i, a = null) {
     if (this.disposed) return;
-    if (o !== this.renderer)
+    if (i !== this.renderer)
       throw new Error("UnifiedSplatMesh: renderView must use its construction renderer.");
-    if (!Se(o))
+    if (!xe(i))
       throw new Error(
         "UnifiedSplatMesh requires a WebGPU backend (renderer.backend.isWebGPUBackend)."
       );
     const c = a ? this.secondaryViewSize.set(a.width, a.height) : void 0;
     this.prepare(e, c, !0);
-    const g = o.getRenderTarget();
+    const S = i.getRenderTarget();
     try {
-      o.setRenderTarget(a), o.render(this, e);
+      i.setRenderTarget(a), i.render(this, e);
     } finally {
-      o.setRenderTarget(g), this.sortScheduler.invalidate();
+      i.setRenderTarget(S), this.sortScheduler.invalidate();
     }
   }
-  prepare(e, o, a = !1) {
-    if (!Se(this.renderer))
+  prepare(e, i, a = !1) {
+    if (!xe(this.renderer))
       throw new Error(
         "UnifiedSplatMesh requires a WebGPU backend (renderer.backend.isWebGPUBackend)."
       );
     this.matrix.identity(), this.matrixWorld.identity();
-    const c = o ? null : nt(e, this.renderer), g = (c == null ? void 0 : c.eye) ?? e, b = (c == null ? void 0 : c.head) ?? e, u = this.drawingBufferSize;
-    o ? u.copy(o) : c ? u.set(c.width, c.height) : this.renderer.getDrawingBufferSize(u);
-    const p = g.projectionMatrix.elements;
+    const c = i ? null : ct(e, this.renderer), S = (c == null ? void 0 : c.eye) ?? e, B = (c == null ? void 0 : c.head) ?? e, u = this.drawingBufferSize;
+    i ? u.copy(i) : c ? u.set(c.width, c.height) : this.renderer.getDrawingBufferSize(u);
+    const f = S.projectionMatrix.elements;
     this.viewport.value.copy(u);
-    const T = p[0] ?? 0, V = p[5] ?? 0;
-    this.focal.value.set(T * u.x / 2, V * u.y / 2);
-    const P = this.candidateScratch;
-    P.length = 0;
-    for (let t = 0; t < this.sources.length; t++) {
-      const i = this.sources[t];
-      i.source.update(e, this.renderer, { sort: !1 }), i.view = i.source.getUnifiedSourceView(), i.registrationOrder = t, P.push(i);
+    const D = f[0] ?? 0, V = f[5] ?? 0;
+    this.focal.value.set(D * u.x / 2, V * u.y / 2);
+    const T = this.candidateScratch;
+    T.length = 0;
+    for (let r = 0; r < this.sources.length; r++) {
+      const o = this.sources[r];
+      o.source.update(e, this.renderer, { sort: !1 }), o.view = o.source.getUnifiedSourceView(), o.registrationOrder = r, T.push(o);
     }
-    P.sort((t, i) => i.priority - t.priority || t.registrationOrder - i.registrationOrder), this.overflowedSourceCount = 0, this.overflowedSplatCount = 0, this.bounds.makeEmpty();
-    const m = this.admittedScratch;
-    m.length = 0;
-    let v = 0;
-    for (const t of P) {
-      const i = t.view;
-      if (t.graphRevision !== i.graphRevision) {
-        const d = this.createGather(i);
-        t.gather.dispose(), t.gather = d, t.graphRevision = i.graphRevision, t.lastGather = null;
+    T.sort((r, o) => o.priority - r.priority || r.registrationOrder - o.registrationOrder), this.overflowedSourceCount = 0, this.overflowedSplatCount = 0, this.bounds.makeEmpty();
+    const y = this.admittedScratch;
+    y.length = 0;
+    let p = 0;
+    for (const r of T) {
+      const o = r.view;
+      if (r.graphRevision !== o.graphRevision) {
+        const d = this.createGather(o);
+        r.gather.dispose(), r.gather = d, r.graphRevision = o.graphRevision, r.lastGather = null;
       }
-      if (!t.visible) {
-        t.lastGather = null;
+      if (!r.visible) {
+        r.lastGather = null;
         continue;
       }
-      if (i.activeCount === 0) {
-        t.lastGather = null;
+      if (o.activeCount === 0) {
+        r.lastGather = null;
         continue;
       }
-      if (v + i.activeCount > this.workBuffer.capacity) {
-        this.overflowedSourceCount++, this.overflowedSplatCount += i.activeCount, t.lastGather = null;
+      if (p + o.activeCount > this.workBuffer.capacity) {
+        this.overflowedSourceCount++, this.overflowedSplatCount += o.activeCount, r.lastGather = null;
         continue;
       }
-      t.offset = v, m.push(t), this.bounds.union(i.worldBounds), v += i.activeCount;
+      r.offset = p, y.push(r), this.bounds.union(o.worldBounds), p += o.activeCount;
     }
-    let A = !1;
-    for (const t of m) {
-      const i = t.view, d = t.offset, B = this.previousLayoutBySource.get(t.source), y = B !== void 0 && B.offset === d && B.activeCount === i.activeCount, f = t.lastGather, S = f !== null && y && f.activeCount === i.activeCount && f.contentRevision === i.contentRevision && f.offset === d && f.opacity === t.opacity && f.matrixWorld.equals(i.matrixWorld);
-      S && // SH depends on camera position, not orientation. A stationary camera
+    let M = !1;
+    for (const r of y) {
+      const o = r.view, d = r.offset, w = this.previousLayoutBySource.get(r.source), b = w !== void 0 && w.offset === d && w.activeCount === o.activeCount, m = r.lastGather, g = m !== null && b && m.activeCount === o.activeCount && m.contentRevision === o.contentRevision && m.offset === d && m.opacity === r.opacity && m.matrixWorld.equals(o.matrixWorld);
+      g && // SH depends on camera position, not orientation. A stationary camera
       // can reuse the resolved colors instead of re-running a full-source
       // gather every frame; camera motion invalidates only SH-bearing slices.
-      (i.sh === null || f.localCameraPosition.equals(i.localCameraPosition.value)) && (i.modifiers.length === 0 || t.cacheModifiers) && // Belt-and-braces: a placed pool's splats move without its own
+      (o.sh === null || m.localCameraPosition.equals(o.localCameraPosition.value)) && (o.modifiers.length === 0 || r.cacheModifiers) && // Belt-and-braces: a placed pool's splats move without its own
       // `matrixWorld` changing, so a cached gather would go stale silently.
       // `addSource` already rejects these.
-      !i.hasSourcePlacement || (t.gather.gather(
+      !o.hasSourcePlacement || (r.gather.gather(
         this.renderer,
-        i.activeCount,
+        o.activeCount,
         d,
-        i.matrixWorld,
-        b.matrixWorldInverse,
-        t.opacity
-      ), S || (A = !0), t.lastGather === null ? t.lastGather = {
-        activeCount: i.activeCount,
-        contentRevision: i.contentRevision,
+        o.matrixWorld,
+        B.matrixWorldInverse,
+        r.opacity
+      ), g || (M = !0), r.lastGather === null ? r.lastGather = {
+        activeCount: o.activeCount,
+        contentRevision: o.contentRevision,
         offset: d,
-        opacity: t.opacity,
-        matrixWorld: i.matrixWorld.clone(),
-        localCameraPosition: i.localCameraPosition.value.clone()
-      } : (t.lastGather.activeCount = i.activeCount, t.lastGather.contentRevision = i.contentRevision, t.lastGather.offset = d, t.lastGather.opacity = t.opacity, t.lastGather.matrixWorld.copy(i.matrixWorld), t.lastGather.localCameraPosition.copy(i.localCameraPosition.value)));
+        opacity: r.opacity,
+        matrixWorld: o.matrixWorld.clone(),
+        localCameraPosition: o.localCameraPosition.value.clone()
+      } : (r.lastGather.activeCount = o.activeCount, r.lastGather.contentRevision = o.contentRevision, r.lastGather.offset = d, r.lastGather.opacity = r.opacity, r.lastGather.matrixWorld.copy(o.matrixWorld), r.lastGather.localCameraPosition.copy(o.localCameraPosition.value)));
     }
-    let k = m.length !== this.previousLayout.length || v !== this.previousAdmittedTotal;
-    if (this.previousAdmittedTotal = v, !k)
-      for (let t = 0; t < m.length; t++) {
-        const i = m[t], d = this.previousLayout[t];
-        if (d.source !== i.source || d.offset !== i.offset || d.activeCount !== i.view.activeCount) {
-          k = !0;
+    let P = y.length !== this.previousLayout.length || p !== this.previousAdmittedTotal;
+    if (this.previousAdmittedTotal = p, !P)
+      for (let r = 0; r < y.length; r++) {
+        const o = y[r], d = this.previousLayout[r];
+        if (d.source !== o.source || d.offset !== o.offset || d.activeCount !== o.view.activeCount) {
+          P = !0;
           break;
         }
       }
-    if (k) {
-      this.previousLayout = m.map((t) => ({
-        source: t.source,
-        offset: t.offset,
-        activeCount: t.view.activeCount
+    if (P) {
+      this.previousLayout = y.map((r) => ({
+        source: r.source,
+        offset: r.offset,
+        activeCount: r.view.activeCount
       })), this.previousLayoutBySource.clear();
-      for (const t of this.previousLayout) this.previousLayoutBySource.set(t.source, t);
+      for (const r of this.previousLayout) this.previousLayoutBySource.set(r.source, r);
     }
-    if ((A || k) && this.sortScheduler.invalidateContent(), v > 0) {
-      const t = performance.now(), i = b.matrixWorldInverse;
-      (a || this.sortScheduler.shouldSubmit(i, this.lastSortedModelView, v, t)) && this.sorter.sort(i, v, this.bounds) && (this.lastSortedModelView.copy(i), this.sortScheduler.markAccepted(t));
+    if ((M || P) && this.sortScheduler.invalidateContent(), p > 0) {
+      const r = performance.now(), o = B.matrixWorldInverse;
+      (a || this.sortScheduler.shouldSubmit(o, this.lastSortedModelView, p, r)) && this.sorter.sort(o, p, this.bounds) && (this.lastSortedModelView.copy(o), this.sortScheduler.markAccepted(r));
     }
-    this.geometry.instanceCount = v, this.mirrors.settled || this.mirrors.release(this.renderer);
+    this.geometry.instanceCount = p, this.mirrors.settled || this.mirrors.release(this.renderer);
   }
   dispose() {
     if (!this.disposed) {
       this.disposed = !0;
       for (const e of this.sources)
         e.gather.dispose(), e.source.visible = e.originalVisible, e.source.setUnifiedPickVisibility(null), e.lastGather = null;
-      this.sources.length = 0, this.previousLayout = [], this.previousLayoutBySource.clear(), this.candidateScratch.length = 0, this.admittedScratch.length = 0, this.sourceMaxStdDev = null, this.sourceAntialias = null, this.sourceProjectedFilterProfile = null, this.sorter.dispose(), this.geometry.dispose(), this.material.dispose(), this.relightPlaceholder.dispose(), ct(this.renderer, [
+      this.sources.length = 0, this.previousLayout = [], this.previousLayoutBySource.clear(), this.candidateScratch.length = 0, this.admittedScratch.length = 0, this.sourceMaxStdDev = null, this.sourceAntialias = null, this.sourceProjectedFilterProfile = null, this.sorter.dispose(), this.geometry.dispose(), this.material.dispose(), this.relightPlaceholder.dispose(), lt(this.renderer, [
         this.workBuffer.centers,
         this.workBuffer.colors,
         this.workBuffer.covarianceA,
@@ -674,7 +682,7 @@ class Ct extends l.Mesh {
   /** Rebuilds the EWA draw material when the relight map identity changes. */
   rebuildDrawMaterial() {
     const e = this.material;
-    this.material = Pe({
+    this.material = ke({
       capacity: this.workBuffer.capacity,
       centers: this.workBuffer.centers,
       colors: this.workBuffer.colors,
@@ -700,12 +708,12 @@ class Ct extends l.Mesh {
     }), e.dispose();
   }
   createGather(e) {
-    const o = this.buildGather(e);
-    return o.warmUp(this.renderer).catch(() => {
-    }), o;
+    const i = this.buildGather(e);
+    return i.warmUp(this.renderer).catch(() => {
+    }), i;
   }
   buildGather(e) {
-    return new ht({
+    return new ft({
       capacity: this.workBuffer.capacity,
       sourceCapacity: e.capacity,
       sourceIndex: e.sourceIndex,
@@ -727,12 +735,12 @@ class Ct extends l.Mesh {
   }
 }
 export {
-  Ct as UnifiedSplatMesh,
-  pt as WORK_BUFFER_BYTES_PER_SLOT,
-  ft as WORK_BUFFER_CENTERS_BYTES_PER_SPLAT,
-  mt as estimateLargestStorageBufferBytes,
-  vt as estimateUnifiedWorkBufferBytes,
-  Mt as estimateUnifiedWorkBufferPeakBytes,
-  Se as supportsUnifiedSplatMesh
+  Pt as UnifiedSplatMesh,
+  mt as WORK_BUFFER_BYTES_PER_SLOT,
+  pt as WORK_BUFFER_CENTERS_BYTES_PER_SPLAT,
+  vt as estimateLargestStorageBufferBytes,
+  gt as estimateUnifiedWorkBufferBytes,
+  Ct as estimateUnifiedWorkBufferPeakBytes,
+  xe as supportsUnifiedSplatMesh
 };
 //# sourceMappingURL=unified.js.map