@voluma/vlam 0.2.3 → 0.3.0

package/dist/relighting-CSQF3UcL.js

@@ -0,0 +1,969 @@
+var St = Object.defineProperty;
+var Tt = (s, e, t) => e in s ? St(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t;
+var l = (s, e, t) => Tt(s, typeof e != "symbol" ? e + "" : e, t);
+import * as h from "three/webgpu";
+import { bool as yt, mat3 as Te, vec3 as S, float as v, modelViewMatrix as $e, vec4 as K, modelWorldMatrix as At, int as L, attribute as Mt, ivec2 as je, textureLoad as O, varying as he, colorSpaceToWorking as Ct, positionGeometry as _e, Fn as G, cameraProjectionMatrix as Pt, If as pe, mix as oe, vec2 as J, Discard as Ne, texture as ve, screenUV as Se, uniform as fe, uint as C, storage as ne, atomicStore as qe, instanceIndex as E, atomicAdd as rt, Loop as We, atomicLoad as it } from "three/tsl";
+import { w as kt } from "./logging-BfPdd7NJ.js";
+function Rt(s, e, t) {
+  if (s.length === 0)
+    return {
+      color: t.color,
+      offset: null,
+      scaleSquared: null,
+      rotation: null,
+      visible: null,
+      isotropicCovarianceMix: null,
+      isotropicVarianceScale: null,
+      isotropicScreenRadiusPx: null
+    };
+  const o = e, a = {
+    color: t.color,
+    offset: S(0, 0, 0),
+    scale: v(1),
+    rotation: Te(S(1, 0, 0), S(0, 1, 0), S(0, 0, 1)),
+    visible: yt(!0)
+  }, n = { offset: !1, scale: !1, rotation: !1, visible: !1 };
+  let r = null, i = null, d = null, c = null, T = null, D = null;
+  const y = /* @__PURE__ */ new Map(), q = {
+    index: t.index,
+    localCenter: t.localCenter,
+    sourceCenter: t.sourceCenter ?? t.localCenter,
+    sourceToLocal: t.sourceToLocal ?? a.rotation,
+    cameraLocal: o,
+    baseColor: t.color,
+    get worldCenter() {
+      return c ?? (c = t.makeWorldCenter ? t.makeWorldCenter() : At.mul(K(t.localCenter, 1)).xyz);
+    },
+    get viewCenter() {
+      return T ?? (T = t.makeViewCenter ? t.makeViewCenter() : $e.mul(K(t.localCenter, 1)).xyz);
+    },
+    get normal() {
+      return D ?? (D = t.makeNormal());
+    },
+    channel(M) {
+      let m = y.get(M);
+      return m || (m = t.makeChannel(M), y.set(M, m)), m;
+    },
+    get color() {
+      return a.color;
+    },
+    get offset() {
+      return a.offset;
+    },
+    get scale() {
+      return a.scale;
+    },
+    get rotation() {
+      return a.rotation;
+    },
+    get visible() {
+      return a.visible;
+    }
+  };
+  for (const M of s) {
+    const m = M(q);
+    m.color && (a.color = m.color), m.offset && (a.offset = m.offset, n.offset = !0), m.scale && (a.scale = m.scale, n.scale = !0), m.rotation && (a.rotation = m.rotation, n.rotation = !0), m.visible && (a.visible = m.visible, n.visible = !0), m.isotropicCovarianceMix !== void 0 && (r = m.isotropicCovarianceMix), m.isotropicVarianceScale !== void 0 && (i = m.isotropicVarianceScale), m.isotropicScreenRadiusPx !== void 0 && (d = m.isotropicScreenRadiusPx);
+  }
+  return {
+    color: a.color,
+    offset: n.offset ? a.offset : null,
+    scaleSquared: n.scale ? a.scale.mul(a.scale) : null,
+    rotation: n.rotation ? a.rotation : null,
+    visible: n.visible ? a.visible : null,
+    isotropicCovarianceMix: r,
+    isotropicVarianceScale: i,
+    isotropicScreenRadiusPx: d
+  };
+}
+const De = 2048;
+function Bt(s, e, t) {
+  let o = -1;
+  for (let a = 0; a < s.length; a++) {
+    const n = s[a];
+    if (!(n.count < e) && ((o === -1 || n.count < s[o].count) && (o = a), n.count === e))
+      break;
+  }
+  if (o !== -1) {
+    const a = s[o], n = a.start;
+    return a.start += e, a.count -= e, a.count === 0 && s.splice(o, 1), n;
+  }
+  throw new Error(
+    `SplatMesh capacity exceeded: no contiguous space for ${e} rows (${De} splats each) in a ${t}-row pool.`
+  );
+}
+function It(s, e, t) {
+  s.push({ start: e, count: t }), s.sort((a, n) => a.start - n.start);
+  const o = [];
+  for (const a of s) {
+    const n = o[o.length - 1];
+    if (n && n.start + n.count > a.start)
+      throw new Error(
+        `SplatMesh pool released rows [${e}, ${e + t}) overlap an already-free span.`
+      );
+    n && n.start + n.count === a.start ? n.count += a.count : o.push(a);
+  }
+  return o;
+}
+class is {
+  constructor(e) {
+    l(this, "width", De);
+    l(this, "rows");
+    l(this, "floatTextures");
+    l(this, "packedShBands");
+    l(this, "backing");
+    l(this, "centersTexture");
+    l(this, "colorsTexture");
+    l(this, "covarianceATexture");
+    l(this, "covarianceBTexture");
+    l(this, "shPackedTextures");
+    /** Free row spans, sorted by start row. Mutated in place by the allocator. */
+    l(this, "freeRowSpans");
+    l(this, "tenants", /* @__PURE__ */ new Set());
+    /**
+     * Pool index → its owner's packed active-list slot, valid only while that
+     * pool index is active.
+     *
+     * Pool-owned rather than per-mesh because it is keyed by *pool* index: a
+     * per-mesh copy would have to span the whole pool, so N meshes sharing one
+     * pool would each pay 4 B per pool splat (a 4 M-splat pool shared by 13
+     * meshes = ~200 MB of reverse maps). One array is safe because a row belongs
+     * to exactly one tenant at a time, so no two tenants ever write the same
+     * entry - the slot numbers in it are simply read back by whoever owns
+     * the row.
+     */
+    l(this, "activeSlotByPoolIndex");
+    l(this, "poolIndexTemplate", null);
+    if (!(e.capacity > 0)) throw new Error("SplatPool capacity must be positive.");
+    this.rows = Math.ceil(e.capacity / this.width), Dt(this.rows, e.maxTextureSize ?? 0, this.width);
+    const t = this.width * this.rows;
+    this.floatTextures = e.floatTextures === "float16" ? "float16" : "float32", this.packedShBands = e.packedShBands ?? 0;
+    const o = this.floatTextures === "float16" ? h.HalfFloatType : h.FloatType;
+    this.backing = {
+      centers: new Float32Array(t * 4),
+      colors: new Uint8Array(t * 4),
+      covarianceA: new Float32Array(t * 4),
+      covarianceB: new Float32Array(t * 4),
+      // One RGBA32UI texel per splat per texture; sharing the pool's row
+      // geometry lets the whole partial-upload/compaction path reuse the
+      // existing row arithmetic unchanged.
+      shPacked: Array.from(
+        { length: e.packedShTextureCount ?? 0 },
+        () => new Uint32Array(t * 4)
+      )
+    };
+    const a = this.floatTextures === "float16" ? new Uint16Array(t * 4) : this.backing.centers, n = this.floatTextures === "float16" ? new Uint16Array(t * 4) : this.backing.covarianceA;
+    this.centersTexture = Ee(a, this.width, this.rows, o), this.colorsTexture = Ee(
+      this.backing.colors,
+      this.width,
+      this.rows,
+      h.UnsignedByteType
+    ), this.covarianceATexture = Ee(n, this.width, this.rows, o), this.covarianceBTexture = Ee(
+      this.backing.covarianceB,
+      this.width,
+      this.rows,
+      h.FloatType
+    ), this.shPackedTextures = this.backing.shPacked.map(
+      (r) => Et(r, this.width, this.rows)
+    ), this.freeRowSpans = [{ start: 0, count: this.rows }], this.activeSlotByPoolIndex = new Uint32Array(t);
+  }
+  /**
+   * A reusable `0, 1, 2, …` ramp over the pool, used to fill runs of pool
+   * indices and active-list slots without a per-element loop. Pool-owned so
+   * tenants sharing a pool share the one copy.
+   */
+  indexTemplate() {
+    if (this.poolIndexTemplate) return this.poolIndexTemplate;
+    const e = new Uint32Array(this.capacity);
+    for (let t = 0; t < e.length; t++) e[t] = t;
+    return this.poolIndexTemplate = e, e;
+  }
+  /** Splats the pool holds, always a whole number of rows. */
+  get capacity() {
+    return this.rows * this.width;
+  }
+  /** Whether `texture` belongs to this pool (and so outlives any one tenant). */
+  isPoolTexture(e) {
+    return e === this.centersTexture || e === this.colorsTexture || e === this.covarianceATexture || e === this.covarianceBTexture || this.shPackedTextures.includes(e);
+  }
+  /** The four core textures, in the order the upload path indexes them. */
+  get coreTextures() {
+    return [
+      this.centersTexture,
+      this.colorsTexture,
+      this.covarianceATexture,
+      this.covarianceBTexture
+    ];
+  }
+  /** Rows still free, whether or not they are contiguous. */
+  get freeRows() {
+    let e = 0;
+    for (const t of this.freeRowSpans) e += t.count;
+    return e;
+  }
+  /** Takes `rowCount` contiguous rows; throws when none are left (compact cue). */
+  allocateRows(e) {
+    return Bt(this.freeRowSpans, e, this.rows);
+  }
+  /** Returns rows to the free list, coalescing neighbours. */
+  releaseRows(e, t) {
+    this.freeRowSpans = It(this.freeRowSpans, e, t);
+  }
+  /** Resets the free list to one span covering the whole pool. */
+  resetFreeRows(e = 0) {
+    this.freeRowSpans = e < this.rows ? [{ start: e, count: this.rows - e }] : [];
+  }
+  /**
+   * Adds a mesh that draws from this pool. Registration exists for
+   * {@link compact}: packing the pool moves rows that belong to *every*
+   * tenant, so each has to be told where its ranges went.
+   */
+  register(e) {
+    this.tenants.add(e);
+  }
+  /**
+   * Drops a tenant. Release its ranges first: an unregistered tenant is
+   * invisible to {@link compact}, which would then treat rows it still holds
+   * as free and hand them to someone else. `compact` throws rather than let
+   * that happen silently.
+   */
+  unregister(e) {
+    this.tenants.delete(e);
+  }
+  /** Number of meshes drawing from this pool. */
+  get tenantCount() {
+    return this.tenants.size;
+  }
+  /**
+   * Packs every tenant's ranges toward row 0, removing the gaps that add /
+   * remove churn leaves behind and restoring a single contiguous free span.
+   * Callers reach this when {@link allocateRows} throws despite enough total
+   * free rows - row-alignment fragmentation.
+   *
+   * The CPU backing arrays are authoritative, so nothing is re-fetched; moved
+   * rows are re-uploaded on the tenant's next update.
+   *
+   * Note this is a whole-pool stall: with several tenants, one mesh's
+   * fragmentation relocates the others' rows too, and every tenant rebuilds
+   * its draw state. (Spark sidesteps the equivalent by allocating fixed-size,
+   * interchangeable pages that never need packing; vlam's ranges are variable
+   * runs, so it packs instead.)
+   */
+  compact() {
+    const e = this.width, t = [];
+    let o = 0;
+    for (const n of this.tenants)
+      for (const r of n.poolRanges())
+        t.push({ tenant: n, range: r }), o += r.rowCount;
+    if (o + this.freeRows !== this.rows)
+      throw new Error(
+        `SplatPool compaction found ${this.rows - o - this.freeRows} unaccounted row(s): ${o} held by ${this.tenants.size} tenant(s), ${this.freeRows} free, ${this.rows} total. Release a tenant's ranges before unregistering it.`
+      );
+    t.sort((n, r) => n.range.startRow - r.range.startRow);
+    let a = 0;
+    for (const { tenant: n, range: r } of t) {
+      if (r.startRow !== a) {
+        const i = r.startRow * e * 4, d = a * e * 4, c = r.rowCount * e * 4;
+        this.backing.centers.copyWithin(d, i, i + c), this.backing.colors.copyWithin(d, i, i + c), this.backing.covarianceA.copyWithin(d, i, i + c), this.backing.covarianceB.copyWithin(d, i, i + c);
+        for (const T of this.backing.shPacked) T.copyWithin(d, i, i + c);
+        n.relocatePoolRange(r, a);
+      }
+      a += r.rowCount;
+    }
+    this.resetFreeRows(a);
+    for (const n of this.tenants) n.onPoolCompacted();
+  }
+  dispose() {
+    for (const e of this.coreTextures) e.dispose();
+    for (const e of this.shPackedTextures) e.dispose();
+    this.tenants.clear();
+  }
+}
+function Ee(s, e, t, o) {
+  const a = new h.DataTexture(s, e, t, h.RGBAFormat, o);
+  return a.needsUpdate = !0, a;
+}
+function Et(s, e, t) {
+  const o = new h.DataTexture(
+    s,
+    e,
+    t,
+    h.RGBAIntegerFormat,
+    h.UnsignedIntType
+  );
+  return o.magFilter = h.NearestFilter, o.minFilter = h.NearestFilter, o.generateMipmaps = !1, o.needsUpdate = !0, o;
+}
+function cs(s) {
+  var a, n;
+  const e = s.backend, t = (n = (a = e == null ? void 0 : e.device) == null ? void 0 : a.limits) == null ? void 0 : n.maxTextureDimension2D;
+  if (typeof t == "number" && t > 0) return t;
+  const o = e == null ? void 0 : e.gl;
+  if (o) {
+    const r = o.getParameter(o.MAX_TEXTURE_SIZE);
+    if (typeof r == "number" && r > 0) return r;
+  }
+  return 0;
+}
+function Dt(s, e, t = De) {
+  if (!(!(e > 0) || s <= e))
+    throw new Error(
+      `SplatPool: this scene needs a ${t}×${s} data texture, but this device caps texture dimensions at ${e} (about ${(e * t).toLocaleString("en-US")} pool splats). Lower the splat budget, or raise maxTextureDimension2D in the renderer's requiredLimits if the adapter advertises more.`
+    );
+}
+function ls(s, e, t) {
+  let o = e, a = e + t;
+  const n = [];
+  for (const r of s.updateRanges) {
+    const i = r.start + r.count;
+    if (i < o || r.start > a) {
+      n.push(r);
+      continue;
+    }
+    o = Math.min(o, r.start), a = Math.max(a, i);
+  }
+  n.push({ start: o, count: a - o }), n.sort((r, i) => r.start - i.start), s.clearUpdateRanges();
+  for (const r of n) s.addUpdateRange(r.start, r.count);
+}
+const ct = 24, dt = ct * ct;
+function Ft(s, e) {
+  const t = Math.max(0, s);
+  if (t <= 0) return 0;
+  const o = Math.max(1e-4, e);
+  return 2 * Math.atan(0.5 * t / o);
+}
+function us(s) {
+  const e = Math.max(1e-4, s.depth), t = Math.max(1e-4, s.focusDistance), o = Ft(s.aperture, t);
+  if (o <= 0 || !(s.focalPx > 0)) return 0;
+  const a = Math.abs(e - t) / e, n = s.focalPx * Math.tan(0.5 * o), r = a * n, i = r * r, d = s.maxVariance ?? dt;
+  return Math.min(i, d);
+}
+function ds(s, e) {
+  return Math.sqrt(Math.max(0, s) / Math.max(1e-9, e));
+}
+function ms(s, e = { focusDistance: 10, aperture: 0 }) {
+  const t = typeof s.focusDistance == "number" && Number.isFinite(s.focusDistance) ? Math.max(1e-4, s.focusDistance) : e.focusDistance, o = typeof s.aperture == "number" && Number.isFinite(s.aperture) ? Math.max(0, s.aperture) : e.aperture;
+  return { focusDistance: t, aperture: o };
+}
+const lt = 1024, zt = 1e30, Ut = 0.35 * 0.35;
+function Vt(s, e, t, o) {
+  const a = S(1, 0, 0), n = S(0, 1, 0), r = S(0, 0, 1), i = s.mul(a), d = s.mul(n), c = s.mul(r), T = i.x, D = d.y, y = c.z, q = i.cross(d), M = d.cross(c), m = c.cross(i), w = q.length(), V = M.length(), X = m.length(), xe = w.greaterThanEqual(V).and(w.greaterThanEqual(X)), ae = V.greaterThan(w).and(V.greaterThanEqual(X)), re = xe.select(q, ae.select(M, m)), u = re.div(re.length().max(1e-12)), x = u.dot(s.mul(u)), F = T.min(D).min(y).min(x).max(1e-12).mul(o), $ = Te(S(F, 0, 0), S(0, F, 0), S(0, 0, F));
+  return s.mul(v(1).sub(t)).add($.mul(t));
+}
+function Ot(s, e, t) {
+  const o = s.min(e);
+  return {
+    lambda1: oe(s, o, t),
+    lambda2: oe(e, o, t)
+  };
+}
+function Lt(s, e, t, o, a) {
+  const n = o.div(a).pow(2), r = s.min(e).min(n), i = oe(s, r, t), d = oe(e, r, t), c = o.greaterThan(0);
+  return {
+    lambda1: c.select(i, s),
+    lambda2: c.select(d, e)
+  };
+}
+function hs(s) {
+  return s;
+}
+function fs() {
+  return fe(new h.Vector3());
+}
+function mt(s, e, t) {
+  const o = e.mul(L(4)), a = s.element(o), n = s.element(o.add(L(1))), r = s.element(o.add(L(2))), i = s.element(o.add(L(3))), d = a.xyz.mul(t.x).add(n.xyz.mul(t.y)).add(r.xyz.mul(t.z)).add(i.xyz), c = Te(a.xyz, n.xyz, r.xyz);
+  return { worldCenter: d, linear: c };
+}
+function _t(s) {
+  return [0, 3, 8, 15][s] ?? 0;
+}
+function ht(s, e, t) {
+  if (s.mode === "palette") {
+    const n = O(e.covarianceBTexture, t).z.toInt(), r = n.mod(L(64)).mul(L(_t(s.bands))), i = n.div(L(64));
+    return (d) => O(s.paletteTexture, je(r.add(L(d)), i)).xyz;
+  }
+  const o = s.textures.map(
+    (n) => O(n, t).toVar()
+  ), a = s.range.max.sub(s.range.min);
+  return (n) => {
+    const r = o[n >> 2], i = [r.x, r.y, r.z, r.w][n & 3], d = S(
+      i.bitAnd(C(2047)).toFloat().div(2047),
+      i.shiftRight(C(11)).bitAnd(C(1023)).toFloat().div(1023),
+      i.shiftRight(C(21)).bitAnd(C(2047)).toFloat().div(2047)
+    );
+    return s.range.min.add(a.mul(d));
+  };
+}
+const ge = 0.4886025119029199, H = [
+  1.0925484305920792,
+  -1.0925484305920792,
+  0.31539156525252005,
+  -1.0925484305920792,
+  0.5462742152960396
+], U = [
+  -0.5900435899266435,
+  2.890611442640554,
+  -0.4570457994644658,
+  0.3731763325901154,
+  -0.4570457994644658,
+  1.445305721320277,
+  -0.5900435899266435
+];
+function ps(s, e, t, o) {
+  const a = o.x, n = o.y, r = o.z, i = ht(s, e, t), d = i(0).mul(n.mul(-ge)).add(i(1).mul(r.mul(ge))).add(i(2).mul(a.mul(-ge)));
+  if (s.bands === 1) return d;
+  const c = a.mul(a), T = n.mul(n), D = r.mul(r), y = d.add(i(3).mul(a.mul(n).mul(H[0]))).add(i(4).mul(n.mul(r).mul(H[1]))).add(i(5).mul(D.mul(2).sub(c).sub(T).mul(H[2]))).add(i(6).mul(a.mul(r).mul(H[3]))).add(i(7).mul(c.sub(T).mul(H[4])));
+  return s.bands === 2 ? y : y.add(i(8).mul(n.mul(c.mul(3).sub(T)).mul(U[0]))).add(i(9).mul(a.mul(n).mul(r).mul(U[1]))).add(i(10).mul(n.mul(D.mul(4).sub(c).sub(T)).mul(U[2]))).add(i(11).mul(r.mul(D.mul(2).sub(c.mul(3)).sub(T.mul(3))).mul(U[3]))).add(i(12).mul(a.mul(D.mul(4).sub(c).sub(T)).mul(U[4]))).add(i(13).mul(r.mul(c.sub(T)).mul(U[5]))).add(i(14).mul(a.mul(c.sub(T.mul(3))).mul(U[6])));
+}
+function gs(s, e, t) {
+  const { textures: o, sh: a, uniforms: n, settings: r, pick: i } = t, d = L(De), c = v(lt), T = -0.5 * r.maxStdDev * r.maxStdDev, D = Mt("splatIndex", "float").toInt(), y = je(D.mod(d), D.div(d)), q = O(o.colorsTexture, y), M = O(o.centersTexture, y).xyz, m = t.sourcePlacement, w = m ? mt(
+    m.columns,
+    O(m.sourceIdTexture, y).r.toInt(),
+    M
+  ) : null, V = w ? w.worldCenter : M, X = a === null ? null : (() => {
+    const b = w ? w.linear.inverse().mul(V.sub(n.localCameraPosition)).normalize() : V.sub(n.localCameraPosition).normalize(), f = b.x, g = b.y, B = b.z, p = ht(a, o, y), z = p(0).mul(g.mul(-ge)).add(p(1).mul(B.mul(ge))).add(p(2).mul(f.mul(-ge)));
+    if (a.bands === 1) return z;
+    const A = f.mul(f), I = g.mul(g), P = B.mul(B), _ = z.add(p(3).mul(f.mul(g).mul(H[0]))).add(p(4).mul(g.mul(B).mul(H[1]))).add(p(5).mul(P.mul(2).sub(A).sub(I).mul(H[2]))).add(p(6).mul(f.mul(B).mul(H[3]))).add(p(7).mul(A.sub(I).mul(H[4])));
+    return a.bands === 2 ? _ : _.add(p(8).mul(g.mul(A.mul(3).sub(I)).mul(U[0]))).add(p(9).mul(f.mul(g).mul(B).mul(U[1]))).add(p(10).mul(g.mul(P.mul(4).sub(A).sub(I)).mul(U[2]))).add(
+      p(11).mul(
+        B.mul(P.mul(2).sub(A.mul(3)).sub(I.mul(3))).mul(U[3])
+      )
+    ).add(p(12).mul(f.mul(P.mul(4).sub(A).sub(I)).mul(U[4]))).add(p(13).mul(B.mul(A.sub(I)).mul(U[5]))).add(p(14).mul(f.mul(A.sub(I.mul(3))).mul(U[6])));
+  })(), xe = X === null ? q : K(q.rgb.add(X).clamp(0, 1), q.a), ae = () => {
+    const b = O(o.covarianceATexture, y), f = O(o.covarianceBTexture, y), g = Te(
+      S(b.x.add(1e-8), b.y, b.z),
+      S(b.y, b.w.add(1e-8), f.x),
+      S(b.z, f.x, f.y.add(1e-8))
+    ), p = (w ? w.linear.mul(g).mul(w.linear.transpose()) : g).inverse(), z = n.localCameraPosition.sub(V), A = p.mul(p.mul(z)).normalize();
+    return A.mul(A.dot(z).sign());
+  }, re = (b) => {
+    const f = t.channels.get(b);
+    if (!f)
+      throw new Error(
+        `SplatMesh: a modifier reads channel "${b}", which is not defined. Call defineChannel("${b}") before assigning the modifier.`
+      );
+    return O(f.texture, y).r;
+  }, u = Rt(t.modifiers, n.localCameraPosition, {
+    index: D,
+    localCenter: V,
+    sourceCenter: M,
+    sourceToLocal: w == null ? void 0 : w.linear,
+    color: xe,
+    makeNormal: ae,
+    makeChannel: re
+  }), x = he(
+    r.srgbOutput ? u.color : Ct(u.color, h.SRGBColorSpace)
+  ), R = he(_e.xy), F = e === "pick" ? he(v(0), "pickViewDepth") : null, $ = he(v(1), "vOpacityCompensation"), Z = r.lodAlpha ? he(v(r.maxStdDev), "vAdjustedStdDev") : null, ie = r.lodAlpha ? he(v(1), "vAlpha2") : null;
+  if (s.vertexNode = G(() => {
+    const b = u.offset === null ? V : V.add(u.offset), f = $e.mul(K(b, 1)).toVar(), g = Pt.mul(f).toVar(), B = K(0, 0, 2, 1).toVar(), p = e === "pick" ? 1.2 + 2 * lt : 1.2, z = g.w.mul(p), A = g.z.greaterThan(z.negate()).and(g.x.abs().lessThan(z)).and(g.y.abs().lessThan(z)), I = u.visible === null ? A : A.and(u.visible);
+    return pe(I, () => {
+      F && F.assign(f.z.negate());
+      const P = O(o.covarianceATexture, y), _ = O(o.covarianceBTexture, y), ce = Te(
+        S(P.x, P.y, P.z),
+        S(P.y, P.w, _.x),
+        S(P.z, _.x, _.y)
+      ), be = w ? w.linear.mul(ce).mul(w.linear.transpose()) : ce;
+      let Y = u.rotation === null ? be : u.rotation.mul(be).mul(u.rotation.transpose());
+      if (u.isotropicCovarianceMix !== null) {
+        const k = u.isotropicVarianceScale ?? v(Ut);
+        Y = Vt(
+          Y,
+          S(0, 0, 1),
+          u.isotropicCovarianceMix,
+          k
+        );
+      }
+      const le = v(1).div(f.z), ye = le.mul(le), Ae = S(
+        n.focal.x.mul(le),
+        0,
+        n.focal.x.negate().mul(f.x).mul(ye)
+      ), Fe = S(
+        0,
+        n.focal.y.mul(le),
+        n.focal.y.negate().mul(f.y).mul(ye)
+      ), Me = $e.toMat3().transpose(), ue = Me.mul(Ae), de = Me.mul(Fe), Ce = ue.dot(Y.mul(ue)), Pe = de.dot(Y.mul(de)), He = ue.dot(Y.mul(de)), ze = u.scaleSquared === null ? Ce : Ce.mul(u.scaleSquared), Ue = u.scaleSquared === null ? Pe : Pe.mul(u.scaleSquared), we = u.scaleSquared === null ? He : He.mul(u.scaleSquared), Ke = f.z.negate().max(1e-4), Xe = n.dofFocusDistance.max(1e-4), ft = n.dofAperture.max(0).mul(0.5).div(Xe).atan(), pt = Ke.sub(Xe).abs().div(Ke), gt = n.focal.x.mul(ft.tan()), Ze = pt.mul(gt), Qe = Ze.mul(Ze).min(v(dt)), ke = r.projectedFilterProfile === "lcc" ? 0.1 : 0.3, Re = ze.add(ke).add(Qe), Ve = Ue.add(ke).add(Qe), Be = we, xt = Re.mul(Ve).sub(Be.mul(Be)).max(1e-9), Je = (r.antialias || r.projectedFilterProfile === "lcc" ? ze.mul(Ue).sub(we.mul(we)).max(0) : ze.add(ke).mul(Ue.add(ke)).sub(we.mul(we)).max(1e-9)).div(xt).sqrt();
+      $.assign(
+        u.isotropicCovarianceMix === null ? Je : oe(Je, v(1), u.isotropicCovarianceMix)
+      );
+      const Ye = Re.add(Ve).mul(0.5), et = J(Re.sub(Ve).mul(0.5), Be).length();
+      let Q = Ye.add(et), me = Ye.sub(et).max(0);
+      if (u.isotropicCovarianceMix !== null) {
+        const k = Ot(
+          Q,
+          me,
+          u.isotropicCovarianceMix
+        );
+        if (Q = k.lambda1, me = k.lambda2, u.isotropicScreenRadiusPx !== null) {
+          const N = Lt(
+            Q,
+            me,
+            u.isotropicCovarianceMix,
+            u.isotropicScreenRadiusPx,
+            v(r.maxStdDev)
+          );
+          Q = N.lambda1, me = N.lambda2;
+        }
+      }
+      const Oe = J(Be, Q.sub(Re)).add(J(1e-6, 0)).normalize();
+      let Ie = v(r.maxStdDev);
+      if (r.lodAlpha && Z && ie) {
+        const k = u.color.a.mul(2), N = k.mul(4).sub(3).min(5);
+        Ie = k.greaterThan(1).select(
+          v(r.maxStdDev).add(N.sub(1).mul(0.7)),
+          v(r.maxStdDev)
+        ), Z.assign(Ie), ie.assign(k);
+      }
+      const bt = r.maxAspect && r.maxAspect > 0 ? Q.min(me.mul(r.maxAspect * r.maxAspect)) : Q, tt = v(r.minSplatSizePx ?? 0), st = Oe.mul(
+        bt.sqrt().mul(Ie).min(c).max(tt)
+      ), nt = J(Oe.y, Oe.x.negate()).mul(
+        me.sqrt().mul(Ie).min(c).max(tt)
+      ), Le = () => {
+        const k = st.mul(_e.x).add(nt.mul(_e.y)), N = g.xy.div(g.w);
+        B.assign(
+          K(
+            N.add(k.mul(2).div(n.viewport)),
+            g.z.div(g.w),
+            1
+          )
+        );
+      };
+      let ee;
+      if (r.foveationMode === "page-table")
+        ee = null;
+      else if (r.foveationMode === "frontier") {
+        const k = f.z.negate(), te = P.x.add(P.w).add(_.y).max(0).mul(1 / 3).sqrt().mul(2), W = _.w, se = W.lessThan(0), ot = W.abs(), wt = ot.equal(0).select(v(zt), ot), at = n.pixelScaleLimit.mul(k), vt = se.select(v(0), te);
+        ee = wt.greaterThan(at).and(vt.lessThanEqual(at));
+      } else {
+        const k = r.maxScreenRadiusPx ?? 0, N = r.minScreenRadiusPx ?? 0, te = Q.sqrt().mul(r.maxStdDev);
+        let W = null;
+        if (k > 0 && (W = te.lessThanEqual(n.screenBandMax)), N > 0) {
+          const se = te.greaterThan(n.screenBandMin);
+          W = W ? W.and(se) : se;
+        }
+        ee = W;
+      }
+      if (r.performanceProfile === "smooth") {
+        const k = st.length(), N = nt.length(), te = u.color.a, W = te.greaterThanEqual(1 / 255).and(k.max(N).mul(2).greaterThanEqual(2)).and(te.mul(k).mul(N).greaterThanEqual(3)), se = u.isotropicCovarianceMix === null ? W : W.or(u.isotropicCovarianceMix.greaterThan(0));
+        pe(ee ? se.and(ee) : se, Le);
+      } else ee ? pe(ee, Le) : Le();
+    }), B;
+  })(), e === "display")
+    s.fragmentNode = G(() => {
+      const b = R.dot(R);
+      Ne(b.greaterThan(1));
+      let f;
+      if (r.lodAlpha && Z && ie) {
+        const ue = b.mul(Z.mul(Z).mul(-0.5)).exp(), de = ie.mul(4).sub(3).min(5), Ce = de.mul(de).sub(1).mul(1 / Math.E).exp(), Pe = ue.oneMinus().pow(Ce).oneMinus();
+        f = ie.greaterThan(1).select(Pe, ue.mul(ie));
+      } else
+        f = b.mul(T).exp().mul(x.a);
+      const g = f.mul($), B = ve(n.relightMap, Se), p = n.relightSoftness.div(n.viewport.x.max(1)), z = n.relightSoftness.div(n.viewport.y.max(1)), A = B, I = ve(n.relightMap, Se.add(J(p, 0))), P = ve(n.relightMap, Se.add(J(p.negate(), 0))), _ = ve(n.relightMap, Se.add(J(0, z))), ce = ve(n.relightMap, Se.add(J(0, z.negate()))), be = A.a.add(I.a).add(P.a).add(_.a).add(ce.a).max(1e-4), Y = A.rgb.mul(A.a).add(I.rgb.mul(I.a)).add(P.rgb.mul(P.a)).add(_.rgb.mul(_.a)).add(ce.rgb.mul(ce.a)).div(be), le = be.mul(0.2), ye = K(Y, le), Ae = n.relightSoftness.greaterThan(0.5).select(ye, B), Fe = oe(
+        S(n.relightBackground),
+        Ae.rgb.mul(n.relightBrightness),
+        Ae.a
+      ), Me = oe(x.rgb, x.rgb.mul(Fe), n.relightBlend);
+      return K(Me.mul(g), g);
+    })(), s.transparent = !0, s.depthTest = !0, s.depthWrite = !1, s.side = h.DoubleSide, s.blending = h.CustomBlending, s.blendSrc = h.OneFactor, s.blendDst = h.OneMinusSrcAlphaFactor, s.blendSrcAlpha = h.OneFactor, s.blendDstAlpha = h.OneMinusSrcAlphaFactor, s.toneMapped = !1;
+  else {
+    if (!i)
+      throw new Error("applySplatMaterialGraph in 'pick' mode requires pick uniforms.");
+    s.fragmentNode = G(() => {
+      const b = R.dot(R);
+      Ne(b.greaterThan(1));
+      const g = b.mul(T).exp().mul(x.a).mul($);
+      Ne(g.lessThan(i.alphaThreshold));
+      const p = F.sub(i.near).div(i.far.sub(i.near)).clamp(0, 1).mul(16777215), z = p.div(65536).floor(), A = p.mod(65536).div(256).floor(), I = p.mod(256).floor();
+      return K(z.div(255), A.div(255), I.div(255), 1);
+    })(), s.transparent = !1, s.depthTest = !0, s.depthWrite = !0, s.side = h.DoubleSide, s.blending = h.NoBlending, s.toneMapped = !1;
+  }
+}
+function Nt(s, e) {
+  const t = s.elements;
+  return e * Math.hypot(t[2], t[6], t[10]);
+}
+function qt(s, e) {
+  const t = s.backend;
+  return !t || t.isWebGPUBackend !== !0 || typeof t.has != "function" || typeof t.get != "function" || !t.has(e) ? !1 : t.get(e).buffer !== void 0;
+}
+function Wt(s) {
+  const e = s.array, t = e.byteLength;
+  if (t === 0) return 0;
+  const o = e.constructor;
+  return s.array = new o(0), t;
+}
+class Gt {
+  constructor(e) {
+    l(this, "pending");
+    /** Released attributes and the `version` they carried when released. */
+    l(this, "released", /* @__PURE__ */ new Map());
+    l(this, "releasedBytesValue", 0);
+    l(this, "warnedDrift", !1);
+    this.pending = [...e];
+  }
+  /** Nothing left to release. */
+  get settled() {
+    return this.pending.length === 0;
+  }
+  /** Bytes still mirrored on the JS heap. */
+  get pendingBytes() {
+    let e = 0;
+    for (const t of this.pending) e += t.array.byteLength;
+    return e;
+  }
+  /** Bytes freed so far. Diagnostic. */
+  get releasedBytes() {
+    return this.releasedBytesValue;
+  }
+  /**
+   * Releases every pending mirror three has uploaded, and checks the ones
+   * already released for version drift. Idempotent and cheap once settled.
+   *
+   * @returns Bytes freed by this call.
+   */
+  release(e) {
+    if (this.checkDrift(), this.pending.length === 0) return 0;
+    let t = 0;
+    for (let o = this.pending.length - 1; o >= 0; o--) {
+      const a = this.pending[o];
+      qt(e, a) && (t += Wt(a), this.released.set(a, a.version), this.pending.splice(o, 1));
+    }
+    return this.releasedBytesValue += t, t;
+  }
+  /**
+   * A released attribute whose `version` moved means someone added a CPU write
+   * to a buffer this class promised was GPU-only. Three would then upload the
+   * zero-length array - a legal no-op - and the data would simply never reach
+   * the GPU. Warn once, so that failure is visible rather than a silent wrong
+   * render.
+   */
+  checkDrift() {
+    if (!(this.warnedDrift || this.released.size === 0)) {
+      for (const [e, t] of this.released)
+        if (e.version !== t) {
+          this.warnedDrift = !0, kt(
+            `StorageMirrorReleaser: storage attribute "${e.name || "unnamed"}" was written from the CPU after its mirror was released; that write will not reach the GPU. Remove it from the releaser's attribute list.`
+          );
+          return;
+        }
+    }
+  }
+}
+const j = class j {
+  constructor(e) {
+    l(this, "kind", "counting");
+    l(this, "renderer");
+    l(this, "clearPass");
+    l(this, "histogramPass");
+    l(this, "scanBlocksPass");
+    l(this, "scanBlockSumsPass");
+    l(this, "addBlockSumOffsetsPass");
+    l(this, "addOffsetsPass");
+    l(this, "scatterPass");
+    /** All stages in dependency order, submitted as one WebGPU compute pass. */
+    l(this, "sortPasses");
+    /** Sorter-owned working buffers, released on {@link dispose}. */
+    l(this, "workingAttributes");
+    /** Frees the JS mirrors three keeps behind the GPU-only working buffers. */
+    l(this, "mirrors");
+    /** Set by {@link dispose}; makes a second dispose a no-op. */
+    l(this, "disposed", !1);
+    /** Row 2 of the model-view matrix; view-space z = row2 · (position, 1). */
+    l(this, "viewRow2", fe(new h.Vector4()));
+    l(this, "depthMin", fe(0));
+    l(this, "depthScale", fe(0));
+    /** Active splat count; a float compares exactly for counts < 2²⁴. */
+    l(this, "activeCount", fe(0));
+    /** Highest bucket index this sort uses; see {@link effectiveBucketCount}. */
+    l(this, "bucketMax", fe(0));
+    l(this, "viewCenter", new h.Vector3());
+    const { renderer: t, capacity: o, centersTexture: a, dataTextureWidth: n, centersBuffer: r, perSource: i } = e, { BUCKET_COUNT: d, BLOCK_SIZE: c } = j;
+    if (!a && !r)
+      throw new Error("ComputeSorter: provide centersTexture or centersBuffer.");
+    if (a && n === void 0)
+      throw new Error("ComputeSorter: dataTextureWidth is required with centersTexture.");
+    if (r && i)
+      throw new Error("ComputeSorter: work-buffer centers are already in world space.");
+    this.renderer = t;
+    const T = new h.StorageBufferAttribute(new Uint32Array(d), 1), D = new h.StorageBufferAttribute(
+      new Uint32Array(d / c),
+      1
+    ), y = new h.StorageBufferAttribute(
+      new Uint32Array(d / c / c),
+      1
+    ), q = new h.StorageBufferAttribute(new Uint32Array(o), 1);
+    this.workingAttributes = [
+      T,
+      D,
+      y,
+      q
+    ], this.mirrors = new Gt(this.workingAttributes);
+    const M = ne(T, "uint", d).toAtomic(), m = ne(D, "uint", d / c), w = ne(
+      y,
+      "uint",
+      d / c / c
+    ), V = ne(q, "uint", o), X = ne(e.sourceIndexAttribute, "uint", o), xe = ne(e.splatIndexAttribute, "float", o), ae = r ? ne(r, "vec4", o) : null;
+    this.clearPass = G(() => {
+      qe(M.element(E), C(0));
+    })().compute(d, [c]), this.histogramPass = G(() => {
+      pe(v(E).lessThan(this.activeCount), () => {
+        const u = L(X.element(E)), x = a ? je(
+          u.mod(L(n)),
+          u.div(L(n))
+        ) : null, R = ae ? ae.element(u).xyz : O(a, x).xyz, F = i ? mt(
+          i.columns,
+          L(O(i.sourceIdTexture, x).r),
+          R
+        ).worldCenter : R, Z = this.viewRow2.xyz.dot(F).add(this.viewRow2.w).sub(this.depthMin).mul(this.depthScale).clamp(0, this.bucketMax).toUint();
+        V.element(E).assign(Z), rt(M.element(Z), C(1));
+      });
+    })().compute(o, [c]), this.scanBlocksPass = G(() => {
+      const u = E.mul(C(c)).toVar(), x = C(0).toVar();
+      We(c, ({ i: R }) => {
+        const F = M.element(u.add(C(R))), $ = it(F).toVar();
+        qe(F, x), x.addAssign($);
+      }), m.element(E).assign(x);
+    })().compute(d / c, [64]), this.scanBlockSumsPass = G(() => {
+      const u = E.mul(C(c)).toVar(), x = C(0).toVar();
+      We(c, ({ i: R }) => {
+        const F = m.element(u.add(C(R))), $ = F.toVar();
+        F.assign(x), x.addAssign($);
+      }), w.element(E).assign(x);
+    })().compute(d / c / c, [64]);
+    const re = G(() => {
+      pe(E.equal(C(0)), () => {
+        const u = C(0).toVar();
+        We(d / c / c, ({ i: x }) => {
+          const R = w.element(x).toVar();
+          w.element(x).assign(u), u.addAssign(R);
+        });
+      });
+    })().compute(1, [64]);
+    this.addBlockSumOffsetsPass = G(() => {
+      m.element(E).addAssign(w.element(E.div(C(c))));
+    })().compute(d / c, [c]), this.addOffsetsPass = G(() => {
+      const u = M.element(E), x = m.element(E.shiftRight(C(Math.log2(c))));
+      qe(u, it(u).add(x));
+    })().compute(d, [c]), this.scatterPass = G(() => {
+      pe(v(E).lessThan(this.activeCount), () => {
+        const u = X.element(E), x = V.element(E), R = rt(M.element(x), C(1));
+        xe.element(R).assign(v(u));
+      });
+    })().compute(o, [c]), this.sortPasses = [
+      this.clearPass,
+      this.histogramPass,
+      this.scanBlocksPass,
+      this.scanBlockSumsPass,
+      re,
+      this.addBlockSumOffsetsPass,
+      this.addOffsetsPass,
+      this.scatterPass
+    ];
+  }
+  /**
+   * Buckets to actually use for `activeCount` splats, rounded up to a power of
+   * two so block indexing stays exact.
+   *
+   * The histogram is allocated once for the pool's worst case, but clearing and
+   * scanning all 2²² buckets costs the same whether one splat is resident or
+   * four million - a fixed per-sort bill that dominates on a mobile GPU when
+   * the pool is only partly filled (a streaming scene ramping up, or any small
+   * scene). Sizing the dispatch to the live splat count keeps the design's
+   * ~1-bucket-per-splat depth resolution, so ordering is unaffected, while
+   * skipping work on buckets no splat can land in.
+   */
+  effectiveBucketCount(e) {
+    const o = 2 ** Math.ceil(Math.log2(Math.max(1, e)));
+    return Math.min(Math.max(o, j.MIN_BUCKET_COUNT), j.BUCKET_COUNT);
+  }
+  sort(e, t, o) {
+    if (t === 0) return !0;
+    const a = e.elements;
+    this.viewRow2.value.set(a[2], a[6], a[10], a[14]), this.activeCount.value = t;
+    const n = this.effectiveBucketCount(t);
+    this.viewCenter.copy(o.center).applyMatrix4(e);
+    const r = Nt(e, o.radius), i = this.viewCenter.z - r, d = this.viewCenter.z + r;
+    this.depthMin.value = i, this.depthScale.value = (n - 1) / (d - i || 1), this.bucketMax.value = n - 1;
+    const c = n / j.BLOCK_SIZE;
+    return this.histogramPass.count = t, this.scatterPass.count = t, this.clearPass.count = n, this.scanBlocksPass.count = c, this.scanBlockSumsPass.count = c / j.BLOCK_SIZE, this.addBlockSumOffsetsPass.count = c, this.addOffsetsPass.count = n, this.renderer.compute(this.sortPasses), this.mirrors.settled || this.mirrors.release(this.renderer), !0;
+  }
+  dispose() {
+    if (!this.disposed) {
+      this.disposed = !0;
+      for (const e of this.sortPasses) e.dispose();
+      $t(this.renderer, this.workingAttributes);
+    }
+  }
+};
+l(j, "BUCKET_COUNT", 1 << 22), l(j, "BLOCK_SIZE", 256), /**
+ * Smallest bucket count a sort will dispatch. Below this the fixed passes
+ * are already cheap, and the floor keeps every block-scan index exact.
+ */
+l(j, "MIN_BUCKET_COUNT", 65536);
+let ut = j;
+function $t(s, e) {
+  const t = s._attributes;
+  if (t)
+    for (const o of e) t.delete(o);
+}
+const jt = 2e6, Ht = 5e6, Kt = 8e6, Xt = 1e-6;
+function Zt(s) {
+  if (s !== void 0 && (!Number.isFinite(s) || s < 0))
+    throw new RangeError(
+      "SplatMesh sortIntervalMs must be a finite number greater than or equal to 0."
+    );
+  return s;
+}
+function Qt(s, e = !1) {
+  return s < jt ? e ? 33 : 0 : s < Ht ? e ? 66 : 50 : s < Kt ? e ? 133 : 100 : 1e3 / 6;
+}
+class xs {
+  constructor(e, t = !1) {
+    l(this, "sortIntervalMs");
+    l(this, "isMobile");
+    l(this, "previousModelView", new h.Matrix4());
+    l(this, "hasPreviousModelView", !1);
+    l(this, "legacyWasMoving", !1);
+    l(this, "forcePending", !0);
+    l(this, "lastAcceptedAt", -1 / 0);
+    l(this, "acceptedCount", 0);
+    this.sortIntervalMs = Zt(e), this.isMobile = t;
+  }
+  /** Forces the next changed or content-invalidated pose to bypass throttling. */
+  invalidate() {
+    this.forcePending = !0;
+  }
+  /**
+   * Content changes replace pool indices underneath the current draw order.
+   * They must bypass cadence so a newly active range never renders through a
+   * stale sort while the camera is moving.
+   */
+  invalidateContent() {
+    this.forcePending = !0;
+  }
+  /**
+   * Whether an invalidation is still waiting for an accepted sort. The WebGL2
+   * worker path consults this directly: it has no cadence, but a content swap
+   * under a stationary camera must still trigger a re-sort - the swap reset
+   * the draw list to unsorted active order, and without this the scene would
+   * render in that unsorted order until the camera next moved (visible
+   * blend-order flicker on every streaming swap).
+   */
+  hasPendingForce() {
+    return this.forcePending;
+  }
+  /**
+   * Returns whether a sort should be submitted at this timestamp.
+   */
+  shouldSubmit(e, t, o, a) {
+    return this.shouldSubmitLegacy(e, t, o, a);
+  }
+  /**
+   * Commits timing state only after the sorter accepts a submission.
+   */
+  markAccepted(e) {
+    this.lastAcceptedAt = e, this.acceptedCount++, this.forcePending = !1;
+  }
+  /** Internal diagnostics for the demo HUD; it does not alter scheduling. */
+  snapshot() {
+    return { acceptedCount: this.acceptedCount, lastAcceptedAt: this.lastAcceptedAt };
+  }
+  shouldSubmitLegacy(e, t, o, a) {
+    let n = !1;
+    if (this.hasPreviousModelView) {
+      const i = Jt(e, this.previousModelView) > Xt;
+      n = this.legacyWasMoving && !i, this.legacyWasMoving = i;
+    } else
+      this.hasPreviousModelView = !0;
+    this.previousModelView.copy(e);
+    const r = this.sortIntervalMs ?? Qt(o, this.isMobile);
+    return this.forcePending ? !0 : e.equals(t) ? !1 : n ? !0 : r === 0 || a - this.lastAcceptedAt >= r;
+  }
+}
+function Jt(s, e) {
+  let t = 0;
+  for (let o = 0; o < 16; o++)
+    t = Math.max(t, Math.abs(s.elements[o] - e.elements[o]));
+  return t;
+}
+const Ge = new h.Vector2();
+function bs(s, e) {
+  var d;
+  const t = e.xr;
+  if ((t == null ? void 0 : t.isPresenting) !== !0 || typeof t.getCamera != "function") return null;
+  t.cameraAutoUpdate !== !1 && typeof t.updateCamera == "function" && t.updateCamera(s);
+  const o = t.getCamera(), a = (d = o.cameras) == null ? void 0 : d[0];
+  if (!a) return null;
+  const n = a.viewport;
+  let r = (n == null ? void 0 : n.z) ?? 0, i = (n == null ? void 0 : n.w) ?? 0;
+  return (!(r > 0) || !(i > 0)) && (e.getDrawingBufferSize(Ge), r = Ge.x, i = Ge.y), { head: o, eye: a, width: r, height: i };
+}
+function ws(s) {
+  return s.isArrayCamera === !0;
+}
+function vs(s, e = {}) {
+  const t = s.backend.isWebGPUBackend === !0, o = [...e.requiredFeatures ?? [], ...t ? ["webgpu"] : []], a = e.optionalFeatures ?? [];
+  return {
+    ...e,
+    ...o.length > 0 ? { requiredFeatures: o } : {},
+    ...a.length > 0 ? { optionalFeatures: a } : {}
+  };
+}
+const Yt = 1, es = 2, ts = 1, ss = 0;
+function Ss(s, e = {
+  blend: Yt,
+  brightness: es,
+  background: ts,
+  softness: ss
+}) {
+  const t = s.blend !== void 0 ? s.blend : e.blend, o = s.brightness !== void 0 ? s.brightness : e.brightness, a = s.background !== void 0 ? s.background : e.background, n = s.softness !== void 0 ? s.softness : e.softness;
+  return {
+    blend: Number.isFinite(t) ? Math.min(1, Math.max(0, t)) : e.blend,
+    brightness: Number.isFinite(o) ? Math.max(0, o) : e.brightness,
+    background: Number.isFinite(a) ? Math.max(0, a) : e.background,
+    softness: Number.isFinite(n) ? Math.min(8, Math.max(0, n)) : e.softness
+  };
+}
+function Ts() {
+  const s = new Uint8Array([255, 255, 255, 255]), e = new h.DataTexture(s, 1, 1);
+  return e.needsUpdate = !0, e.magFilter = h.NearestFilter, e.minFilter = h.NearestFilter, e.generateMipmaps = !1, e;
+}
+export {
+  gs as A,
+  Zt as B,
+  ut as C,
+  ts as D,
+  Ee as E,
+  fs as F,
+  Bt as G,
+  _t as H,
+  It as I,
+  ls as J,
+  ct as M,
+  Gt as S,
+  xs as W,
+  Yt as a,
+  es as b,
+  ss as c,
+  dt as d,
+  De as e,
+  is as f,
+  Ft as g,
+  Dt as h,
+  ms as i,
+  Ss as j,
+  us as k,
+  ds as l,
+  Ts as m,
+  cs as n,
+  ps as o,
+  Rt as p,
+  hs as q,
+  $t as r,
+  Ut as s,
+  Vt as t,
+  Ot as u,
+  Nt as v,
+  Lt as w,
+  vs as x,
+  bs as y,
+  ws as z
+};
+//# sourceMappingURL=relighting-CSQF3UcL.js.map