@voluma/vlam 0.2.4 → 0.3.0

package/dist/unified.js

@@ -0,0 +1,738 @@
+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);
+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 {
+  constructor(n) {
+    /** World-space center xyz; w is the drawable flag (1 draw, 0 modifier-hidden). */
+    s(this, "centers");
+    /** Resolved color and opacity per work slot. */
+    s(this, "colors");
+    /** First packed covariance row per work slot. */
+    s(this, "covarianceA");
+    /** Second packed covariance row per work slot. */
+    s(this, "covarianceB");
+    /** Per-slot isotropic covariance mix (0 = keep Σ, 1 = round dot). */
+    s(this, "isotropicMix");
+    /** Per-slot isotropic target sigma radius in screen px (0 = disabled). */
+    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([
+      this.centers,
+      this.colors,
+      this.covarianceA,
+      this.covarianceB,
+      this.isotropicMix,
+      this.isotropicScreenRadius
+    ]);
+  }
+  /**
+   * Drops the JS-heap copies three keeps behind these storage buffers.
+   *
+   * Every one of them is written only by the gather compute pass and read only
+   * by the draw material - the CPU side is zeroes that no code ever reads, and
+   * three's WebGPU backend never frees it on its own. At 72 B/slot that mirror
+   * is ~720 MB of JS heap on a 10M-slot scene. See `storage-attribute-mirror`.
+   *
+   * Safe to call after any dispatch that bound this buffer; a no-op once
+   * settled, and on WebGL2 or a renderer double that has no WebGPU backend.
+   */
+  releaseCpuMirrors(n) {
+    this.mirrors.settled || this.mirrors.release(n);
+  }
+};
+/**
+ * Slots past {@link capacity}, reserved so a pipeline warm-up has somewhere
+ * harmless to write. See {@link WorkBufferGather.warmUp}: compiling a compute
+ * pipeline requires actually dispatching it, and dispatching zero workgroups
+ * - while it does compile - makes WebGPU log an "unusual workgroup count of 0"
+ * warning for every source. One workgroup aimed at this tail compiles just the
+ * 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 {
+  constructor(n) {
+    /** World-space `xyzw` center buffer, one element per unified work slot. */
+    s(this, "centers");
+    /** Resolved source RGBA values; production draw consumes this next. */
+    s(this, "colors");
+    /** Packed symmetric world-space covariance rows. */
+    s(this, "covarianceA");
+    s(this, "covarianceB");
+    s(this, "isotropicMix");
+    s(this, "isotropicScreenRadius");
+    /** 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, "pass");
+    const {
+      capacity: e,
+      sourceCapacity: o,
+      sourceIndex: a,
+      centersTexture: c,
+      colorsTexture: g,
+      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,
+              { covarianceBTexture: u },
+              f,
+              S.sub(m).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,
+          makeNormal: () => {
+            const G = L.inverse(), H = m.sub(S), ie = G.mul(G.mul(H)).normalize();
+            return ie.mul(ie.dot(H).sign());
+          },
+          makeChannel: (G) => {
+            const H = P.get(G);
+            if (!H)
+              throw new Error(
+                `UnifiedSplatMesh: source modifier reads undefined channel "${G}".`
+              );
+            return ee(H.texture, f).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);
+        if (h.isotropicCovarianceMix !== null) {
+          const G = h.isotropicVarianceScale ?? R(Xe);
+          K = Ye(
+            K,
+            D(0, 0, 1),
+            h.isotropicCovarianceMix,
+            G
+          );
+        }
+        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)
+        );
+      });
+    })().compute(o, [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)
+      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(
+      0,
+      typeof c == "number" ? c : g
+    ), this.pass.count = e, n.compute(this.pass), this.workBuffer.releaseCpuMirrors(n);
+  }
+  /**
+   * Compiles this gather's compute pipeline without gathering anything.
+   *
+   * WebGPU compiles a compute pipeline lazily, at its first dispatch - not when
+   * the node graph is built. Measured on a 13-mesh scene, a source's *first*
+   * `gather` took up to 2.0s while every later dispatch of the same pipeline
+   * took under 0.4ms, and because `gather` runs inside `update` that compile
+   * landed whole in one render frame. Running it through the async path here
+   * compiles off the critical frame, so the first real gather finds it ready.
+   *
+   * The dispatch targets {@link WorkBuffer.SCRATCH_SLOTS} past the drawable
+   * capacity rather than dispatching zero workgroups: zero also compiles, but
+   * WebGPU warns about it once per source, and writing into a drawn slot could
+   * leave junk behind when a cached gather is reused instead of re-run.
+   *
+   * Best-effort: a failure here costs only the stall it was meant to avoid, so
+   * callers may ignore it.
+   */
+  async warmUp(n) {
+    this.activeCount.value = 1, this.targetOffset.value = this.capacity, this.pass.count = 1, await n.computeAsync(this.pass), this.activeCount.value = 0, this.targetOffset.value = 0, this.workBuffer.releaseCpuMirrors(n);
+  }
+  /** Releases the gather pipeline. The owner releases the storage attribute. */
+  dispose() {
+    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),
+      0,
+      r.focal.x.negate().mul(t.x).mul(S)
+    ), F = D(
+      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,
+      J,
+      q,
+      u.element(m),
+      r.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),
+      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);
+  })(), 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)
+    throw new RangeError("Splat capacity must be a non-negative finite number.");
+}
+function mt(r) {
+  return Re(r), Math.floor(r) * ft;
+}
+function vt(r) {
+  return Re(r), Math.floor(r) * pt;
+}
+function Mt(r) {
+  return vt(r) * 2;
+}
+function Se(r) {
+  var n;
+  return ((n = r.backend) == null ? void 0 : n.isWebGPUBackend) === !0;
+}
+class Ct extends l.Mesh {
+  constructor(e, o, a = {}) {
+    if (!Se(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(
+      "position",
+      new l.BufferAttribute(new Float32Array([-1, -1, 0, 1, -1, 0, 1, 1, 0, -1, 1, 0]), 3)
+    ), y.instanceCount = 0;
+    super(
+      y,
+      Pe({
+        capacity: o,
+        centers: c.centers,
+        colors: c.colors,
+        covarianceA: c.covarianceA,
+        covarianceB: c.covarianceB,
+        isotropicMix: c.isotropicMix,
+        isotropicScreenRadius: c.isotropicScreenRadius,
+        order: B,
+        focal: g,
+        viewport: b,
+        maxStdDev: u,
+        minSplatSizePx: p,
+        antialias: T,
+        projectedLowPassVariance: V,
+        compensateProjectedLowPass: P,
+        dofFocusDistance: m,
+        dofAperture: v,
+        relightMap: A,
+        relightBlend: k,
+        relightBrightness: t,
+        relightBackground: i,
+        relightSoftness: d
+      })
+    );
+    s(this, "workBuffer");
+    s(this, "workSourceIndex");
+    /** The sorted draw-order buffer; lives outside the geometry, freed on dispose. */
+    s(this, "orderAttribute");
+    /**
+     * Frees the JS mirrors three keeps behind `workSourceIndex` and `order`.
+     *
+     * `workSourceIndex` is an identity ramp written once at construction; `order`
+     * is written only by the sorter, on the GPU. Neither is ever read back, so
+     * both mirrors are 4 B/slot of dead JS heap once uploaded.
+     */
+    s(this, "mirrors");
+    s(this, "sorter");
+    s(this, "renderer");
+    s(this, "sources", []);
+    s(this, "previousLayout", []);
+    /** Previous layout keyed by source; kept in step with {@link previousLayout}. */
+    s(this, "previousLayoutBySource", /* @__PURE__ */ new Map());
+    /** Per-prepare scratch lists, reused so a steady frame allocates nothing. */
+    s(this, "candidateScratch", []);
+    s(this, "admittedScratch", []);
+    s(this, "drawingBufferSize", new l.Vector2());
+    /** Reused target dimensions for secondary views; avoids per-view garbage. */
+    s(this, "secondaryViewSize", new l.Vector2());
+    /**
+     * Camera gating for the global sorter, mirroring the standalone
+     * `SplatMesh.requestSortIfNeeded` path: an unchanged work buffer under a
+     * stationary camera skips the whole-buffer re-sort. Content changes
+     * (regather, layout change) force the next sort through the scheduler.
+     */
+    s(this, "sortScheduler");
+    /** Model-view of the last accepted sort; starts unmatchable (zero scale). */
+    s(this, "lastSortedModelView", new l.Matrix4().makeScale(0, 0, 0));
+    /**
+     * Total admitted splats in the last prepared frame. `removeSource` filters
+     * {@link previousLayout} directly, so a tail source's removal can leave the
+     * remaining entries identical - only this total betrays the shrink, and a
+     * shrunk draw range must re-sort (the old permutation indexes past it).
+     */
+    s(this, "previousAdmittedTotal", 0);
+    s(this, "bounds", new l.Sphere());
+    s(this, "focal");
+    s(this, "viewport");
+    s(this, "maxStdDev");
+    s(this, "minSplatSizePx");
+    s(this, "antialias");
+    s(this, "projectedLowPassVariance");
+    s(this, "compensateProjectedLowPass");
+    s(this, "dofFocusDistance");
+    s(this, "dofAperture");
+    s(this, "relightPlaceholder");
+    s(this, "relightMap");
+    s(this, "relightBlend");
+    s(this, "relightBrightness");
+    s(this, "relightBackground");
+    s(this, "relightSoftness");
+    s(this, "srgbOutput");
+    s(this, "sourceMaxStdDev", null);
+    s(this, "sourceAntialias", null);
+    s(this, "sourceProjectedFilterProfile", null);
+    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 = {
+      renderer: e,
+      capacity: o,
+      centersBuffer: c.centers,
+      splatIndexAttribute: B,
+      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();
+  }
+  /** 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;
+    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."
+      );
+    if (a.srgbOutput !== this.srgbOutput)
+      throw new Error("UnifiedSplatMesh: every source must use the renderer's srgbOutput setting.");
+    if (this.sourceMaxStdDev === null)
+      this.sourceMaxStdDev = a.maxStdDev, this.maxStdDev.value = a.maxStdDev, this.minSplatSizePx.value = a.minSplatSizePx;
+    else {
+      if (this.sourceMaxStdDev !== a.maxStdDev)
+        throw new Error("UnifiedSplatMesh: every source must use the same maxStdDev setting.");
+      if (this.minSplatSizePx.value !== a.minSplatSizePx)
+        throw new Error("UnifiedSplatMesh: every source must use the same minSplatSizePx setting.");
+    }
+    if (this.sourceAntialias === null)
+      this.sourceAntialias = a.antialias, this.antialias.value = a.antialias ? 1 : 0;
+    else if (this.sourceAntialias !== a.antialias)
+      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;
+    } 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,
+      visible: c,
+      cacheModifiers: o.cacheModifiers ?? !1,
+      originalVisible: e.visible,
+      lastGather: null,
+      view: null,
+      registrationOrder: 0,
+      offset: 0
+    }), e.visible = !1, e.setUnifiedPickVisibility(c);
+  }
+  /**
+   * Invalidates one registered source's cached gather output.
+   *
+   * Required after changing modifier uniforms or channels when that source was
+   * registered with `cacheModifiers: true`. The following {@link update}
+   * re-gathers the source and re-sorts because modifiers may move splats.
+   * Returns `false` when the source is not registered.
+   */
+  invalidateSource(e) {
+    this.assertNotDisposed("invalidateSource");
+    const o = this.sources.find((a) => a.source === e);
+    return o ? (o.lastGather = null, !0) : !1;
+  }
+  /** Number of whole sources omitted in the most recent update due to capacity. */
+  get droppedSourceCount() {
+    return this.overflowedSourceCount;
+  }
+  /** Number of active splats omitted in the most recent update due to capacity. */
+  get droppedSplatCount() {
+    return this.overflowedSplatCount;
+  }
+  /** Updates a source's resolved opacity without rebuilding its gather pipeline. */
+  setSourceOpacity(e, o) {
+    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;
+  }
+  /** Shows or hides a source without changing its residency. */
+  setSourceVisible(e, o) {
+    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);
+  }
+  /**
+   * Core projected-2D depth of field on the unified draw pass (not gather).
+   * Live uniforms - no gather-cache invalidation. Pass `aperture: 0` to disable.
+   */
+  setDepthOfField(e) {
+    this.assertNotDisposed("setDepthOfField");
+    const o = ot(e, this.getDepthOfField());
+    this.dofFocusDistance.value = o.focusDistance, this.dofAperture.value = o.aperture;
+  }
+  /** Current core DoF uniforms (`aperture === 0` means off). */
+  getDepthOfField() {
+    return {
+      focusDistance: this.dofFocusDistance.value,
+      aperture: this.dofAperture.value
+    };
+  }
+  /**
+   * PlayCanvas-style proxy-mesh relighting on the unified draw pass (not gather).
+   * Live blend/brightness/background; map identity change rebuilds the draw
+   * material. Does not invalidate gather caches. Pass `null` to disable.
+   */
+  setRelighting(e) {
+    if (this.assertNotDisposed("setRelighting"), e === null) {
+      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());
+  }
+  /** Current relight numeric uniforms (`blend === 0` means off). */
+  getRelighting() {
+    return {
+      blend: this.relightBlend.value,
+      brightness: this.relightBrightness.value,
+      background: this.relightBackground.value,
+      softness: this.relightSoftness.value
+    };
+  }
+  /**
+   * Asynchronously picks the frontmost visible splat under an NDC coordinate
+   * across every registered source.
+   *
+   * Semantics: each source that is
+   * currently visible in this unified renderer runs its own depth-tested GPU
+   * pick pass; the hit nearest the camera wins and the result names its source
+   * mesh. Hidden sources (`setSourceVisible(source, false)`) never hit. A hit
+   * whose source was removed, hidden, or disposed while its readback was in
+   * flight is dropped rather than misattributed. Resolves `null` for misses,
+   * an empty source list, and picks pending across {@link dispose}.
+   *
+   * Uses the construction renderer. Concurrent calls are safe: each source
+   * serializes its own picks and shared renderer state is restored
+   * synchronously before any await.
+   */
+  async pick(e, o, 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(
+      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 };
+      })
+    );
+    if (this.disposed) return null;
+    let b = null;
+    for (const u of g) {
+      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);
+    }
+    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);
+    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. */
+  update(e) {
+    this.disposed || this.prepare(e);
+  }
+  /**
+   * Re-sorts and draws this unified source list for a secondary camera.
+   * 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) {
+    if (this.disposed) return;
+    if (o !== this.renderer)
+      throw new Error("UnifiedSplatMesh: renderView must use its construction renderer.");
+    if (!Se(o))
+      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();
+    try {
+      o.setRenderTarget(a), o.render(this, e);
+    } finally {
+      o.setRenderTarget(g), this.sortScheduler.invalidate();
+    }
+  }
+  prepare(e, o, a = !1) {
+    if (!Se(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;
+    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);
+    }
+    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;
+      }
+      if (!t.visible) {
+        t.lastGather = null;
+        continue;
+      }
+      if (i.activeCount === 0) {
+        t.lastGather = null;
+        continue;
+      }
+      if (v + i.activeCount > this.workBuffer.capacity) {
+        this.overflowedSourceCount++, this.overflowedSplatCount += i.activeCount, t.lastGather = null;
+        continue;
+      }
+      t.offset = v, m.push(t), this.bounds.union(i.worldBounds), v += i.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
+      // 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
+      // `matrixWorld` changing, so a cached gather would go stale silently.
+      // `addSource` already rejects these.
+      !i.hasSourcePlacement || (t.gather.gather(
+        this.renderer,
+        i.activeCount,
+        d,
+        i.matrixWorld,
+        b.matrixWorldInverse,
+        t.opacity
+      ), S || (A = !0), t.lastGather === null ? t.lastGather = {
+        activeCount: i.activeCount,
+        contentRevision: i.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)));
+    }
+    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;
+          break;
+        }
+      }
+    if (k) {
+      this.previousLayout = m.map((t) => ({
+        source: t.source,
+        offset: t.offset,
+        activeCount: t.view.activeCount
+      })), this.previousLayoutBySource.clear();
+      for (const t of this.previousLayout) this.previousLayoutBySource.set(t.source, t);
+    }
+    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));
+    }
+    this.geometry.instanceCount = v, 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.workBuffer.centers,
+        this.workBuffer.colors,
+        this.workBuffer.covarianceA,
+        this.workBuffer.covarianceB,
+        this.workBuffer.isotropicMix,
+        this.workBuffer.isotropicScreenRadius,
+        this.workSourceIndex,
+        this.orderAttribute
+      ]);
+    }
+  }
+  assertNotDisposed(e) {
+    if (this.disposed)
+      throw new Error(`UnifiedSplatMesh: ${e} called after dispose.`);
+  }
+  /** Rebuilds the EWA draw material when the relight map identity changes. */
+  rebuildDrawMaterial() {
+    const e = this.material;
+    this.material = Pe({
+      capacity: this.workBuffer.capacity,
+      centers: this.workBuffer.centers,
+      colors: this.workBuffer.colors,
+      covarianceA: this.workBuffer.covarianceA,
+      covarianceB: this.workBuffer.covarianceB,
+      isotropicMix: this.workBuffer.isotropicMix,
+      isotropicScreenRadius: this.workBuffer.isotropicScreenRadius,
+      order: this.orderAttribute,
+      focal: this.focal,
+      viewport: this.viewport,
+      maxStdDev: this.maxStdDev,
+      minSplatSizePx: this.minSplatSizePx,
+      antialias: this.antialias,
+      projectedLowPassVariance: this.projectedLowPassVariance,
+      compensateProjectedLowPass: this.compensateProjectedLowPass,
+      dofFocusDistance: this.dofFocusDistance,
+      dofAperture: this.dofAperture,
+      relightMap: this.relightMap,
+      relightBlend: this.relightBlend,
+      relightBrightness: this.relightBrightness,
+      relightBackground: this.relightBackground,
+      relightSoftness: this.relightSoftness
+    }), e.dispose();
+  }
+  createGather(e) {
+    const o = this.buildGather(e);
+    return o.warmUp(this.renderer).catch(() => {
+    }), o;
+  }
+  buildGather(e) {
+    return new ht({
+      capacity: this.workBuffer.capacity,
+      sourceCapacity: e.capacity,
+      sourceIndex: e.sourceIndex,
+      centersTexture: e.centersTexture,
+      colorsTexture: e.colorsTexture,
+      covarianceATexture: e.covarianceATexture,
+      covarianceBTexture: e.covarianceBTexture,
+      dataTextureWidth: e.dataTextureWidth,
+      sh: e.sh,
+      modifiers: e.modifiers,
+      channels: e.channels,
+      localCameraPosition: e.localCameraPosition,
+      srgbOutput: this.srgbOutput,
+      // Per source, not a compatibility field: the gather normalizes `.rad`
+      // half-alpha here so one shared draw material serves mixed scenes.
+      lodAlpha: e.lodAlpha,
+      workBuffer: this.workBuffer
+    });
+  }
+}
+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
+};
+//# sourceMappingURL=unified.js.map