@voluma/vlam 0.2.4 → 0.3.2

package/dist/relighting-Tiwep8yd.js

@@ -0,0 +1,977 @@
+var Tt = Object.defineProperty;
+var yt = (s, e, t) => e in s ? Tt(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t;
+var l = (s, e, t) => yt(s, typeof e != "symbol" ? e + "" : e, t);
+import * as h from "three/webgpu";
+import { bool as At, mat3 as ye, vec3 as S, float as w, modelViewMatrix as je, vec4 as Q, modelWorldMatrix as Mt, int as N, attribute as Ct, ivec2 as He, textureLoad as _, varying as re, colorSpaceToWorking as Pt, positionGeometry as Ne, Fn as $, cameraProjectionMatrix as kt, If as be, mix as ce, vec2 as te, Discard as qe, texture as Se, screenUV as Te, uniform as xe, uint as P, storage as ie, atomicStore as We, instanceIndex as I, atomicAdd as it, Loop as Ge, atomicLoad as ct } from "three/tsl";
+import { w as Rt } from "./logging-BfPdd7NJ.js";
+function Bt(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: w(1),
+    rotation: ye(S(1, 0, 0), S(0, 1, 0), S(0, 0, 1)),
+    visible: At(!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() : Mt.mul(Q(t.localCenter, 1)).xyz);
+    },
+    get viewCenter() {
+      return T ?? (T = t.makeViewCenter ? t.makeViewCenter() : je.mul(Q(t.localCenter, 1)).xyz);
+    },
+    get normal() {
+      return D ?? (D = t.makeNormal());
+    },
+    channel(C) {
+      let m = y.get(C);
+      return m || (m = t.makeChannel(C), y.set(C, 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 C of s) {
+    const m = C(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 Fe = 2048;
+function Et(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 (${Fe} 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 cs {
+  constructor(e) {
+    l(this, "width", Fe);
+    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), Ft(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 = De(a, this.width, this.rows, o), this.colorsTexture = De(
+      this.backing.colors,
+      this.width,
+      this.rows,
+      h.UnsignedByteType
+    ), this.covarianceATexture = De(n, this.width, this.rows, o), this.covarianceBTexture = De(
+      this.backing.covarianceB,
+      this.width,
+      this.rows,
+      h.FloatType
+    ), this.shPackedTextures = this.backing.shPacked.map(
+      (r) => Dt(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 Et(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 De(s, e, t, o) {
+  const a = new h.DataTexture(s, e, t, h.RGBAFormat, o);
+  return a.needsUpdate = !0, a;
+}
+function Dt(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 ls(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 Ft(s, e, t = Fe) {
+  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 us(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 lt = 24, mt = lt * lt;
+function zt(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 ds(s) {
+  const e = Math.max(1e-4, s.depth), t = Math.max(1e-4, s.focusDistance), o = zt(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 ?? mt;
+  return Math.min(i, d);
+}
+function ms(s, e) {
+  return Math.sqrt(Math.max(0, s) / Math.max(1e-9, e));
+}
+function hs(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 ut = 1024, Ut = 1e30, Vt = 0.35 * 0.35;
+function Ot(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), C = d.cross(c), m = c.cross(i), v = q.length(), L = C.length(), J = m.length(), le = v.greaterThanEqual(L).and(v.greaterThanEqual(J)), ue = L.greaterThan(v).and(L.greaterThanEqual(J)), de = le.select(q, ue.select(C, m)), u = de.div(de.length().max(1e-12)), x = u.dot(s.mul(u)), F = T.min(D).min(y).min(x).max(1e-12).mul(o), j = ye(S(F, 0, 0), S(0, F, 0), S(0, 0, F));
+  return s.mul(w(1).sub(t)).add(j.mul(t));
+}
+function Lt(s, e, t) {
+  const o = s.min(e);
+  return {
+    lambda1: ce(s, o, t),
+    lambda2: ce(e, o, t)
+  };
+}
+function _t(s, e, t, o, a) {
+  const n = o.div(a).pow(2), r = s.min(e).min(n), i = ce(s, r, t), d = ce(e, r, t), c = o.greaterThan(0);
+  return {
+    lambda1: c.select(i, s),
+    lambda2: c.select(d, e)
+  };
+}
+function fs(s) {
+  return s;
+}
+function ps() {
+  return xe(new h.Vector3());
+}
+function ht(s, e, t) {
+  const o = e.mul(N(4)), a = s.element(o), n = s.element(o.add(N(1))), r = s.element(o.add(N(2))), i = s.element(o.add(N(3))), d = a.xyz.mul(t.x).add(n.xyz.mul(t.y)).add(r.xyz.mul(t.z)).add(i.xyz), c = ye(a.xyz, n.xyz, r.xyz);
+  return { worldCenter: d, linear: c };
+}
+function Nt(s) {
+  return [0, 3, 8, 15][s] ?? 0;
+}
+function ft(s, e, t) {
+  if (s.mode === "palette") {
+    const n = _(e.covarianceBTexture, t).z.toInt(), r = n.mod(N(64)).mul(N(Nt(s.bands))), i = n.div(N(64));
+    return (d) => _(s.paletteTexture, He(r.add(N(d)), i)).xyz;
+  }
+  const o = s.textures.map(
+    (n) => _(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(P(2047)).toFloat().div(2047),
+      i.shiftRight(P(11)).bitAnd(P(1023)).toFloat().div(1023),
+      i.shiftRight(P(21)).bitAnd(P(2047)).toFloat().div(2047)
+    );
+    return s.range.min.add(a.mul(d));
+  };
+}
+const we = 0.4886025119029199, X = [
+  1.0925484305920792,
+  -1.0925484305920792,
+  0.31539156525252005,
+  -1.0925484305920792,
+  0.5462742152960396
+], O = [
+  -0.5900435899266435,
+  2.890611442640554,
+  -0.4570457994644658,
+  0.3731763325901154,
+  -0.4570457994644658,
+  1.445305721320277,
+  -0.5900435899266435
+];
+function gs(s, e, t, o) {
+  const a = o.x, n = o.y, r = o.z, i = ft(s, e, t), d = i(0).mul(n.mul(-we)).add(i(1).mul(r.mul(we))).add(i(2).mul(a.mul(-we)));
+  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(X[0]))).add(i(4).mul(n.mul(r).mul(X[1]))).add(i(5).mul(D.mul(2).sub(c).sub(T).mul(X[2]))).add(i(6).mul(a.mul(r).mul(X[3]))).add(i(7).mul(c.sub(T).mul(X[4])));
+  return s.bands === 2 ? y : y.add(i(8).mul(n.mul(c.mul(3).sub(T)).mul(O[0]))).add(i(9).mul(a.mul(n).mul(r).mul(O[1]))).add(i(10).mul(n.mul(D.mul(4).sub(c).sub(T)).mul(O[2]))).add(i(11).mul(r.mul(D.mul(2).sub(c.mul(3)).sub(T.mul(3))).mul(O[3]))).add(i(12).mul(a.mul(D.mul(4).sub(c).sub(T)).mul(O[4]))).add(i(13).mul(r.mul(c.sub(T)).mul(O[5]))).add(i(14).mul(a.mul(c.sub(T.mul(3))).mul(O[6])));
+}
+function xs(s, e, t) {
+  const { textures: o, sh: a, uniforms: n, settings: r, pick: i } = t, d = N(Fe), c = w(ut), T = -0.5 * r.maxStdDev * r.maxStdDev, D = Ct("splatIndex", "float").toInt(), y = He(D.mod(d), D.div(d)), q = _(o.colorsTexture, y), C = _(o.centersTexture, y).xyz, m = t.sourcePlacement, v = m ? ht(
+    m.columns,
+    _(m.sourceIdTexture, y).r.toInt(),
+    C
+  ) : null, L = v ? v.worldCenter : C, J = a === null ? null : (() => {
+    const b = v ? v.linear.inverse().mul(L.sub(n.localCameraPosition)).normalize() : L.sub(n.localCameraPosition).normalize(), f = b.x, g = b.y, B = b.z, p = ft(a, o, y), U = p(0).mul(g.mul(-we)).add(p(1).mul(B.mul(we))).add(p(2).mul(f.mul(-we)));
+    if (a.bands === 1) return U;
+    const A = f.mul(f), E = g.mul(g), M = B.mul(B), z = U.add(p(3).mul(f.mul(g).mul(X[0]))).add(p(4).mul(g.mul(B).mul(X[1]))).add(p(5).mul(M.mul(2).sub(A).sub(E).mul(X[2]))).add(p(6).mul(f.mul(B).mul(X[3]))).add(p(7).mul(A.sub(E).mul(X[4])));
+    return a.bands === 2 ? z : z.add(p(8).mul(g.mul(A.mul(3).sub(E)).mul(O[0]))).add(p(9).mul(f.mul(g).mul(B).mul(O[1]))).add(p(10).mul(g.mul(M.mul(4).sub(A).sub(E)).mul(O[2]))).add(
+      p(11).mul(
+        B.mul(M.mul(2).sub(A.mul(3)).sub(E.mul(3))).mul(O[3])
+      )
+    ).add(p(12).mul(f.mul(M.mul(4).sub(A).sub(E)).mul(O[4]))).add(p(13).mul(B.mul(A.sub(E)).mul(O[5]))).add(p(14).mul(f.mul(A.sub(E.mul(3))).mul(O[6])));
+  })(), le = J === null ? q : Q(q.rgb.add(J).clamp(0, 1), q.a), ue = () => {
+    const b = _(o.covarianceATexture, y), f = _(o.covarianceBTexture, y), g = ye(
+      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 = (v ? v.linear.mul(g).mul(v.linear.transpose()) : g).inverse(), U = n.localCameraPosition.sub(L), A = p.mul(p.mul(U)).normalize();
+    return A.mul(A.dot(U).sign());
+  }, de = (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 _(f.texture, y).r;
+  }, u = Bt(t.modifiers, n.localCameraPosition, {
+    index: D,
+    localCenter: L,
+    sourceCenter: C,
+    sourceToLocal: v == null ? void 0 : v.linear,
+    color: le,
+    makeNormal: ue,
+    makeChannel: de
+  }), x = re(
+    r.srgbOutput ? u.color : Pt(u.color, h.SRGBColorSpace)
+  ), R = re(Ne.xy), F = e === "pick" ? re(w(0), "pickViewDepth") : null, j = re(w(1), "vOpacityCompensation"), W = r.lodAlpha ? re(w(r.maxStdDev), "vAdjustedStdDev") : null, H = r.lodAlpha ? re(w(1), "vAlpha2") : null, me = r.lodAlpha ? re(w(1), "vVisualOpacity") : null;
+  if (s.vertexNode = $(() => {
+    const b = u.offset === null ? L : L.add(u.offset), f = je.mul(Q(b, 1)).toVar(), g = kt.mul(f).toVar(), B = Q(0, 0, 2, 1).toVar(), p = e === "pick" ? 1.2 + 2 * ut : 1.2, U = g.w.mul(p), A = g.z.greaterThan(U.negate()).and(g.x.abs().lessThan(U)).and(g.y.abs().lessThan(U)), E = u.visible === null ? A : A.and(u.visible);
+    return be(E, () => {
+      F && F.assign(f.z.negate());
+      const M = _(o.covarianceATexture, y), z = _(o.covarianceBTexture, y), Y = ye(
+        S(M.x, M.y, M.z),
+        S(M.y, M.w, z.x),
+        S(M.z, z.x, z.y)
+      ), se = v ? v.linear.mul(Y).mul(v.linear.transpose()) : Y;
+      let ne = u.rotation === null ? se : u.rotation.mul(se).mul(u.rotation.transpose());
+      if (u.isotropicCovarianceMix !== null) {
+        const k = u.isotropicVarianceScale ?? w(Vt);
+        ne = Ot(
+          ne,
+          S(0, 0, 1),
+          u.isotropicCovarianceMix,
+          k
+        );
+      }
+      const he = w(1).div(f.z), Ae = he.mul(he), Me = S(
+        n.focal.x.mul(he),
+        0,
+        n.focal.x.negate().mul(f.x).mul(Ae)
+      ), ze = S(
+        0,
+        n.focal.y.mul(he),
+        n.focal.y.negate().mul(f.y).mul(Ae)
+      ), Ce = je.toMat3().transpose(), fe = Ce.mul(Me), pe = Ce.mul(ze), Pe = fe.dot(ne.mul(fe)), ke = pe.dot(ne.mul(pe)), Ke = fe.dot(ne.mul(pe)), Ue = u.scaleSquared === null ? Pe : Pe.mul(u.scaleSquared), Ve = u.scaleSquared === null ? ke : ke.mul(u.scaleSquared), ve = u.scaleSquared === null ? Ke : Ke.mul(u.scaleSquared), Xe = f.z.negate().max(1e-4), Ze = n.dofFocusDistance.max(1e-4), pt = n.dofAperture.max(0).mul(0.5).div(Ze).atan(), gt = Xe.sub(Ze).abs().div(Xe), xt = n.focal.x.mul(pt.tan()), Qe = gt.mul(xt), Je = Qe.mul(Qe).min(w(mt)), Re = r.projectedFilterProfile === "lcc" ? 0.1 : 0.3, Be = Ue.add(Re).add(Je), Oe = Ve.add(Re).add(Je), Ee = ve, bt = Be.mul(Oe).sub(Ee.mul(Ee)).max(1e-9), Ye = (r.antialias || r.projectedFilterProfile === "lcc" ? Ue.mul(Ve).sub(ve.mul(ve)).max(0) : Ue.add(Re).mul(Ve.add(Re)).sub(ve.mul(ve)).max(1e-9)).div(bt).sqrt();
+      j.assign(
+        u.isotropicCovarianceMix === null ? Ye : ce(Ye, w(1), u.isotropicCovarianceMix)
+      );
+      const et = Be.add(Oe).mul(0.5), tt = te(Be.sub(Oe).mul(0.5), Ee).length();
+      let ee = et.add(tt), ge = et.sub(tt).max(0);
+      if (u.isotropicCovarianceMix !== null) {
+        const k = Lt(
+          ee,
+          ge,
+          u.isotropicCovarianceMix
+        );
+        if (ee = k.lambda1, ge = k.lambda2, u.isotropicScreenRadiusPx !== null) {
+          const V = _t(
+            ee,
+            ge,
+            u.isotropicCovarianceMix,
+            u.isotropicScreenRadiusPx,
+            w(r.maxStdDev)
+          );
+          ee = V.lambda1, ge = V.lambda2;
+        }
+      }
+      const Le = te(Ee, ee.sub(Be)).add(te(1e-6, 0)).normalize();
+      let Ie = w(r.maxStdDev);
+      if (r.lodAlpha && W && H && me) {
+        const k = le.a, V = k.mul(2), Z = V.mul(4).sub(3).min(5);
+        Ie = V.greaterThan(1).select(
+          w(r.maxStdDev).add(Z.sub(1).mul(0.7)),
+          w(r.maxStdDev)
+        ), W.assign(Ie), H.assign(V), me.assign(
+          k.greaterThan(0).select(u.color.a.div(k.max(1e-8)), w(1))
+        );
+      }
+      const wt = r.maxAspect && r.maxAspect > 0 ? ee.min(ge.mul(r.maxAspect * r.maxAspect)) : ee, st = w(r.minSplatSizePx ?? 0), nt = Le.mul(
+        wt.sqrt().mul(Ie).min(c).max(st)
+      ), ot = te(Le.y, Le.x.negate()).mul(
+        ge.sqrt().mul(Ie).min(c).max(st)
+      ), _e = () => {
+        const k = nt.mul(Ne.x).add(ot.mul(Ne.y)), V = g.xy.div(g.w);
+        B.assign(
+          Q(
+            V.add(k.mul(2).div(n.viewport)),
+            g.z.div(g.w),
+            1
+          )
+        );
+      };
+      let oe;
+      if (r.foveationMode === "page-table")
+        oe = null;
+      else if (r.foveationMode === "frontier") {
+        const k = f.z.negate(), Z = M.x.add(M.w).add(z.y).max(0).mul(1 / 3).sqrt().mul(2), G = z.w, ae = G.lessThan(0), at = G.abs(), vt = at.equal(0).select(w(Ut), at), rt = n.pixelScaleLimit.mul(k), St = ae.select(w(0), Z);
+        oe = vt.greaterThan(rt).and(St.lessThanEqual(rt));
+      } else {
+        const k = r.maxScreenRadiusPx ?? 0, V = r.minScreenRadiusPx ?? 0, Z = ee.sqrt().mul(r.maxStdDev);
+        let G = null;
+        if (k > 0 && (G = Z.lessThanEqual(n.screenBandMax)), V > 0) {
+          const ae = Z.greaterThan(n.screenBandMin);
+          G = G ? G.and(ae) : ae;
+        }
+        oe = G;
+      }
+      if (r.performanceProfile === "smooth") {
+        const k = nt.length(), V = ot.length(), Z = u.color.a, G = Z.greaterThanEqual(1 / 255).and(k.max(V).mul(2).greaterThanEqual(2)).and(Z.mul(k).mul(V).greaterThanEqual(3)), ae = u.isotropicCovarianceMix === null ? G : G.or(u.isotropicCovarianceMix.greaterThan(0));
+        be(oe ? ae.and(oe) : ae, _e);
+      } else oe ? be(oe, _e) : _e();
+    }), B;
+  })(), e === "display")
+    s.fragmentNode = $(() => {
+      const b = R.dot(R);
+      qe(b.greaterThan(1));
+      let f;
+      if (r.lodAlpha && W && H && me) {
+        const fe = b.mul(W.mul(W).mul(-0.5)).exp(), pe = H.mul(4).sub(3).min(5), Pe = pe.mul(pe).sub(1).mul(1 / Math.E).exp(), ke = fe.oneMinus().pow(Pe).oneMinus();
+        f = H.greaterThan(1).select(ke, fe.mul(H)).mul(me);
+      } else
+        f = b.mul(T).exp().mul(x.a);
+      const g = f.mul(j), B = Se(n.relightMap, Te), p = n.relightSoftness.div(n.viewport.x.max(1)), U = n.relightSoftness.div(n.viewport.y.max(1)), A = B, E = Se(n.relightMap, Te.add(te(p, 0))), M = Se(n.relightMap, Te.add(te(p.negate(), 0))), z = Se(n.relightMap, Te.add(te(0, U))), Y = Se(n.relightMap, Te.add(te(0, U.negate()))), se = A.a.add(E.a).add(M.a).add(z.a).add(Y.a).max(1e-4), ne = A.rgb.mul(A.a).add(E.rgb.mul(E.a)).add(M.rgb.mul(M.a)).add(z.rgb.mul(z.a)).add(Y.rgb.mul(Y.a)).div(se), he = se.mul(0.2), Ae = Q(ne, he), Me = n.relightSoftness.greaterThan(0.5).select(Ae, B), ze = ce(
+        S(n.relightBackground),
+        Me.rgb.mul(n.relightBrightness),
+        Me.a
+      ), Ce = ce(x.rgb, x.rgb.mul(ze), n.relightBlend);
+      return Q(Ce.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 = $(() => {
+      const b = R.dot(R);
+      qe(b.greaterThan(1));
+      let f;
+      if (r.lodAlpha && W && H && me) {
+        const M = b.mul(W.mul(W).mul(-0.5)).exp(), z = H.mul(4).sub(3).min(5), Y = z.mul(z).sub(1).mul(1 / Math.E).exp(), se = M.oneMinus().pow(Y).oneMinus();
+        f = H.greaterThan(1).select(se, M.mul(H)).mul(me);
+      } else
+        f = b.mul(T).exp().mul(x.a);
+      const g = f.mul(j);
+      qe(g.lessThan(i.alphaThreshold));
+      const p = F.sub(i.near).div(i.far.sub(i.near)).clamp(0, 1).mul(16777215), U = p.div(65536).floor(), A = p.mod(65536).div(256).floor(), E = p.mod(256).floor();
+      return Q(U.div(255), A.div(255), E.div(255), 1);
+    })(), s.transparent = !1, s.depthTest = !0, s.depthWrite = !0, s.side = h.DoubleSide, s.blending = h.NoBlending, s.toneMapped = !1;
+  }
+}
+function qt(s, e) {
+  const t = s.elements;
+  return e * Math.hypot(t[2], t[6], t[10]);
+}
+function Wt(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 Gt(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 $t {
+  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];
+      Wt(e, a) && (t += Gt(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, Rt(
+            `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 K = class K {
+  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", xe(new h.Vector4()));
+    l(this, "depthMin", xe(0));
+    l(this, "depthScale", xe(0));
+    /** Active splat count; a float compares exactly for counts < 2²⁴. */
+    l(this, "activeCount", xe(0));
+    /** Highest bucket index this sort uses; see {@link effectiveBucketCount}. */
+    l(this, "bucketMax", xe(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 } = K;
+    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 $t(this.workingAttributes);
+    const C = ie(T, "uint", d).toAtomic(), m = ie(D, "uint", d / c), v = ie(
+      y,
+      "uint",
+      d / c / c
+    ), L = ie(q, "uint", o), J = ie(e.sourceIndexAttribute, "uint", o), le = ie(e.splatIndexAttribute, "float", o), ue = r ? ie(r, "vec4", o) : null;
+    this.clearPass = $(() => {
+      We(C.element(I), P(0));
+    })().compute(d, [c]), this.histogramPass = $(() => {
+      be(w(I).lessThan(this.activeCount), () => {
+        const u = N(J.element(I)), x = a ? He(
+          u.mod(N(n)),
+          u.div(N(n))
+        ) : null, R = ue ? ue.element(u).xyz : _(a, x).xyz, F = i ? ht(
+          i.columns,
+          N(_(i.sourceIdTexture, x).r),
+          R
+        ).worldCenter : R, W = this.viewRow2.xyz.dot(F).add(this.viewRow2.w).sub(this.depthMin).mul(this.depthScale).clamp(0, this.bucketMax).toUint();
+        L.element(I).assign(W), it(C.element(W), P(1));
+      });
+    })().compute(o, [c]), this.scanBlocksPass = $(() => {
+      const u = I.mul(P(c)).toVar(), x = P(0).toVar();
+      Ge(c, ({ i: R }) => {
+        const F = C.element(u.add(P(R))), j = ct(F).toVar();
+        We(F, x), x.addAssign(j);
+      }), m.element(I).assign(x);
+    })().compute(d / c, [64]), this.scanBlockSumsPass = $(() => {
+      const u = I.mul(P(c)).toVar(), x = P(0).toVar();
+      Ge(c, ({ i: R }) => {
+        const F = m.element(u.add(P(R))), j = F.toVar();
+        F.assign(x), x.addAssign(j);
+      }), v.element(I).assign(x);
+    })().compute(d / c / c, [64]);
+    const de = $(() => {
+      be(I.equal(P(0)), () => {
+        const u = P(0).toVar();
+        Ge(d / c / c, ({ i: x }) => {
+          const R = v.element(x).toVar();
+          v.element(x).assign(u), u.addAssign(R);
+        });
+      });
+    })().compute(1, [64]);
+    this.addBlockSumOffsetsPass = $(() => {
+      m.element(I).addAssign(v.element(I.div(P(c))));
+    })().compute(d / c, [c]), this.addOffsetsPass = $(() => {
+      const u = C.element(I), x = m.element(I.shiftRight(P(Math.log2(c))));
+      We(u, ct(u).add(x));
+    })().compute(d, [c]), this.scatterPass = $(() => {
+      be(w(I).lessThan(this.activeCount), () => {
+        const u = J.element(I), x = L.element(I), R = it(C.element(x), P(1));
+        le.element(R).assign(w(u));
+      });
+    })().compute(o, [c]), this.sortPasses = [
+      this.clearPass,
+      this.histogramPass,
+      this.scanBlocksPass,
+      this.scanBlockSumsPass,
+      de,
+      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, K.MIN_BUCKET_COUNT), K.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 = qt(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 / K.BLOCK_SIZE;
+    return this.histogramPass.count = t, this.scatterPass.count = t, this.clearPass.count = n, this.scanBlocksPass.count = c, this.scanBlockSumsPass.count = c / K.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();
+      jt(this.renderer, this.workingAttributes);
+    }
+  }
+};
+l(K, "BUCKET_COUNT", 1 << 22), l(K, "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(K, "MIN_BUCKET_COUNT", 65536);
+let dt = K;
+function jt(s, e) {
+  const t = s._attributes;
+  if (t)
+    for (const o of e) t.delete(o);
+}
+const Ht = 2e6, Kt = 5e6, Xt = 8e6, Zt = 1e-6;
+function Qt(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 Jt(s, e = !1) {
+  return s < Ht ? e ? 33 : 0 : s < Kt ? e ? 66 : 50 : s < Xt ? e ? 133 : 100 : 1e3 / 6;
+}
+class bs {
+  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 = Qt(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 = Yt(e, this.previousModelView) > Zt;
+      n = this.legacyWasMoving && !i, this.legacyWasMoving = i;
+    } else
+      this.hasPreviousModelView = !0;
+    this.previousModelView.copy(e);
+    const r = this.sortIntervalMs ?? Jt(o, this.isMobile);
+    return this.forcePending ? !0 : e.equals(t) ? !1 : n ? !0 : r === 0 || a - this.lastAcceptedAt >= r;
+  }
+}
+function Yt(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 $e = new h.Vector2();
+function ws(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($e), r = $e.x, i = $e.y), { head: o, eye: a, width: r, height: i };
+}
+function vs(s) {
+  return s.isArrayCamera === !0;
+}
+function Ss(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 es = 1, ts = 2, ss = 1, ns = 0;
+function Ts(s, e = {
+  blend: es,
+  brightness: ts,
+  background: ss,
+  softness: ns
+}) {
+  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 ys() {
+  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 {
+  xs as A,
+  Qt as B,
+  dt as C,
+  ss as D,
+  De as E,
+  ps as F,
+  Et as G,
+  Nt as H,
+  It as I,
+  us as J,
+  lt as M,
+  $t as S,
+  bs as W,
+  es as a,
+  ts as b,
+  ns as c,
+  mt as d,
+  Fe as e,
+  cs as f,
+  zt as g,
+  Ft as h,
+  hs as i,
+  Ts as j,
+  ds as k,
+  ms as l,
+  ys as m,
+  ls as n,
+  gs as o,
+  Bt as p,
+  fs as q,
+  jt as r,
+  Vt as s,
+  Ot as t,
+  Lt as u,
+  qt as v,
+  _t as w,
+  Ss as x,
+  ws as y,
+  vs as z
+};
+//# sourceMappingURL=relighting-Tiwep8yd.js.map