@takram/three-geospatial 0.8.0 → 0.9.0

package/build/webgpu.js

@@ -1,82 +1,181 @@
-import { Vector3 as tt, Mesh as Te, Scene as zt, Camera as Ct, RenderTarget as st, RGBAFormat as ot, HalfFloatType as nt, LinearFilter as ae, Vector2 as P, Matrix4 as ne, AdditiveBlending as Rt, PlaneGeometry as Dt, PerspectiveCamera as Vt, SRGBColorSpace as Bt, CanvasTexture as At, Vector4 as it, NoColorSpace as Pt, DepthTexture as Ft } from "three";
-import { reference as ce, uniform as g, vec4 as b, positionGeometry as rt, texture as ie, uv as q, vec2 as f, add as D, luminance as jt, smoothstep as at, Fn as k, screenCoordinate as ut, time as kt, vec3 as N, equirectUV as Ot, fwidth as Ut, abs as X, positionLocal as It, positionPrevious as Et, sub as ue, nodeImmutable as Lt, instancedArray as Le, storage as Wt, uvec2 as lt, If as K, globalId as Ce, Return as Gt, atomicAdd as qt, instanceIndex as Ht, mat3 as ct, struct as Pe, min as ht, mul as $t, fract as Yt, distance as Xt, mix as re, rtt as Zt, convertToTexture as De, sqrt as Se, dot as ye, color as Qt, mat4 as Kt, mat2 as _t, bvec4 as Jt, uvec4 as es, ivec4 as ts, bvec3 as ss, uvec3 as os, ivec3 as ns, bvec2 as is, ivec2 as j, bool as rs, uint as as, int as Z, float as pe, textureSize as ve, viewZToLogarithmicDepth as dt, logarithmicDepthToViewZ as pt, perspectiveDepthToViewZ as mt, orthographicDepthToViewZ as us, PI2 as ls, PI as cs, cos as We, sin as Ge, viewZToPerspectiveDepth as hs, workgroupArray as ds, greaterThan as ps, invocationLocalIndex as xe, workgroupBarrier as ms, textureStore as fs, workgroupId as qe, and as ft, screenUV as xs, step as gs, max as xt, select as ys } from "three/tsl";
-import { NodeMaterial as le, TextureNode as vs, TempNode as _, NodeUpdateType as Q, RendererUtils as me, QuadMesh as Ne, StorageBufferAttribute as ws, MeshBasicNodeMaterial as Ts, NodeBuilder as Ss, Node as Ns, Texture3DNode as Ms, StorageTexture as bs } from "three/webgpu";
-import { Q as Fe } from "./shared3.js";
-import { i as w } from "./shared.js";
-import { hash as je } from "three/src/nodes/core/NodeUtils.js";
-let Re;
-function J(n, e, t) {
-  Re ??= /* @__PURE__ */ new WeakMap();
-  let s = Re.get(n);
-  return s == null && (s = {}, Re.set(n, s)), s[e] ??= t();
+import { Fn as U, logarithmicDepthToViewZ as ct, perspectiveDepthToViewZ as ut, orthographicDepthToViewZ as Et, viewZToLogarithmicDepth as lt, sub as ie, PI2 as kt, PI as It, cos as Xe, vec3 as M, sin as Ze, viewZToPerspectiveDepth as Lt, int as K, vec4 as z, cameraNear as je, cameraFar as Ee, depth as Wt, cameraPosition as $t, cameraProjectionMatrixInverse as qt, cameraWorldMatrix as Gt, cameraProjectionMatrix as Ht, cameraViewMatrix as Yt, uniform as g, reference as le, positionGeometry as ht, texture as oe, uv as I, vec2 as f, add as B, luminance as Xt, smoothstep as dt, OnBeforeObjectUpdate as Zt, OnObjectUpdate as _t, screenCoordinate as ke, time as Kt, equirectUV as Qt, fwidth as Jt, abs as _, positionLocal as es, positionPrevious as ts, nodeImmutable as pt, instancedArray as _e, storage as ss, uvec2 as re, If as ae, globalId as Ae, Return as os, atomicAdd as ns, instanceIndex as is, mat3 as mt, struct as Ie, min as ft, mul as rs, fract as as, distance as cs, mix as ne, rtt as us, convertToTexture as Oe, overloadingFn as Le, sqrt as be, dot as Ne, bvec2 as xt, bvec3 as gt, uvec3 as pe, bvec4 as vt, uvec4 as me, bool as Me, color as ls, mat4 as hs, mat2 as ds, ivec4 as yt, ivec3 as ps, ivec2 as O, uint as ms, float as G, workgroupArray as fs, greaterThan as xs, invocationLocalIndex as we, workgroupBarrier as gs, textureStore as vs, workgroupId as Ke, and as wt, frameId as ys, screenUV as ws, step as Ts, textureSize as Ns, max as Tt } from "three/tsl";
+import { StructTypeNode as Ss, NodeMaterial as ce, TextureNode as bs, TempNode as Q, NodeUpdateType as H, RendererUtils as ge, QuadMesh as ze, IndirectStorageBufferAttribute as Ms, MeshBasicNodeMaterial as zs, NodeBuilder as Cs, Node as Rs, Texture3DNode as Nt, StorageTexture as Ds, Data3DTexture as Bs, RedFormat as As, NearestFilter as Qe, RepeatWrapping as Ve, StorageTextureNode as Vs } from "three/webgpu";
+import { Vector3 as St, Plane as Ps, Mesh as bt, Scene as Fs, Camera as Os, RenderTarget as Mt, RGBAFormat as zt, HalfFloatType as Ct, LinearFilter as ue, Matrix4 as Se, Vector2 as ve, AdditiveBlending as Us, PlaneGeometry as js, PerspectiveCamera as Es, SRGBColorSpace as ks, CanvasTexture as Is, NoColorSpace as Ls, Vector4 as Ws, DepthTexture as $s } from "three";
+import { CSMShadowNode as qs } from "three/examples/jsm/csm/CSMShadowNode.js";
+import { Q as Gs, D as Hs, S as Ys } from "./shared2.js";
+import { i as y } from "./shared.js";
+import { hash as We, hashString as Xs } from "three/src/nodes/core/NodeUtils.js";
+function Je(s) {
+  if (typeof s == "string")
+    return s;
+  if ("layout" in s && s.layout instanceof Ss) {
+    if (s.layout.name == null)
+      throw new Error("Struct name is required.");
+    return s.layout.name;
+  }
+  throw new Error(`Unsupported layout type: ${s}`);
 }
-const No = (n) => J(
-  n,
+function V({
+  typeOnly: s = !1,
+  ...e
+}) {
+  return s ? (t) => U(t) : (t) => U(t).setLayout({
+    ...e,
+    type: Je(e.type),
+    inputs: e.inputs?.map((o) => ({
+      ...o,
+      type: Je(o.type)
+    })) ?? []
+  });
+}
+function L(s) {
+  return U((e, t) => {
+    const o = s(...e);
+    return typeof o == "function" ? o(t) : o;
+  });
+}
+const Rt = /* @__PURE__ */ L(
+  (s, e, t, o) => (n) => {
+    t ??= fe(e), o ??= xe(e);
+    const i = e?.isPerspectiveCamera === !0;
+    return n.renderer.logarithmicDepthBuffer ? ct(s, t, o) : i ? ut(s, t, o) : Et(s, t, o);
+  }
+), Ue = (s, e, t) => {
+  e ??= je, t ??= Ee;
+  const o = ct(s, e, t);
+  return Lt(o, e, t);
+}, un = (s, e, t) => {
+  e ??= je, t ??= Ee;
+  const o = ut(s, e, t);
+  return lt(o, e, t);
+}, ln = (s, e, t, o, n) => {
+  const i = o.element(K(2)).element(K(3)), r = o.element(K(3)).element(K(3)), a = z(M(s.flipY(), e).mul(2).sub(1), 1).mul(t.mul(i).add(r));
+  return n.mul(a).xyz;
+}, Pe = [
+  [58.1375, 2.7747, 26.8183],
+  [-150.5666, 4.2109, -88.5066],
+  [130.5887, -14.0195, 109.0745],
+  [-42.3277, 4.8052, -60.1097],
+  [4.5974, 2.1856, 12.5925],
+  [0.1357, 0.0914, 0.1067]
+], Zs = /* @__PURE__ */ V({
+  name: "turbo",
+  type: "vec3",
+  inputs: [{ name: "x", type: "float" }]
+})(([s]) => {
+  const e = M(...Pe[0]).toVar();
+  for (let t = 1; t < Pe.length; ++t)
+    e.assign(M(...Pe[t]).add(s.mul(e)));
+  return e;
+}), hn = L(
+  (s, e, t, o) => {
+    t ??= fe(e), o ??= xe(e);
+    const n = Rt(s, e, t, o);
+    return Zs(lt(n, t, o));
+  }
+), dn = /* @__PURE__ */ V({
+  name: "equirectToDirectionWorld",
+  type: "vec3",
+  inputs: [{ name: "uv", type: "vec2" }]
+})(([s]) => {
+  const e = ie(0.5, s.x).mul(kt), t = ie(s.y, 0.5).mul(It), o = Xe(t);
+  return M(o.mul(Xe(e)), Ze(t), o.mul(Ze(e)));
+});
+let Fe;
+function J(s, e, t) {
+  Fe ??= /* @__PURE__ */ new WeakMap();
+  let o = Fe.get(s);
+  return o == null && (o = {}, Fe.set(s, o)), o[e] ??= t();
+}
+const pn = (s) => s != null ? J(
+  s,
   "projectionMatrix",
-  () => ce("projectionMatrix", "mat4", n).setName("projectionMatrix")
-), Mo = (n) => J(
-  n,
+  () => le("projectionMatrix", "mat4", s).setName(
+    "projectionMatrix"
+  )
+) : Ht, mn = (s) => s != null ? J(
+  s,
   "viewMatrix",
-  () => ce("matrixWorldInverse", "mat4", n).setName("viewMatrix")
-), bo = (n) => J(
-  n,
+  () => le("matrixWorldInverse", "mat4", s).setName("viewMatrix")
+) : Yt, fn = (s) => s != null ? J(
+  s,
   "inverseProjectionMatrix",
-  () => ce("projectionMatrixInverse", "mat4", n).setName(
+  () => le("projectionMatrixInverse", "mat4", s).setName(
     "inverseProjectionMatrix"
   )
-), zo = (n) => J(
-  n,
+) : qt, xn = (s) => s != null ? J(
+  s,
   "inverseViewMatrix",
-  () => ce("matrixWorld", "mat4", n).setName("inverseViewMatrix")
-), Co = (n) => J(
-  n,
+  () => le("matrixWorld", "mat4", s).setName("inverseViewMatrix")
+) : Gt, gn = (s) => s != null ? J(
+  s,
   "cameraPositionWorld",
-  () => g(new tt()).setName("cameraPositionWorld").onRenderUpdate((e, { value: t }) => {
-    t.setFromMatrixPosition(n.matrixWorld);
+  () => g("vec3").setName("cameraPositionWorld").onRenderUpdate((e, { value: t }) => {
+    t.setFromMatrixPosition(s.matrixWorld);
   })
-), Ve = (n) => J(
-  n,
+) : $t, fe = (s) => s != null ? J(
+  s,
   "cameraNear",
-  () => ce("near", "float", n).setName("cameraNear")
-), Be = (n) => J(
-  n,
+  () => le("near", "float", s).setName("cameraNear")
+) : je, xe = (s) => s != null ? J(
+  s,
   "cameraFar",
-  () => ce("far", "float", n).setName("cameraFar")
-);
-async function ke(n, e) {
-  return await n.debug.getShaderAsync(new zt(), new Ct(), e).then((t) => t).catch((t) => (console.error(t), { fragmentShader: null, vertexShader: null }));
+  () => le("far", "float", s).setName("cameraFar")
+) : Ee, vn = U(
+  ({ camera: s }) => Rt(Wt, s)
+).once()().toVar("viewZ"), _s = /* @__PURE__ */ new St(), Ks = /* @__PURE__ */ new Ps();
+class yn extends qs {
+  updateBefore(e) {
+    super.updateBefore(e);
+    const { lights: t } = this;
+    if (t.length < 2)
+      return;
+    const o = t[t.length - 1], n = _s.subVectors(o.target.position, o.position).normalize(), i = Ks.setFromNormalAndCoplanarPoint(
+      n,
+      o.position
+    );
+    for (let r = 0; r < t.length - 1; ++r) {
+      const c = t[r];
+      i.projectPoint(c.position, c.position), c.target.position.copy(c.position).add(n);
+    }
+  }
 }
-function Ro(n, e) {
-  const t = new Te(new Fe(), e);
-  ke(n, t).then((s) => {
-    console.log(s.fragmentShader);
-  }).finally(() => {
+async function Ce(s, e) {
+  const t = new bt(new Gs(), e);
+  try {
+    return await s.debug.getShaderAsync(new Fs(), new Os(), t);
+  } catch (o) {
+    return console.error(o), { vertexShader: null, fragmentShader: null };
+  } finally {
     t.geometry.dispose();
-  });
+  }
 }
-function Do(n, e) {
-  const t = new Te(new Fe(), e);
-  ke(n, t).then((s) => {
-    console.log(s.vertexShader);
-  }).finally(() => {
-    t.geometry.dispose();
-  });
+async function wn(s, e) {
+  const { vertexShader: t, fragmentShader: o } = await Ce(s, e);
+  return t != null && o != null ? `// Vertex shader
+
+${t}
+// Fragment shader
+
+${o}` : null;
 }
-function Vo(n, e) {
-  const t = new le();
-  t.vertexNode = b(rt.xy, 0, 1), t.fragmentNode = e;
-  const s = new Te(new Fe(), t);
-  ke(n, s).then((o) => {
-    console.log(o.fragmentShader);
-  }).finally(() => {
-    t.dispose(), s.geometry.dispose();
-  });
+async function Tn(s, e) {
+  return (await Ce(s, e)).vertexShader;
 }
-function Bo(n, e, t) {
-  const s = n[e];
-  return n[e] = ((...o) => (t(...o), s.apply(n, o))), n;
+async function Nn(s, e) {
+  return (await Ce(s, e)).fragmentShader;
 }
-class zs extends vs {
+async function Sn(s, e) {
+  const t = new ce();
+  t.vertexNode = z(ht.xy, 0, 1), t.fragmentNode = e.toConst("debugNode");
+  const o = await Ce(s, t);
+  return t.dispose(), o.fragmentShader;
+}
+function bn(s, e, t) {
+  const o = s[e];
+  return s[e] = ((...n) => (t(...n), o.apply(s, n))), s;
+}
+class Qs extends bs {
   static get type() {
     return "OutputTextureNode";
   }
@@ -90,26 +189,26 @@ class zs extends vs {
     return new this.constructor(this.owner, this.value);
   }
 }
-const Oe = (...n) => new zs(...n);
-class Me extends _ {
+const $e = (...s) => new Qs(...s);
+class Re extends Q {
   constructor(e) {
-    super("vec4"), this.resolutionScale = 1, this.renderTargets = [], this.inputNode = e, this.updateBeforeType = Q.FRAME;
+    super("vec4"), this.resolutionScale = 1, this.renderTargets = [], this.updateBeforeType = H.FRAME, this.inputNode = e;
   }
   static get type() {
     return "FilterNode";
   }
   createRenderTarget(e) {
-    const t = new st(1, 1, {
+    const t = new Mt(1, 1, {
       depthBuffer: !1,
-      type: nt,
-      format: ot
-    }), s = t.texture;
-    s.minFilter = ae, s.magFilter = ae, s.generateMipmaps = !1;
-    const o = this.constructor.type;
-    return s.name = e != null ? `${o}.${e}` : o, this.renderTargets.push(t), t;
+      type: Ct,
+      format: zt
+    }), o = t.texture;
+    o.minFilter = ue, o.magFilter = ue, o.generateMipmaps = !1;
+    const n = this.constructor.type;
+    return o.name = e != null ? `${n}_${e}` : n, this.renderTargets.push(t), t;
   }
   getTextureNode() {
-    return w(
+    return y(
       this.textureNode != null,
       "outputTexture must be specified before getTextureNode() is called."
     ), this.textureNode;
@@ -118,17 +217,17 @@ class Me extends _ {
     return this.textureNode?.value ?? null;
   }
   set outputTexture(e) {
-    this.textureNode = e != null ? Oe(this, e) : void 0;
+    this.textureNode = e != null ? $e(this, e) : void 0;
   }
   setup(e) {
-    const { inputNode: t, textureNode: s } = this;
-    return w(
+    const { inputNode: t, textureNode: o } = this;
+    return y(
       t != null,
       "inputNode must be specified before being setup."
-    ), w(
-      s != null,
+    ), y(
+      o != null,
       "outputTexture must be specified before being setup."
-    ), s.uvNode = t.uvNode, s;
+    ), o.uvNode = t.uvNode, o;
   }
   dispose() {
     for (const e of this.renderTargets)
@@ -136,20 +235,22 @@ class Me extends _ {
     super.dispose();
   }
 }
-const { resetRendererState: Cs, restoreRendererState: Rs } = me;
-class Ue extends Me {
+const { resetRendererState: Js, restoreRendererState: eo } = ge;
+class qe extends Re {
   constructor(e, t) {
-    super(e), this.downsampleRTs = [], this.upsampleRTs = [], this.downsampleMaterial = new le(), this.upsampleMaterial = new le(), this.mesh = new Ne(), this.inputTexelSize = g(new P()), this.downsampleNode = ie();
-    for (let s = 0; s < t; ++s)
-      this.downsampleRTs[s] = this.createRenderTarget(`Downsample${s}`), s < t - 1 && (this.upsampleRTs[s] = this.createRenderTarget(`Upsample${s}`));
+    super(e), this.downsampleRTs = [], this.upsampleRTs = [], this.downsampleMaterial = new ce(), this.upsampleMaterial = new ce(), this.mesh = new ze(), this.inputTexelSize = g("vec2"), this.downsampleNode = oe();
+    const o = this.constructor.type.replace(/Node$/, "");
+    this.downsampleMaterial.name = `${o}_downsample`, this.upsampleMaterial.name = `${o}_upsample`, this.mesh.name = o;
+    for (let n = 0; n < t; ++n)
+      this.downsampleRTs[n] = this.createRenderTarget(`downsample${n}`), n < t - 1 && (this.upsampleRTs[n] = this.createRenderTarget(`upsample${n}`));
     this.outputTexture = this.upsampleRTs[0].texture;
   }
   setSize(e, t) {
-    const { resolutionScale: s } = this;
-    let o = Math.max(Math.round(e * s), 1), i = Math.max(Math.round(t * s), 1);
-    const { downsampleRTs: r, upsampleRTs: u } = this;
+    const { resolutionScale: o } = this;
+    let n = Math.max(Math.round(e * o), 1), i = Math.max(Math.round(t * o), 1);
+    const { downsampleRTs: r, upsampleRTs: c } = this;
     for (let a = 0; a < r.length; ++a)
-      o = Math.max(Math.round(o / 2), 1), i = Math.max(Math.round(i / 2), 1), r[a].setSize(o, i), a < u.length && u[a].setSize(o, i);
+      n = Math.max(Math.round(n / 2), 1), i = Math.max(Math.round(i / 2), 1), r[a].setSize(n, i), a < c.length && c[a].setSize(n, i);
     return this;
   }
   updateBefore({ renderer: e }) {
@@ -157,33 +258,33 @@ class Ue extends Me {
       return;
     const {
       downsampleRTs: t,
-      upsampleRTs: s,
-      mesh: o,
+      upsampleRTs: o,
+      mesh: n,
       inputNode: i,
       inputTexelSize: r,
-      downsampleNode: u
+      downsampleNode: c
     } = this;
-    w(i != null);
-    const { width: a, height: l } = i.value;
-    this.setSize(a, l);
-    const c = i.value;
-    this.rendererState = Cs(e, this.rendererState), o.material = this.downsampleMaterial;
-    for (const h of t) {
+    y(i != null);
+    const { width: a, height: h } = i.value;
+    this.setSize(a, h);
+    const l = i.value;
+    this.rendererState = Js(e, this.rendererState), n.material = this.downsampleMaterial;
+    for (const u of t) {
       const { width: p, height: d } = i.value;
-      r.value.set(1 / p, 1 / d), e.setRenderTarget(h), o.render(e), i.value = h.texture;
+      r.value.set(1 / p, 1 / d), e.setRenderTarget(u), n.render(e), i.value = u.texture;
     }
-    o.material = this.upsampleMaterial;
-    for (let h = s.length - 1; h >= 0; --h) {
-      const p = s[h], { width: d, height: m } = i.value;
-      r.value.set(1 / d, 1 / m), u.value = t[h].texture, e.setRenderTarget(p), o.render(e), i.value = p.texture;
+    n.material = this.upsampleMaterial;
+    for (let u = o.length - 1; u >= 0; --u) {
+      const p = o[u], { width: d, height: m } = i.value;
+      r.value.set(1 / d, 1 / m), c.value = t[u].texture, e.setRenderTarget(p), n.render(e), i.value = p.texture;
     }
-    Rs(e, this.rendererState), i.value = c;
+    eo(e, this.rendererState), i.value = l;
   }
   setup(e) {
     const { inputNode: t } = this;
-    w(t != null);
-    const { downsampleMaterial: s, upsampleMaterial: o } = this;
-    return s.fragmentNode = this.setupDownsampleNode(e), o.fragmentNode = this.setupUpsampleNode(e), s.needsUpdate = !0, o.needsUpdate = !0, super.setup(e);
+    y(t != null);
+    const { downsampleMaterial: o, upsampleMaterial: n } = this;
+    return o.fragmentNode = this.setupDownsampleNode(e), n.fragmentNode = this.setupUpsampleNode(e), o.needsUpdate = !0, n.needsUpdate = !0, super.setup(e);
   }
   dispose() {
     for (const e of this.downsampleRTs)
@@ -193,48 +294,48 @@ class Ue extends Me {
     this.downsampleMaterial.dispose(), this.upsampleMaterial.dispose(), this.mesh.geometry.dispose(), super.dispose();
   }
 }
-const gt = (n, e) => {
-  const t = q(), s = b(1, 1, -1, -1).mul(e.xyxy).add(t.xyxy).toVertexStage(), o = b(2, 2, -2, -2).mul(e.xyxy).add(t.xyxy).toVertexStage(), i = s.zy, r = s.xy, u = s.zw, a = s.xw, l = f(t.x, o.y), c = f(o.z, t.y), h = f(o.x, t.y), p = f(t.x, o.w), d = o.zy, m = o.xy, x = o.zw, z = o.xw;
-  return D(
-    D(
-      n.sample(t),
-      n.sample(i),
-      n.sample(r),
-      n.sample(u),
-      n.sample(a)
+const Dt = (s, e) => {
+  const t = I(), o = z(1, 1, -1, -1).mul(e.xyxy).add(t.xyxy).toVertexStage(), n = z(2, 2, -2, -2).mul(e.xyxy).add(t.xyxy).toVertexStage(), i = o.zy, r = o.xy, c = o.zw, a = o.xw, h = f(t.x, n.y), l = f(n.z, t.y), u = f(n.x, t.y), p = f(t.x, n.w), d = n.zy, m = n.xy, x = n.zw, w = n.xw;
+  return B(
+    B(
+      s.sample(t),
+      s.sample(i),
+      s.sample(r),
+      s.sample(c),
+      s.sample(a)
     ).mul(1 / 8),
-    D(
-      n.sample(l),
-      n.sample(c),
-      n.sample(h),
-      n.sample(p)
+    B(
+      s.sample(h),
+      s.sample(l),
+      s.sample(u),
+      s.sample(p)
     ).mul(1 / 16),
-    D(
-      n.sample(d),
-      n.sample(m),
-      n.sample(x),
-      n.sample(z)
+    B(
+      s.sample(d),
+      s.sample(m),
+      s.sample(x),
+      s.sample(w)
     ).mul(1 / 32)
   );
-}, Ds = (n, e) => {
-  const t = q(), s = b(1, 1, -1, -1).mul(e.xyxy).add(t.xyxy).toVertexStage(), o = f(t.x, s.y), i = f(s.z, t.y), r = f(s.x, t.y), u = f(t.x, s.w), a = s.zy, l = s.xy, c = s.zw, h = s.xw;
-  return D(
-    n.sample(t).mul(0.25),
-    D(
-      n.sample(o),
-      n.sample(i),
-      n.sample(r),
-      n.sample(u)
+}, to = (s, e) => {
+  const t = I(), o = z(1, 1, -1, -1).mul(e.xyxy).add(t.xyxy).toVertexStage(), n = f(t.x, o.y), i = f(o.z, t.y), r = f(o.x, t.y), c = f(t.x, o.w), a = o.zy, h = o.xy, l = o.zw, u = o.xw;
+  return B(
+    s.sample(t).mul(0.25),
+    B(
+      s.sample(n),
+      s.sample(i),
+      s.sample(r),
+      s.sample(c)
     ).mul(0.125),
-    D(
-      n.sample(a),
-      n.sample(l),
-      n.sample(c),
-      n.sample(h)
+    B(
+      s.sample(a),
+      s.sample(h),
+      s.sample(l),
+      s.sample(u)
     ).mul(0.0625)
   );
 };
-class Vs extends Ue {
+class so extends qe {
   static get type() {
     return "MipmapBlurNode";
   }
@@ -242,40 +343,42 @@ class Vs extends Ue {
     super(e, t), this.resolutionScale = 0.5;
   }
   setupDownsampleNode(e) {
-    return w(this.inputNode != null), gt(this.inputNode, this.inputTexelSize);
+    return y(this.inputNode != null), Dt(this.inputNode, this.inputTexelSize);
   }
   setupUpsampleNode(e) {
-    return w(this.inputNode != null), Ds(this.inputNode, this.inputTexelSize);
+    return y(this.inputNode != null), to(this.inputNode, this.inputTexelSize);
   }
 }
-const Ao = (...n) => new Vs(...n), { resetRendererState: Bs, restoreRendererState: As } = me;
-class Ps extends Me {
+const Mn = (...s) => new so(...s), { resetRendererState: oo, restoreRendererState: no } = ge;
+class io extends Re {
   constructor(e) {
-    super(e), this.material = new le(), this.mesh = new Ne(this.material), this.inputTexelSize = g(new P()), this.renderTarget = this.createRenderTarget(), this.outputTexture = this.renderTarget.texture;
+    super(e), this.material = new ce(), this.mesh = new ze(this.material), this.inputTexelSize = g("vec2");
+    const t = this.constructor.type.replace(/Node$/, "");
+    this.material.name = t, this.mesh.name = t, this.renderTarget = this.createRenderTarget(), this.outputTexture = this.renderTarget.texture;
   }
   setSize(e, t) {
-    const { resolutionScale: s } = this, o = Math.max(Math.round(e * s), 1), i = Math.max(Math.round(t * s), 1);
-    return this.renderTarget.setSize(o, i), this;
+    const { resolutionScale: o } = this, n = Math.max(Math.round(e * o), 1), i = Math.max(Math.round(t * o), 1);
+    return this.renderTarget.setSize(n, i), this;
   }
   updateBefore({ renderer: e }) {
     if (e == null)
       return;
     const { inputNode: t } = this;
-    w(t != null);
-    const { width: s, height: o } = t.value;
-    this.setSize(s, o), this.inputTexelSize.value.set(1 / s, 1 / o), this.rendererState = Bs(e, this.rendererState), e.setRenderTarget(this.renderTarget), this.mesh.render(e), As(e, this.rendererState);
+    y(t != null);
+    const { width: o, height: n } = t.value;
+    this.setSize(o, n), this.inputTexelSize.value.set(1 / o, 1 / n), this.rendererState = oo(e, this.rendererState), e.setRenderTarget(this.renderTarget), this.mesh.render(e), no(e, this.rendererState);
   }
   setup(e) {
     const { inputNode: t } = this;
-    w(t != null);
-    const { material: s } = this;
-    return s.fragmentNode = this.setupOutputNode(e), s.needsUpdate = !0, super.setup(e);
+    y(t != null);
+    const { material: o } = this;
+    return o.fragmentNode = this.setupOutputNode(e), o.needsUpdate = !0, super.setup(e);
   }
   dispose() {
     this.renderTarget.dispose(), this.material.dispose(), this.mesh.geometry.dispose(), super.dispose();
   }
 }
-class yt extends Ps {
+class Bt extends io {
   constructor(e) {
     super(e), this.thresholdLevel = g(5), this.thresholdRange = g(1), this.resolutionScale = 0.5;
   }
@@ -283,108 +386,89 @@ class yt extends Ps {
     return "DownsampleThresholdNode";
   }
   setupOutputNode() {
-    const { inputNode: e, thresholdLevel: t, thresholdRange: s, inputTexelSize: o } = this;
-    w(e != null);
-    const i = gt(e, o), r = jt(i.rgb), u = at(
+    const { inputNode: e, thresholdLevel: t, thresholdRange: o, inputTexelSize: n } = this;
+    y(e != null);
+    const i = Dt(e, n), r = Xt(i.rgb), c = dt(
       t,
-      t.add(s),
+      t.add(o),
       r
     );
-    return b(i.rgb, r).mul(u);
+    return z(i.rgb, r).mul(c);
   }
 }
-const Po = (...n) => new yt(...n);
-function He(n) {
-  if (typeof n == "string")
-    return n;
-  if (n.layout.name == null)
-    throw new Error("Struct name is required.");
-  return n.layout.name;
-}
-function we({
-  typeOnly: n = !1,
-  ...e
-}) {
-  return n ? (t) => k(t) : (t) => k(t).setLayout({
-    ...e,
-    type: He(e.type),
-    inputs: e.inputs?.map((s) => ({
-      ...s,
-      type: He(s.type)
-    })) ?? []
-  });
-}
-function ee(n) {
-  return k((e, t) => {
-    const s = n(...e);
-    return typeof s == "function" ? s(t) : s;
-  });
-}
-const { resetRendererState: Fs, restoreRendererState: js } = me;
-class ks extends Me {
+const zn = (...s) => new Bt(...s), Cn = (s) => {
+  const e = _t(s);
+  return e.updateType = H.NONE, e;
+}, Rn = (s) => {
+  const e = Zt(s);
+  return e.updateBeforeType = H.FRAME, e;
+}, { resetRendererState: ro, restoreRendererState: ao } = ge;
+class co extends Re {
   constructor(e) {
-    super(e), this.iterations = 1, this.material = new le(), this.mesh = new Ne(this.material), this.inputTexelSize = g(new P()), this.direction = g(new P()), this.horizontalRT = this.createRenderTarget("Horizontal"), this.verticalRT = this.createRenderTarget("Vertical"), this.outputTexture = this.verticalRT.texture;
+    super(e), this.iterations = 1, this.material = new ce(), this.mesh = new ze(this.material), this.inputTexelSize = g("vec2"), this.direction = g("vec2");
+    const t = this.constructor.type.replace(/Node$/, "");
+    this.material.name = t, this.mesh.name = t, this.horizontalRT = this.createRenderTarget("horizontal"), this.verticalRT = this.createRenderTarget("vertical"), this.outputTexture = this.verticalRT.texture;
   }
   setSize(e, t) {
-    const { resolutionScale: s } = this, o = Math.max(Math.round(e * s), 1), i = Math.max(Math.round(t * s), 1);
-    return this.horizontalRT.setSize(o, i), this.verticalRT.setSize(o, i), this;
+    const { resolutionScale: o } = this, n = Math.max(Math.round(e * o), 1), i = Math.max(Math.round(t * o), 1);
+    return this.horizontalRT.setSize(n, i), this.verticalRT.setSize(n, i), this;
   }
   updateBefore({ renderer: e }) {
     if (e == null)
       return;
-    const { horizontalRT: t, verticalRT: s, mesh: o, inputNode: i, direction: r } = this;
-    w(i != null);
-    const { width: u, height: a } = i.value;
-    this.setSize(u, a), this.inputTexelSize.value.set(1 / u, 1 / a);
-    const l = i.value;
-    this.rendererState = Fs(e, this.rendererState);
-    for (let c = 0; c < this.iterations; ++c)
-      r.value.set(1, 0), e.setRenderTarget(t), o.render(e), i.value = t.texture, r.value.set(0, 1), e.setRenderTarget(s), o.render(e), i.value = s.texture;
-    js(e, this.rendererState), i.value = l;
+    const { horizontalRT: t, verticalRT: o, mesh: n, inputNode: i, direction: r } = this;
+    y(i != null);
+    const { width: c, height: a } = i.value;
+    this.setSize(c, a), this.inputTexelSize.value.set(1 / c, 1 / a);
+    const h = i.value;
+    this.rendererState = ro(e, this.rendererState);
+    for (let l = 0; l < this.iterations; ++l)
+      r.value.set(1, 0), e.setRenderTarget(t), n.render(e), i.value = t.texture, r.value.set(0, 1), e.setRenderTarget(o), n.render(e), i.value = o.texture;
+    ao(e, this.rendererState), i.value = h;
   }
   setup(e) {
     const { inputNode: t } = this;
-    w(t != null);
-    const { material: s } = this;
-    return s.fragmentNode = this.setupOutputNode(e), s.needsUpdate = !0, super.setup(e);
+    y(t != null);
+    const { material: o } = this;
+    return o.fragmentNode = this.setupOutputNode(e), o.needsUpdate = !0, super.setup(e);
   }
   dispose() {
     this.horizontalRT.dispose(), this.verticalRT.dispose(), this.material.dispose(), this.mesh.geometry.dispose(), super.dispose();
   }
 }
-function $e(n) {
-  if (w(n >= 0), n === 0)
+function et(s) {
+  if (y(s >= 0), s === 0)
     return new Float64Array(0);
-  if (n === 1)
+  if (s === 1)
     return new Float64Array([1]);
-  let e = new Float64Array(n), t = new Float64Array(n), s = t;
-  for (let o = 1; o <= n; ++o) {
-    for (let i = 0; i < o; ++i)
-      t[i] = i === 0 || i === o - 1 ? 1 : e[i - 1] + e[i];
-    s = t, t = e, e = s;
+  let e = new Float64Array(s), t = new Float64Array(s), o = t;
+  for (let n = 1; n <= s; ++n) {
+    for (let i = 0; i < n; ++i)
+      t[i] = i === 0 || i === n - 1 ? 1 : e[i - 1] + e[i];
+    o = t, t = e, e = o;
   }
-  return s;
+  return o;
 }
-function Os(n, e = 2) {
-  w(n >= 3);
-  const t = n + e * 2, s = e > 0 ? $e(t).slice(e, -e) : $e(t), o = Math.floor((s.length - 1) / 2), i = s.reduce((h, p) => h + p, 0), r = s.slice(o), u = [...Array(o + 1).keys()], a = new Float64Array(Math.floor(u.length / 2)), l = new Float64Array(a.length);
+function uo(s, e = 2) {
+  y(s >= 3);
+  const t = s + e * 2, o = e > 0 ? et(t).slice(e, -e) : et(t), n = Math.floor((o.length - 1) / 2), i = o.reduce((u, p) => u + p, 0), r = o.slice(n), c = [...Array(n + 1).keys()], a = new Float64Array(Math.floor(c.length / 2)), h = new Float64Array(a.length);
   a[0] = r[0] / i;
-  for (let h = 1, p = 1; h < u.length - 1; h += 2, ++p) {
-    const d = u[h], m = u[h + 1], x = r[h], z = r[h + 1], T = x + z, B = (d * x + m * z) / T;
-    a[p] = T / i, l[p] = B;
+  for (let u = 1, p = 1; u < c.length - 1; u += 2, ++p) {
+    const d = c[u], m = c[u + 1], x = r[u], w = r[u + 1], T = x + w, C = (d * x + m * w) / T;
+    a[p] = T / i, h[p] = C;
   }
-  const c = (a.reduce((h, p) => h + p, 0) - a[0] * 0.5) * 2;
-  if (c !== 0) {
-    const h = 1 / c;
+  const l = (a.reduce((u, p) => u + p, 0) - a[0] * 0.5) * 2;
+  if (l !== 0) {
+    const u = 1 / l;
     for (let p = 0; p < a.length; ++p)
-      a[p] *= h;
+      a[p] *= u;
   }
   return {
-    offsets: l,
+    offsets: h,
     weights: a
   };
 }
-class vt extends ks {
+class At extends co {
   static get type() {
     return "GaussianBlurNode";
   }
@@ -392,34 +476,34 @@ class vt extends ks {
     super(e), this.kernelSize = t;
   }
   setupOutputNode(e) {
-    const { inputNode: t, inputTexelSize: s, direction: o } = this;
-    w(t != null);
-    const { offsets: i, weights: r } = Os(this.kernelSize);
-    return k(() => {
-      const u = q(), a = o.mul(s).toVertexStage(), l = t.sample(u).mul(r[0]);
-      for (let c = 1; c < i.length; ++c) {
-        const h = a.mul(i[c]);
-        l.addAssign(
-          D(
-            t.sample(u.add(h)),
-            t.sample(u.sub(h))
-          ).mul(r[c])
+    const { inputNode: t, inputTexelSize: o, direction: n } = this;
+    y(t != null);
+    const { offsets: i, weights: r } = uo(this.kernelSize);
+    return U(() => {
+      const c = I(), a = n.mul(o).toVertexStage(), h = t.sample(c).mul(r[0]);
+      for (let l = 1; l < i.length; ++l) {
+        const u = a.mul(i[l]);
+        h.addAssign(
+          B(
+            t.sample(c.add(u)),
+            t.sample(c.sub(u))
+          ).mul(r[l])
         );
       }
-      return l;
+      return h;
     })();
   }
 }
-const Fo = (...n) => new vt(...n), Us = (n) => n.dot(f(0.06711056, 583715e-8)).fract().mul(52.9829189).fract(), jo = /* @__PURE__ */ k(() => {
-  const n = f(ut.xy).add(kt.fract().mul(1337)), e = Us(n);
-  return N(e, e.oneMinus(), e).sub(0.5).div(255);
-}).once()(), ko = (n, e, t = f(90, 45)) => {
-  const s = Ot(n), o = Ut(s), i = e.mul(o).mul(0.5), r = X(s.mul(t).fract().sub(0.5)).div(t), u = at(i, i.add(o), r).oneMinus();
-  return u.x.add(u.y).clamp(0, 1);
+const Dn = (...s) => new At(...s), lo = (s) => s.dot(f(0.06711056, 583715e-8)).fract().mul(52.9829189).fract(), Bn = /* @__PURE__ */ U(() => {
+  const s = f(ke.xy).add(Kt.fract().mul(1337)), e = lo(s);
+  return M(e, e.oneMinus(), e).sub(0.5).div(255);
+}).once()(), An = (s, e, t = f(90, 45)) => {
+  const o = Qt(s), n = Jt(o), i = e.mul(n).mul(0.5), r = _(o.mul(t).fract().sub(0.5)).div(t), c = dt(i, i.add(n), r).oneMinus();
+  return c.x.add(c.y).clamp(0, 1);
 };
-class Is extends _ {
+class ho extends Q {
   constructor() {
-    super("vec3"), this.currentProjectionMatrix = g(new ne()), this.previousProjectionMatrix = g("mat4"), this.currentModelViewMatrix = g(new ne()), this.previousModelViewMatrix = g("mat4"), this.objectModelViewMatrices = /* @__PURE__ */ new WeakMap(), this.updateType = Q.FRAME, this.updateBeforeType = Q.OBJECT, this.updateAfterType = Q.OBJECT;
+    super("vec3"), this.currentProjectionMatrix = g("mat4"), this.previousProjectionMatrix = g("mat4"), this.currentModelViewMatrix = g("mat4"), this.previousModelViewMatrix = g("mat4"), this.objectModelViewMatrices = /* @__PURE__ */ new WeakMap(), this.updateType = H.FRAME, this.updateBeforeType = H.OBJECT, this.updateAfterType = H.OBJECT;
   }
   static get type() {
     return "HighpVelocityNode";
@@ -433,23 +517,23 @@ class Is extends _ {
       return;
     const {
       currentProjectionMatrix: t,
-      previousProjectionMatrix: s
-    } = this, o = this.projectionMatrix ?? e.projectionMatrix;
-    s.value == null ? s.value = new ne().copy(o) : s.value.copy(t.value), t.value.copy(o);
+      previousProjectionMatrix: o
+    } = this, n = this.projectionMatrix ?? e.projectionMatrix;
+    o.value == null ? o.value = new Se().copy(n) : o.value.copy(t.value), t.value.copy(n);
   }
   // Executed once per object before rendering:
   updateBefore({ object: e, camera: t }) {
     if (e == null || t == null)
       return;
     const {
-      currentModelViewMatrix: s,
-      previousModelViewMatrix: o,
+      currentModelViewMatrix: o,
+      previousModelViewMatrix: n,
       objectModelViewMatrices: i
     } = this;
-    s.value.multiplyMatrices(
+    o.value.multiplyMatrices(
       t.matrixWorldInverse,
       e.matrixWorld
-    ), o.value = i.get(e) ?? s.value;
+    ), n.value = i.get(e) ?? o.value;
   }
   // Executed once per object after rendering:
   updateAfter({ object: e }) {
@@ -457,18 +541,18 @@ class Is extends _ {
       return;
     const {
       currentModelViewMatrix: t,
-      objectModelViewMatrices: s
+      objectModelViewMatrices: o
     } = this;
-    let o = s.get(e);
-    o == null && (o = new ne(), s.set(e, o)), o.copy(t.value);
+    let n = o.get(e);
+    n == null && (n = new Se(), o.set(e, n)), n.copy(t.value);
   }
   setup(e) {
-    const t = this.currentProjectionMatrix.mul(this.currentModelViewMatrix).mul(It).toVertexStage(), s = this.previousProjectionMatrix.mul(this.previousModelViewMatrix).mul(Et).toVertexStage(), o = t.xyz.div(t.w), i = s.xyz.div(s.w);
-    return ue(o, i);
+    const t = this.currentProjectionMatrix.mul(this.currentModelViewMatrix).mul(es).toVertexStage(), o = this.previousProjectionMatrix.mul(this.previousModelViewMatrix).mul(ts).toVertexStage(), n = t.xyz.div(t.w), i = o.xyz.div(o.w);
+    return ie(n, i);
   }
 }
-const Ye = /* @__PURE__ */ Lt(Is);
-class Es extends Ue {
+const tt = /* @__PURE__ */ pt(ho);
+class po extends qe {
   static get type() {
     return "KawaseBlurNode";
   }
@@ -476,39 +560,39 @@ class Es extends Ue {
     super(e, t), this.resolutionScale = 0.5;
   }
   setupDownsampleNode(e) {
-    const { inputNode: t, inputTexelSize: s } = this;
-    w(t != null);
-    const o = q(), i = b(1, 1, -1, -1).mul(s.xyxy.mul(0.5)).add(o.xyxy).toVertexStage(), r = i.zy, u = i.xy, a = i.xw, l = i.zw;
-    return D(
-      t.sample(o).mul(4),
+    const { inputNode: t, inputTexelSize: o } = this;
+    y(t != null);
+    const n = I(), i = z(1, 1, -1, -1).mul(o.xyxy.mul(0.5)).add(n.xyxy).toVertexStage(), r = i.zy, c = i.xy, a = i.xw, h = i.zw;
+    return B(
+      t.sample(n).mul(4),
       t.sample(r),
-      t.sample(u),
+      t.sample(c),
       t.sample(a),
-      t.sample(l)
+      t.sample(h)
     ).mul(1 / 8);
   }
   setupUpsampleNode(e) {
-    const { inputNode: t, inputTexelSize: s } = this;
-    w(t != null);
-    const o = q(), i = b(1, 1, -1, -1).mul(s.xyxy.mul(0.5)).add(o.xyxy).toVertexStage(), r = i.zy, u = i.xy, a = i.xw, l = i.zw, c = f(i.z, o.y), h = f(i.x, o.y), p = f(o.x, i.y), d = f(o.x, i.w);
-    return D(
-      D(
+    const { inputNode: t, inputTexelSize: o } = this;
+    y(t != null);
+    const n = I(), i = z(1, 1, -1, -1).mul(o.xyxy.mul(0.5)).add(n.xyxy).toVertexStage(), r = i.zy, c = i.xy, a = i.xw, h = i.zw, l = f(i.z, n.y), u = f(i.x, n.y), p = f(n.x, i.y), d = f(n.x, i.w);
+    return B(
+      B(
         t.sample(r),
-        t.sample(u),
+        t.sample(c),
         t.sample(a),
-        t.sample(l)
+        t.sample(h)
       ).mul(1 / 12),
-      D(
-        t.sample(c),
-        t.sample(h),
+      B(
+        t.sample(l),
+        t.sample(u),
         t.sample(p),
         t.sample(d)
       ).mul(1 / 6)
     );
   }
 }
-const Oo = (...n) => new Es(...n);
-class Ls extends _ {
+const Vn = (...s) => new po(...s);
+class mo extends Q {
   constructor(e) {
     super("vec3"), this.intensity = g(1e-5), this.inputNode = e;
   }
@@ -516,9 +600,9 @@ class Ls extends _ {
     return "LensGhostNode";
   }
   setup(e) {
-    const { inputNode: t, intensity: s } = this;
-    w(t != null);
-    const o = we({
+    const { inputNode: t, intensity: o } = this;
+    y(t != null);
+    const n = V({
       name: "sampleGhost",
       type: "vec3",
       inputs: [
@@ -527,33 +611,33 @@ class Ls extends _ {
         { name: "color", type: "vec3" },
         { name: "offset", type: "float" }
       ]
-    })(([a, l, c, h]) => {
-      const p = l.mul(h).add(a.oneMinus()).saturate(), d = t.sample(p).rgb.mul(c), m = ue(0.5, p).length().mul(1 / (Math.SQRT2 / 4)).saturate();
+    })(([a, h, l, u]) => {
+      const p = h.mul(u).add(a.oneMinus()).saturate(), d = t.sample(p).rgb.mul(l), m = ie(0.5, p).length().mul(1 / (Math.SQRT2 / 4)).saturate();
       return d.mulAssign(m.oneMinus().pow(3)), d;
-    }), i = q(), r = i.sub(0.5);
-    return D(
-      o(i, r, N(0.8, 0.8, 1), -5),
-      o(i, r, N(1, 0.8, 0.4), -1.5),
-      o(i, r, N(0.9, 1, 0.8), -0.4),
-      o(i, r, N(1, 0.8, 0.4), -0.2),
-      o(i, r, N(0.9, 0.7, 0.7), -0.1),
-      o(i, r, N(0.5, 1, 0.4), 0.7),
-      o(i, r, N(0.5, 0.5, 0.5), 1),
-      o(i, r, N(1, 1, 0.6), 2.5),
-      o(i, r, N(0.5, 0.8, 1), 10)
-    ).mul(s);
+    }), i = I(), r = i.sub(0.5);
+    return B(
+      n(i, r, M(0.8, 0.8, 1), -5),
+      n(i, r, M(1, 0.8, 0.4), -1.5),
+      n(i, r, M(0.9, 1, 0.8), -0.4),
+      n(i, r, M(1, 0.8, 0.4), -0.2),
+      n(i, r, M(0.9, 0.7, 0.7), -0.1),
+      n(i, r, M(0.5, 1, 0.4), 0.7),
+      n(i, r, M(0.5, 0.5, 0.5), 1),
+      n(i, r, M(1, 1, 0.6), 2.5),
+      n(i, r, M(0.5, 0.8, 1), 10)
+    ).mul(o);
   }
 }
-const { resetRendererState: Ws, restoreRendererState: Gs } = me;
-function qs() {
-  const s = document.createElement("canvas");
-  s.width = 256, s.height = 32;
-  const o = s.getContext("2d");
-  w(o != null), o.beginPath(), o.moveTo(0, 32 / 2), o.lineTo(256 / 2, 5), o.lineTo(256, 32 / 2), o.lineTo(256 / 2, 27), o.closePath();
-  const i = o.createLinearGradient(0, 0, 256, 0);
-  return i.addColorStop(0, "#000000"), i.addColorStop(0.5, "#ffffff"), i.addColorStop(1, "#000000"), o.fillStyle = i, o.fill(), new At(s);
+const { resetRendererState: fo, restoreRendererState: xo } = ge;
+function go() {
+  const o = document.createElement("canvas");
+  o.width = 256, o.height = 32;
+  const n = o.getContext("2d");
+  y(n != null), n.beginPath(), n.moveTo(0, 32 / 2), n.lineTo(256 / 2, 5), n.lineTo(256, 32 / 2), n.lineTo(256 / 2, 27), n.closePath();
+  const i = n.createLinearGradient(0, 0, 256, 0);
+  return i.addColorStop(0, "#000000"), i.addColorStop(0.5, "#ffffff"), i.addColorStop(1, "#000000"), n.fillStyle = i, n.fill(), new Is(o);
 }
-const Xe = /* @__PURE__ */ Pe({
+const st = /* @__PURE__ */ Ie({
   color: "vec3",
   luminance: "float",
   position: "vec2",
@@ -561,68 +645,70 @@ const Xe = /* @__PURE__ */ Pe({
   sin: "float",
   cos: "float"
 });
-class Hs extends Me {
+class vo extends Re {
   constructor(e) {
-    super(e), this.spikePairCount = 6, this.wireframe = !1, this.intensity = g(1e-5), this.sizeScale = g(new P(1.5, 0.01)), this.luminanceThreshold = g(100), this.counterBuffer = new ws(1, 1), this.instanceBuffer = Le(1, Xe), this.renderTarget = this.createRenderTarget(), this.material = new Ts({
+    super(e), this.spikePairCount = 6, this.wireframe = !1, this.intensity = g(1e-5), this.sizeScale = g(new ve(1.5, 0.01)), this.luminanceThreshold = g(100), this.indirectBuffer = new Ms(
+      new Uint32Array([6, 0, 0, 0, 0]),
+      1
+    ), this.instanceBuffer = _e(1, st), this.renderTarget = this.createRenderTarget(), this.material = new zs({
       depthTest: !1,
       depthWrite: !1,
       transparent: !0,
-      blending: Rt
-    }), this.mesh = new Te(new Dt(1, 1), this.material), this.camera = new Vt(), this.inputTexelSize = g(new P()), this.outputTexelSize = g(new P()), this.geometryRatio = g(new P()), this.inputNode = e, this.resolutionScale = 0.5, this.outputTexture = this.renderTarget.texture;
+      blending: Us
+    }), this.mesh = new bt(new js(1, 1), this.material), this.camera = new Es(), this.inputTexelSize = g("vec2"), this.outputTexelSize = g("vec2"), this.geometryRatio = g("vec2"), this.material.name = "LensGlare", this.inputNode = e, this.resolutionScale = 0.5, this.outputTexture = this.renderTarget.texture, this.mesh.geometry.indirect = this.indirectBuffer;
   }
   customCacheKey() {
-    return je(this.spikePairCount, +this.wireframe);
+    return We(this.spikePairCount, +this.wireframe);
   }
   setSize(e, t) {
-    const { resolutionScale: s } = this, o = Math.max(Math.round(e * s), 1), i = Math.max(Math.round(t * s), 1);
-    this.renderTarget.setSize(o, i);
-    const r = Math.floor(o / 2), u = Math.floor(i / 2), a = r * u;
-    return this.instanceBuffer.bufferCount < a && (this.instanceBuffer.dispose(), this.instanceBuffer = Le(a, Xe), this.setupCompute(r, u), this.setupMaterial()), this;
+    const { resolutionScale: o } = this, n = Math.max(Math.round(e * o), 1), i = Math.max(Math.round(t * o), 1);
+    this.renderTarget.setSize(n, i);
+    const r = Math.floor(n / 2), c = Math.floor(i / 2), a = r * c;
+    return this.instanceBuffer.bufferCount < a && (this.instanceBuffer.dispose(), this.instanceBuffer = _e(a, st), this.setupCompute(r, c), this.setupMaterial()), this;
   }
   updateBefore({ renderer: e }) {
     if (e == null)
       return;
     const { inputNode: t } = this;
-    w(t != null);
-    const { width: s, height: o } = t.value;
-    this.setSize(s, o);
-    const { computeNode: i, counterBuffer: r, renderTarget: u } = this;
-    w(i != null), this.inputTexelSize.value.set(1 / s, 1 / o);
-    const a = s / o;
+    y(t != null);
+    const { width: o, height: n } = t.value;
+    this.setSize(o, n);
+    const { computeNode: i, indirectBuffer: r, renderTarget: c } = this;
+    y(i != null), this.inputTexelSize.value.set(1 / o, 1 / n);
+    const a = o / n;
     a > 1 ? this.geometryRatio.value.set(1 / a, 1) : this.geometryRatio.value.set(1, a);
-    const { width: l, height: c } = u;
-    this.outputTexelSize.value.set(1 / l, 1 / c), r.array[0] = 0, r.needsUpdate = !0, e.compute(i), e.getArrayBufferAsync(r).then((h) => {
-      this.mesh.count = new Uint32Array(h)[0];
-    }).catch((h) => {
-      console.error(h);
-    }), this.rendererState = Ws(e, this.rendererState), e.setRenderTarget(u), e.render(this.mesh, this.camera), Gs(e, this.rendererState);
+    const { width: h, height: l } = c;
+    this.outputTexelSize.value.set(1 / h, 1 / l), r.array[1] = 0, r.needsUpdate = !0, e.compute(i), this.rendererState = fo(e, this.rendererState), e.setRenderTarget(c), e.render(this.mesh, this.camera), xo(e, this.rendererState);
   }
   setupCompute(e, t) {
     const {
-      spikePairCount: s,
-      inputNode: o,
-      counterBuffer: i,
+      spikePairCount: o,
+      inputNode: n,
+      indirectBuffer: i,
       instanceBuffer: r,
-      outputTexelSize: u
+      outputTexelSize: c
     } = this;
-    w(o != null);
-    const a = Wt(
+    y(n != null);
+    const a = ss(
       i,
       "uint",
       i.count
     ).toAtomic();
-    this.computeNode = k(() => {
-      const l = lt(e, t);
-      K(Ce.xy.greaterThanEqual(l).any(), () => {
-        Gt();
+    this.computeNode = U(() => {
+      const h = re(e, t);
+      ae(Ae.xy.greaterThanEqual(h).any(), () => {
+        os();
       });
-      const c = f(Ce.xy).mul(u).mul(2), h = o.sample(c), p = h.a;
-      K(p.greaterThan(0.1), () => {
-        const d = qt(a.element(0), s);
-        for (let m = 0; m < s; ++m) {
+      const l = f(Ae.xy).mul(c).mul(2), u = n.sample(l), p = u.a;
+      ae(p.greaterThan(0.1), () => {
+        const d = ns(
+          a.element(1),
+          o
+        );
+        for (let m = 0; m < o; ++m) {
           const x = r.element(d.add(m));
-          x.get("color").assign(h.rgb), x.get("luminance").assign(p), x.get("position").assign(Ce.xy), x.get("scale").assign(m % 2 === 0 ? 1 : 0.5);
-          const z = Math.PI * (3 - Math.sqrt(5)), T = Math.PI / s * m + z;
+          x.get("color").assign(u.rgb), x.get("luminance").assign(p), x.get("position").assign(Ae.xy), x.get("scale").assign(m % 2 === 0 ? 1 : 0.5);
+          const w = Math.PI * (3 - Math.sqrt(5)), T = Math.PI / o * m + w;
           x.get("sin").assign(Math.sin(T)), x.get("cos").assign(Math.cos(T));
         }
       });
@@ -636,29 +722,29 @@ class Hs extends Me {
     const {
       inputNode: e,
       spikeNode: t,
-      instanceBuffer: s,
-      luminanceThreshold: o,
+      instanceBuffer: o,
+      luminanceThreshold: n,
       intensity: i,
       sizeScale: r,
-      outputTexelSize: u,
+      outputTexelSize: c,
       geometryRatio: a
     } = this;
-    w(e != null), w(t != null);
-    const l = s.element(Ht);
-    this.material.colorNode = this.wireframe ? b(1) : t.mul(l.get("color").mul(i)), this.material.vertexNode = k(() => {
-      const c = l.get("sin"), h = l.get("cos"), p = ct(h, c, 0, c.negate(), h, 0, 0, 0, 1), m = l.get("position").mul(u).mul(2), x = m.flipY().mul(2).sub(1), T = l.get("luminance").div(o).saturate(), B = f(T, 1).mul(
-        l.get("scale"),
+    y(e != null), y(t != null);
+    const h = o.element(is);
+    this.material.colorNode = this.wireframe ? z(1) : t.mul(h.get("color").mul(i)), this.material.vertexNode = U(() => {
+      const l = h.get("sin"), u = h.get("cos"), p = mt(u, l, 0, l.negate(), u, 0, 0, 0, 1), m = h.get("position").mul(c).mul(2), x = m.flipY().mul(2).sub(1), T = h.get("luminance").div(n).saturate(), C = f(T, 1).mul(
+        h.get("scale"),
         r,
         // Make the spike to shrink at screen borders:
         m.sub(0.5).length().mul(2).oneMinus().mul(0.5).add(0.5)
-      ), O = p.mul(rt.mul(b(B, 1, 1))).mul(a).add(N(x, 0));
-      return b(O, 1);
+      ), j = p.mul(ht.mul(z(C, 1, 1))).mul(a).add(M(x, 0));
+      return z(j, 1);
     })(), this.material.wireframe = this.wireframe, this.material.needsUpdate = !0;
   }
   setup(e) {
     if (this.spikeNode == null) {
-      const t = qs();
-      t.colorSpace = Bt, this.spikeNode = ie(t);
+      const t = go();
+      t.colorSpace = ks, this.spikeNode = oe(t);
     }
     return this.setupMaterial(), super.setup(e);
   }
@@ -666,10 +752,10 @@ class Hs extends Me {
     this.renderTarget.dispose(), this.material.dispose(), this.mesh.geometry.dispose(), super.dispose();
   }
 }
-const $s = /* @__PURE__ */ new P();
-class Ys extends _ {
+const yo = /* @__PURE__ */ new ve();
+class wo extends Q {
   constructor(e) {
-    super("vec3"), this.intensity = g(1e-5), this.chromaticAberration = g(5e-3), this.aspectRatio = g(0), this.inputNode = e, this.updateBeforeType = Q.FRAME;
+    super("vec3"), this.intensity = g(1e-5), this.chromaticAberration = g(5e-3), this.aspectRatio = g(0), this.updateBeforeType = H.FRAME, this.inputNode = e;
   }
   static get type() {
     return "LensHaloNode";
@@ -677,13 +763,13 @@ class Ys extends _ {
   updateBefore({ renderer: e }) {
     if (e == null)
       return;
-    const { width: t, height: s } = e.getDrawingBufferSize($s);
-    this.aspectRatio.value = t / s;
+    const { width: t, height: o } = e.getDrawingBufferSize(yo);
+    this.aspectRatio.value = t / o;
   }
   setup(e) {
-    const { inputNode: t, intensity: s, chromaticAberration: o, aspectRatio: i } = this;
-    w(t != null);
-    const r = we({
+    const { inputNode: t, intensity: o, chromaticAberration: n, aspectRatio: i } = this;
+    y(t != null);
+    const r = V({
       name: "cubicRingMask",
       type: "float",
       inputs: [
@@ -691,29 +777,29 @@ class Ys extends _ {
         { name: "radius", type: "float" },
         { name: "thickness", type: "float" }
       ]
-    })(([c, h, p]) => {
-      const d = ht(X(c.sub(h)).div(p), 1);
-      return $t(d, d, ue(3, d.mul(2))).oneMinus();
-    }), u = we({
+    })(([l, u, p]) => {
+      const d = ft(_(l.sub(u)).div(p), 1);
+      return rs(d, d, ie(3, d.mul(2))).oneMinus();
+    }), c = V({
       name: "sampleHalo",
       type: "vec3",
       inputs: [
         { name: "uv", type: "vec2" },
         { name: "radius", type: "float" }
       ]
-    })(([c, h]) => {
-      const p = f(i, 1), d = c.sub(0.5).mul(p).normalize().div(p), m = N(o).mul(N(-1, 0, 1)), x = Yt(d.mul(h).add(c.oneMinus())), z = N(
+    })(([l, u]) => {
+      const p = f(i, 1), d = l.sub(0.5).mul(p).normalize().div(p), m = M(n).mul(M(-1, 0, 1)), x = as(d.mul(u).add(l.oneMinus())), w = M(
         t.sample(d.mul(m.r).add(x)).r,
         t.sample(d.mul(m.g).add(x)).g,
         t.sample(d.mul(m.b).add(x)).b
-      ), T = c.sub(f(0.5, 0)).mul(p).add(f(0.5, 0)), B = Xt(T, f(0.5)).saturate();
-      return z.mulAssign(r(B, 0.45, 0.25)), z;
-    }), a = q();
-    return u(a, 0.3).mul(s);
+      ), T = l.sub(f(0.5, 0)).mul(p).add(f(0.5, 0)), C = cs(T, f(0.5)).saturate();
+      return w.mulAssign(r(C, 0.45, 0.25)), w;
+    }), a = I();
+    return c(a, 0.3).mul(o);
   }
 }
-const F = (n) => n.greaterThanEqual(0).all().and(n.lessThanEqual(1).all()).toFloat();
-class wt extends Ue {
+const E = (s) => s.greaterThanEqual(0).all().and(s.lessThanEqual(1).all()).toFloat();
+class Vt extends qe {
   constructor(e, t = 4) {
     super(e, t), this.blendAmount = g(0.85), this.resolutionScale = 0.5;
   }
@@ -721,71 +807,71 @@ class wt extends Ue {
     return "MipmapSurfaceBlurNode";
   }
   setupDownsampleNode(e) {
-    const { inputNode: t, inputTexelSize: s } = this;
-    return w(t != null), k(() => {
-      const o = q(), i = b(1, 1, -1, -1).mul(s.xyxy).add(o.xyxy).toVertexStage(), r = b(2, 2, -2, -2).mul(s.xyxy).add(o.xyxy).toVertexStage(), u = i.zy, a = i.xy, l = i.zw, c = i.xw, h = r.zy, p = r.xy, d = r.zw, m = r.xw, x = f(o.x, r.y), z = f(r.z, o.y), T = f(r.x, o.y), B = f(o.x, r.w), O = 1 / 4 / 2, C = 1 / 9 / 2, V = t.sample(o).mul(C);
-      let S;
-      return S = b(
-        F(u),
-        F(a),
-        F(l),
-        F(c)
-      ).mul(O), V.addAssign(
-        t.sample(u).mul(S.x),
-        t.sample(a).mul(S.y),
-        t.sample(l).mul(S.z),
-        t.sample(c).mul(S.w)
-      ), S = b(
-        F(h),
-        F(p),
-        F(d),
-        F(m)
-      ).mul(C), V.addAssign(
-        t.sample(h).mul(S.x),
-        t.sample(p).mul(S.y),
-        t.sample(d).mul(S.z),
-        t.sample(m).mul(S.w)
-      ), S = b(
-        F(x),
-        F(z),
-        F(T),
-        F(B)
-      ).mul(C), V.addAssign(
-        t.sample(x).mul(S.x),
-        t.sample(z).mul(S.y),
-        t.sample(T).mul(S.z),
-        t.sample(B).mul(S.w)
-      ), V;
+    const { inputNode: t, inputTexelSize: o } = this;
+    return y(t != null), U(() => {
+      const n = I(), i = z(1, 1, -1, -1).mul(o.xyxy).add(n.xyxy).toVertexStage(), r = z(2, 2, -2, -2).mul(o.xyxy).add(n.xyxy).toVertexStage(), c = i.zy, a = i.xy, h = i.zw, l = i.xw, u = r.zy, p = r.xy, d = r.zw, m = r.xw, x = f(n.x, r.y), w = f(r.z, n.y), T = f(r.x, n.y), C = f(n.x, r.w), j = 1 / 4 / 2, R = 1 / 9 / 2, F = t.sample(n).mul(R);
+      let b;
+      return b = z(
+        E(c),
+        E(a),
+        E(h),
+        E(l)
+      ).mul(j), F.addAssign(
+        t.sample(c).mul(b.x),
+        t.sample(a).mul(b.y),
+        t.sample(h).mul(b.z),
+        t.sample(l).mul(b.w)
+      ), b = z(
+        E(u),
+        E(p),
+        E(d),
+        E(m)
+      ).mul(R), F.addAssign(
+        t.sample(u).mul(b.x),
+        t.sample(p).mul(b.y),
+        t.sample(d).mul(b.z),
+        t.sample(m).mul(b.w)
+      ), b = z(
+        E(x),
+        E(w),
+        E(T),
+        E(C)
+      ).mul(R), F.addAssign(
+        t.sample(x).mul(b.x),
+        t.sample(w).mul(b.y),
+        t.sample(T).mul(b.z),
+        t.sample(C).mul(b.w)
+      ), F;
     })();
   }
   setupUpsampleNode(e) {
-    const { inputNode: t, inputTexelSize: s, downsampleNode: o } = this;
-    w(t != null);
-    const i = q(), r = b(1, 1, -1, -1).mul(s.xyxy).add(i.xyxy).toVertexStage(), u = f(i.x, r.y), a = f(r.z, i.y), l = f(r.x, i.y), c = f(i.x, r.w), h = r.zy, p = r.xy, d = r.zw, m = r.xw, x = D(
+    const { inputNode: t, inputTexelSize: o, downsampleNode: n } = this;
+    y(t != null);
+    const i = I(), r = z(1, 1, -1, -1).mul(o.xyxy).add(i.xyxy).toVertexStage(), c = f(i.x, r.y), a = f(r.z, i.y), h = f(r.x, i.y), l = f(i.x, r.w), u = r.zy, p = r.xy, d = r.zw, m = r.xw, x = B(
       t.sample(i).mul(1 / 4),
-      D(
-        t.sample(u),
+      B(
+        t.sample(c),
         t.sample(a),
-        t.sample(l),
-        t.sample(c)
-      ).mul(1 / 8),
-      D(
         t.sample(h),
+        t.sample(l)
+      ).mul(1 / 8),
+      B(
+        t.sample(u),
         t.sample(p),
         t.sample(d),
         t.sample(m)
       ).mul(1 / 16)
     );
-    return re(o.sample(i), x, this.blendAmount);
+    return ne(n.sample(i), x, this.blendAmount);
   }
 }
-const Uo = (...n) => new wt(...n);
-function Tt(n) {
-  return (n instanceof Ss ? n.renderer.backend : "backend" in n ? n.backend : n).isWebGPUBackend === !0;
+const Pn = (...s) => new Vt(...s);
+function Pt(s) {
+  return (s instanceof Cs ? s.renderer.backend : "backend" in s ? s.backend : s).isWebGPUBackend === !0;
 }
-class Xs extends _ {
+class To extends Q {
   constructor(e) {
-    super("vec4"), this.bloomIntensity = g(0.05), this.inputNode = e, this.thresholdNode = new yt(), this.blurNode = new vt(), this.ghostNode = new Ls(), this.haloNode = new Ys(), this.bloomNode = new wt(null, 8), this.glareNode = new Hs(), this.featuresNode = Zt(D(this.ghostNode, this.haloNode)), this.featuresNode.value.name = "LensFlareNode.Features", this.featuresNode.pixelRatio = 0.5, this.blurNode.resolutionScale = 1, this.bloomNode.resolutionScale = 1, this.glareNode.resolutionScale = 1;
+    super("vec4"), this.bloomIntensity = g(0.05), this.inputNode = e, this.thresholdNode = new Bt(), this.blurNode = new At(), this.ghostNode = new mo(), this.haloNode = new wo(), this.bloomNode = new Vt(null, 8), this.glareNode = new vo(), this.featuresNode = us(B(this.ghostNode, this.haloNode)), this.featuresNode.value.name = "LensFlare_features", this.featuresNode.pixelRatio = 0.5, this.blurNode.resolutionScale = 1, this.bloomNode.resolutionScale = 1, this.glareNode.resolutionScale = 1;
   }
   static get type() {
     return "LensFlareNode";
@@ -793,80 +879,139 @@ class Xs extends _ {
   setup(e) {
     const {
       inputNode: t,
-      thresholdNode: s,
-      blurNode: o,
+      thresholdNode: o,
+      blurNode: n,
       ghostNode: i,
       haloNode: r,
-      bloomNode: u,
+      bloomNode: c,
       featuresNode: a,
-      glareNode: l
+      glareNode: h
     } = this;
-    w(t != null);
-    const c = s.getTextureNode(), h = o.getTextureNode();
-    s.inputNode = t, o.inputNode = c, i.inputNode = h, r.inputNode = h, u.inputNode = c, l.inputNode = c;
-    const p = u.getTextureNode().mul(this.bloomIntensity), d = l.getTextureNode();
-    return k(() => {
+    y(t != null);
+    const l = o.getTextureNode(), u = n.getTextureNode();
+    o.inputNode = t, n.inputNode = l, i.inputNode = u, r.inputNode = u, c.inputNode = l, h.inputNode = l;
+    const p = c.getTextureNode().mul(this.bloomIntensity), d = h.getTextureNode();
+    return U(() => {
       const m = t;
-      return m.addAssign(p), Tt(e) && m.addAssign(d), m.add(a);
+      return m.addAssign(p), Pt(e) && m.addAssign(d), m.add(a);
     })();
   }
   dispose() {
     this.thresholdNode.dispose(), this.blurNode.dispose(), this.ghostNode.dispose(), this.haloNode.dispose(), this.bloomNode.dispose(), this.glareNode.dispose(), this.featuresNode.dispose(), super.dispose();
   }
 }
-const Io = (n) => new Xs(n != null ? De(n) : null), Eo = /* @__PURE__ */ ee(
-  (n, e, t, s) => {
-    const o = n.sub(t), i = ye(e, o), r = ye(o, o).sub(s.pow2()), u = i.pow2().sub(r).toVar(), a = f(-1);
-    return K(u.greaterThanEqual(0), () => {
-      const l = Se(u);
-      a.assign(f(i.negate().sub(l), i.negate().add(l)));
+const Fn = (s) => new To(s != null ? Oe(s) : null), No = /* @__PURE__ */ V({
+  name: "bvec2Not",
+  type: "bvec2",
+  inputs: [{ name: "x", type: "bvec2" }]
+})(([s]) => s.notEqual(Me(!0))), So = /* @__PURE__ */ V({
+  name: "bvec3Not",
+  type: "bvec3",
+  inputs: [{ name: "x", type: "bvec3" }]
+})(([s]) => s.notEqual(Me(!0))), bo = /* @__PURE__ */ V({
+  name: "bvec4Not",
+  type: "bvec4",
+  inputs: [{ name: "x", type: "bvec4" }]
+})(([s]) => s.notEqual(Me(!0))), On = /* @__PURE__ */ Le([
+  No,
+  So,
+  bo
+]), Mo = /* @__PURE__ */ V({
+  name: "bvec2And",
+  type: "bvec2",
+  inputs: [
+    { name: "x", type: "bvec2" },
+    { name: "y", type: "bvec2" }
+  ]
+})(([s, e]) => xt(re(s).mul(re(e)))), zo = /* @__PURE__ */ V({
+  name: "bvec3And",
+  type: "bvec3",
+  inputs: [
+    { name: "x", type: "bvec3" },
+    { name: "y", type: "bvec3" }
+  ]
+})(([s, e]) => gt(pe(s).mul(pe(e)))), Co = /* @__PURE__ */ V({
+  name: "bvec4And",
+  type: "bvec4",
+  inputs: [
+    { name: "x", type: "bvec4" },
+    { name: "y", type: "bvec4" }
+  ]
+})(([s, e]) => vt(me(s).mul(me(e)))), Un = /* @__PURE__ */ Le([
+  Mo,
+  zo,
+  Co
+]), Ro = /* @__PURE__ */ V({
+  name: "bvec2Or",
+  type: "bvec2",
+  inputs: [
+    { name: "x", type: "bvec2" },
+    { name: "y", type: "bvec2" }
+  ]
+})(([s, e]) => re(s).add(re(e)).notEqual(0)), Do = /* @__PURE__ */ V({
+  name: "bvec3Or",
+  type: "bvec3",
+  inputs: [
+    { name: "x", type: "bvec3" },
+    { name: "y", type: "bvec3" }
+  ]
+})(([s, e]) => pe(s).add(pe(e)).notEqual(0)), Bo = /* @__PURE__ */ V({
+  name: "bvec4Or",
+  type: "bvec4",
+  inputs: [
+    { name: "x", type: "bvec4" },
+    { name: "y", type: "bvec4" }
+  ]
+})(([s, e]) => me(s).add(me(e)).notEqual(0)), jn = /* @__PURE__ */ Le([Ro, Do, Bo]), En = /* @__PURE__ */ L(
+  (s, e, t, o) => {
+    const n = s.sub(t), i = Ne(e, n), r = Ne(n, n).sub(o.pow2()), c = i.pow2().sub(r).toConst(), a = f(-1);
+    return ae(c.greaterThanEqual(0), () => {
+      const h = be(c);
+      a.assign(f(i.negate().sub(h), i.negate().add(h)));
     }), a;
   }
-), Zs = /* @__PURE__ */ Pe(
-  { near: "vec4", far: "vec4" },
-  "raySpheresIntersections"
-), Lo = /* @__PURE__ */ ee(
-  (n, e, t, s) => {
-    const o = n.sub(t), i = ye(e, o), r = ye(o, o).sub(s.pow2()), u = i.pow2().sub(r).toVar(), a = b(-1), l = b(-1);
-    return K(u.greaterThanEqual(0), () => {
-      const c = Se(u);
-      a.assign(i.negate().sub(c)), l.assign(i.negate().add(c));
-    }), Zs(a, l);
-  }
-), Wo = /* @__PURE__ */ ee(
-  (n, e, t) => {
-    const s = n.div(t), o = e.div(t), i = o.dot(o), r = s.dot(o), u = s.dot(s), a = r.pow2().sub(i.mul(u.sub(1))).toVar(), l = f(-1);
-    return K(a.greaterThanEqual(0), () => {
-      const c = Se(a);
-      l.assign(f(r.negate().sub(c), r.negate().add(c)).div(i));
-    }), l;
-  }
-), Qs = {
-  float: pe,
-  int: Z,
-  uint: as,
-  bool: rs,
+), Ao = /* @__PURE__ */ Ie({
+  near: "vec4",
+  far: "vec4"
+}), kn = /* @__PURE__ */ L(
+  (s, e, t, o) => {
+    const n = s.sub(t), i = Ne(e, n), r = Ne(n, n).sub(o.pow2()), c = i.pow2().sub(r).toConst(), a = f(c.greaterThanEqual(0)).toConst(), h = a.oneMinus().toConst(), l = be(c.max(0)).toConst(), u = a.mul(i.negate().sub(l)).sub(h), p = a.mul(i.negate().add(l)).sub(h);
+    return Ao(u, p);
+  }
+), In = /* @__PURE__ */ L(
+  (s, e, t) => {
+    const o = s.div(t), n = e.div(t), i = n.dot(n), r = o.dot(n), c = o.dot(o), a = r.pow2().sub(i.mul(c.sub(1))).toConst(), h = f(-1);
+    return ae(a.greaterThanEqual(0), () => {
+      const l = be(a);
+      h.assign(f(r.negate().sub(l), r.negate().add(l)).div(i));
+    }), h;
+  }
+), Vo = {
+  float: G,
+  int: K,
+  uint: ms,
+  bool: Me,
   vec2: f,
-  ivec2: j,
-  uvec2: lt,
-  bvec2: is,
-  vec3: N,
-  ivec3: ns,
-  uvec3: os,
-  bvec3: ss,
-  vec4: b,
-  ivec4: ts,
-  uvec4: es,
-  bvec4: Jt,
-  mat2: _t,
-  mat3: ct,
-  mat4: Kt,
-  color: Qt
-}, Go = Ns;
-function qo(n) {
-  return Qs[n];
+  ivec2: O,
+  uvec2: re,
+  bvec2: xt,
+  vec3: M,
+  ivec3: ps,
+  uvec3: pe,
+  bvec3: gt,
+  vec4: z,
+  ivec4: yt,
+  uvec4: me,
+  bvec4: vt,
+  mat2: ds,
+  mat3: mt,
+  mat4: hs,
+  color: ls
+}, Ln = Rs;
+function Wn(s) {
+  return Vo[s];
 }
-class Ks extends Ms {
+class Po extends Nt {
   static get type() {
     return "OutputTexture3DNode";
   }
@@ -880,48 +1025,47 @@ class Ks extends Ms {
     return new this.constructor(this.owner, this.value);
   }
 }
-const Ho = (...n) => new Ks(...n), $o = /* @__PURE__ */ ee(
-  (n, e) => {
-    const t = f(ve(n)), s = t.reciprocal(), o = e.mul(t), i = o.sub(0.5).floor().add(0.5), r = o.sub(i), u = r.mul(r.mul(r.mul(0.5).oneMinus()).sub(0.5)), a = r.mul(r).mul(r.mul(1.5).sub(2.5)).add(1), l = r.mul(r.mul(ue(2, r.mul(1.5))).add(0.5)), c = r.mul(r).mul(r.mul(0.5).sub(0.5)), h = a.add(l), p = l.div(a.add(l)), d = i.sub(1).mul(s), m = i.add(2).mul(s), x = i.add(p).mul(s);
-    return D(
-      n.sample(f(d.x, d.y)).mul(u.x).mul(u.y),
-      n.sample(f(x.x, d.y)).mul(h.x).mul(u.y),
-      n.sample(f(m.x, d.y)).mul(c.x).mul(u.y),
-      n.sample(f(d.x, x.y)).mul(u.x).mul(h.y),
-      n.sample(f(x.x, x.y)).mul(h.x).mul(h.y),
-      n.sample(f(m.x, x.y)).mul(c.x).mul(h.y),
-      n.sample(f(d.x, m.y)).mul(u.x).mul(c.y),
-      n.sample(f(x.x, m.y)).mul(h.x).mul(c.y),
-      n.sample(f(m.x, m.y)).mul(c.x).mul(c.y)
+const $n = (...s) => new Po(...s), Fo = ["x", "y", "z", "w"], qn = /* @__PURE__ */ L(
+  (s, e, t = 0) => {
+    let o;
+    if (typeof t == "number")
+      o = t;
+    else if (t?.isConstNode === !0)
+      o = t.value;
+    else
+      throw new Error("Component must be a constant.");
+    const n = s.size(), i = O(e.mul(n).sub(0.5).floor()).toConst(), r = yt(i, i.add(1)).toConst(), c = Fo[o];
+    return z(
+      s.load(r.xw)[c],
+      // min, max
+      s.load(r.zw)[c],
+      // max, max
+      s.load(r.zy)[c],
+      // max, min
+      s.load(r.xy)[c]
+      // min, min
+    );
+  }
+), Gn = /* @__PURE__ */ L(
+  (s, e = I()) => {
+    const t = f(s.size()), o = t.reciprocal(), n = e.mul(t), i = n.sub(0.5).floor().add(0.5), r = n.sub(i), c = r.mul(r.mul(r.mul(0.5).oneMinus()).sub(0.5)), a = r.mul(r).mul(r.mul(1.5).sub(2.5)).add(1), h = r.mul(r.mul(ie(2, r.mul(1.5))).add(0.5)), l = r.mul(r).mul(r.mul(0.5).sub(0.5)), u = a.add(h), p = h.div(a.add(h)), d = i.sub(1).mul(o), m = i.add(2).mul(o), x = i.add(p).mul(o);
+    return B(
+      s.sample(f(d.x, d.y)).mul(c.x).mul(c.y),
+      s.sample(f(x.x, d.y)).mul(u.x).mul(c.y),
+      s.sample(f(m.x, d.y)).mul(l.x).mul(c.y),
+      s.sample(f(d.x, x.y)).mul(c.x).mul(u.y),
+      s.sample(f(x.x, x.y)).mul(u.x).mul(u.y),
+      s.sample(f(m.x, x.y)).mul(l.x).mul(u.y),
+      s.sample(f(d.x, m.y)).mul(c.x).mul(l.y),
+      s.sample(f(x.x, m.y)).mul(u.x).mul(l.y),
+      s.sample(f(m.x, m.y)).mul(l.x).mul(l.y)
     );
   }
-), _s = (n, e, t, { perspective: s = !0, logarithmic: o = !1 } = {}) => o ? pt(n, e, t) : s ? mt(n, e, t) : us(n, e, t), Ae = (n, e, t) => {
-  const s = pt(n, e, t);
-  return hs(s, e, t);
-}, Yo = (n, e, t) => {
-  const s = mt(n, e, t);
-  return dt(s, e, t);
-}, Xo = (n, e, t, s, o) => {
-  const i = s.element(Z(2)).element(Z(3)), r = s.element(Z(3)).element(Z(3)), a = b(N(n.flipY(), e).mul(2).sub(1), 1).mul(t.mul(i).add(r));
-  return o.mul(a).xyz;
-}, Ze = [
-  /* @__PURE__ */ N(58.1375, 2.7747, 26.8183),
-  /* @__PURE__ */ N(-150.5666, 4.2109, -88.5066),
-  /* @__PURE__ */ N(130.5887, -14.0195, 109.0745),
-  /* @__PURE__ */ N(-42.3277, 4.8052, -60.1097),
-  /* @__PURE__ */ N(4.5974, 2.1856, 12.5925),
-  /* @__PURE__ */ N(0.1357, 0.0914, 0.1067)
-], Js = (n) => Ze.slice(1).reduce((e, t) => t.add(n.mul(e)), Ze[0]), Zo = (n, e, t, s) => {
-  const o = _s(n, e, t, s);
-  return Js(dt(o, e, t));
-}, Qo = (n) => {
-  const e = ue(0.5, n.x).mul(ls), t = ue(n.y, 0.5).mul(cs), s = We(t);
-  return N(s.mul(We(e)), Ge(t), s.mul(Ge(e)));
-}, R = 64;
-function ge(n) {
-  return Math.floor(Math.max(0, n) / R);
+), D = 64;
+function Te(s) {
+  return Math.floor(Math.max(0, s) / D);
 }
-class eo {
+class Oo {
   constructor() {
     this.size = [0, 0, 0], this.offset = { x: 0, y: 0 };
   }
@@ -929,22 +1073,22 @@ class eo {
     return [this.size[0], this.size[1], this.size[2]] = e.size, this.offset.x = e.offset.x, this.offset.y = e.offset.y, this;
   }
 }
-const to = /* @__PURE__ */ new tt(), so = /* @__PURE__ */ new it(), oo = /* @__PURE__ */ new P(), no = /* @__PURE__ */ new ne();
-class io extends _ {
-  constructor(e, t, s) {
-    super("float"), this.sampleCount = 60, this.hardShadowSamples = 4, this.fadeOutSamples = 8, this.thickness = g(5e-3), this.shadowContrast = g(4), this.shadowIntensity = g(1), this.bilinearThreshold = g(0.02), this.nearDepth = g(0), this.farDepth = g(1), this.lightCoordinate = g(new it()), this.dispatchOffset = g(new P(), "ivec2"), this.dispatchIndex = g(0), this.dispatches = Array.from(
+const Uo = /* @__PURE__ */ new St(), jo = /* @__PURE__ */ new Ws(), Eo = /* @__PURE__ */ new ve(), ko = /* @__PURE__ */ new Se();
+class Io extends Q {
+  constructor(e, t, o) {
+    super("float"), this.sampleCount = 60, this.hardShadowSamples = 4, this.fadeOutSamples = 8, this.thickness = g(5e-3), this.shadowContrast = g(4), this.shadowIntensity = g(1), this.bilinearThreshold = g(0.02), this.lightCoordinate = g("vec4"), this.dispatchOffset = g("ivec2"), this.dispatchIndex = g(0), this.dispatches = Array.from(
       // Populate the max number of dispatches
       { length: 8 },
-      () => new eo()
-    ), this.dispatchCount = 0, this.depthNode = e, this.camera = t, this.mainLight = s;
-    const o = new bs(1, 1);
-    o.colorSpace = Pt, o.minFilter = ae, o.magFilter = ae, o.generateMipmaps = !1, o.name = "ScreenSpaceShadowNode", this.outputTexture = o, this.textureNode = Oe(this, o), this.updateBeforeType = Q.FRAME;
+      () => new Oo()
+    ), this.dispatchCount = 0, this.updateBeforeType = H.FRAME, this.depthNode = e, this.camera = t, this.mainLight = o;
+    const n = new Ds(1, 1);
+    n.colorSpace = Ls, n.minFilter = ue, n.magFilter = ue, n.generateMipmaps = !1, n.name = "ScreenSpaceShadow", this.outputTexture = n, this.textureNode = $e(this, n), this.computeNode = this.createComputeNode();
   }
   get type() {
     return "ScreenSpaceShadowNode";
   }
   customCacheKey() {
-    return je(
+    return We(
       this.camera?.id ?? -1,
       this.mainLight?.id ?? -1,
       this.sampleCount,
@@ -956,173 +1100,201 @@ class io extends _ {
     return this.textureNode;
   }
   setSize(e, t) {
-    const { outputTexture: s } = this;
-    return (e !== s.width || t !== s.height) && (s.setSize(e, t, 0), s.needsUpdate = !0), this;
+    const { outputTexture: o } = this;
+    return (e !== o.width || t !== o.height) && (o.setSize(e, t, 0), o.needsUpdate = !0), this;
   }
   updateBefore(e) {
     const { renderer: t } = e;
     if (t == null)
       return;
-    const s = t.getDrawingBufferSize(oo);
-    this.setSize(s.width, s.height);
-    const { camera: o, mainLight: i } = this, r = no.multiplyMatrices(
-      o.projectionMatrix,
-      o.matrixWorldInverse
-    ), u = to.copy(i.position).sub(i.target.position).normalize(), a = so.set(u.x, u.y, u.z, 0).applyMatrix4(r);
-    this.updateDispatchList(a, s), w(this.computeNode != null);
-    for (let l = 0; l < this.dispatchCount; ++l) {
-      const c = this.dispatches[l];
-      this.dispatchOffset.value.set(c.offset.x, c.offset.y), this.dispatchIndex.value = l, t.compute(this.computeNode, c.size);
+    const o = t.getDrawingBufferSize(Eo);
+    this.setSize(o.width, o.height);
+    const { camera: n, mainLight: i } = this, r = ko.multiplyMatrices(
+      n.projectionMatrix,
+      n.matrixWorldInverse
+    ), c = Uo.copy(i.position).sub(i.target.position).normalize(), a = jo.set(c.x, c.y, c.z, 0).applyMatrix4(r);
+    this.updateDispatchList(a, o);
+    for (let h = 0; h < this.dispatchCount; ++h) {
+      const l = this.dispatches[h];
+      this.dispatchOffset.value.set(l.offset.x, l.offset.y), this.dispatchIndex.value = h, t.compute(this.computeNode, l.size);
     }
   }
   // See bend_sss_cpu.h
-  updateDispatchList(e, { width: t, height: s }) {
-    let o = e.w;
-    const i = 2e-6 * R;
-    o >= 0 && o < i ? o = i : o < 0 && o > -i && (o = -i), this.lightCoordinate.value.set(
-      (e.x / o * 0.5 + 0.5) * t,
-      (e.y / o * -0.5 + 0.5) * s,
+  updateDispatchList(e, { width: t, height: o }) {
+    let n = e.w;
+    const i = 2e-6 * D;
+    n >= 0 && n < i ? n = i : n < 0 && n > -i && (n = -i), this.lightCoordinate.value.set(
+      (e.x / n * 0.5 + 0.5) * t,
+      (e.y / n * -0.5 + 0.5) * o,
       e.w === 0 ? 0 : e.z / e.w,
       e.w > 0 ? 1 : -1
     );
-    const r = Math.round(this.lightCoordinate.value.x), u = Math.round(this.lightCoordinate.value.y), a = -r, l = -(s - u), c = t - r, h = u;
+    const r = Math.round(this.lightCoordinate.value.x), c = Math.round(this.lightCoordinate.value.y), a = -r, h = -(o - c), l = t - r, u = c;
     let p = 0;
     for (let d = 0; d < 4; ++d) {
-      const m = d === 0 || d === 3, x = (d & 1) > 0, z = (d & 2) > 0, T = ge(x ? a : -c), B = ge(z ? l : -h), O = R * (m ? 1 : 2) - 1, C = R * (m ? 2 : 1) - 1, V = ge((x ? c : -a) + O), S = ge((z ? h : -l) + C);
-      if (V - T > 0 && S - B > 0) {
-        const H = d === 2 || d === 3 ? 1 : 0, U = d === 1 || d === 3 ? 1 : 0, v = this.dispatches[p++];
-        v.size[0] = R, v.size[1] = V - T, v.size[2] = S - B, v.offset.x = (x ? T : -V) + H, v.offset.y = (z ? -S : B) + U;
+      const m = d === 0 || d === 3, x = (d & 1) > 0, w = (d & 2) > 0, T = Te(x ? a : -l), C = Te(w ? h : -u), j = D * (m ? 1 : 2) - 1, R = D * (m ? 2 : 1) - 1, F = Te((x ? l : -a) + j), b = Te((w ? u : -h) + R);
+      if (F - T > 0 && b - C > 0) {
+        const k = d === 2 || d === 3 ? 1 : 0, W = d === 1 || d === 3 ? 1 : 0, v = this.dispatches[p++];
+        v.size[0] = D, v.size[1] = F - T, v.size[2] = b - C, v.offset.x = (x ? T : -F) + k, v.offset.y = (w ? -b : C) + W;
         let A;
-        if (d === 0 ? A = a - l : d === 1 ? A = c + l : d === 2 ? A = -a - h : A = -c + h, A = (A + R - 1) / R | 0, A > 0) {
-          const y = this.dispatches[p++].copy(v);
-          d === 0 ? (y.size[2] = Math.min(v.size[2], A), v.size[2] -= y.size[2], y.offset.y = v.offset.y + v.size[2], y.offset.x -= 1, y.size[1] += 1) : d === 1 ? (y.size[1] = Math.min(v.size[1], A), v.size[1] -= y.size[1], y.offset.x = v.offset.x + v.size[1], y.size[2] += 1) : d === 2 ? (y.size[1] = Math.min(v.size[1], A), v.size[1] -= y.size[1], v.offset.x += y.size[1], y.size[2] += 1, y.offset.y -= 1) : d === 3 && (y.size[2] = Math.min(v.size[2], A), v.size[2] -= y.size[2], v.offset.y += y.size[2], ++y.size[1]), (y.size[1] <= 0 || y.size[2] <= 0) && y.copy(this.dispatches[--p]), (v.size[1] <= 0 || v.size[2] <= 0) && v.copy(this.dispatches[--p]);
+        if (d === 0 ? A = a - h : d === 1 ? A = l + h : d === 2 ? A = -a - u : A = -l + u, A = (A + D - 1) / D | 0, A > 0) {
+          const N = this.dispatches[p++].copy(v);
+          d === 0 ? (N.size[2] = Math.min(v.size[2], A), v.size[2] -= N.size[2], N.offset.y = v.offset.y + v.size[2], N.offset.x -= 1, N.size[1] += 1) : d === 1 ? (N.size[1] = Math.min(v.size[1], A), v.size[1] -= N.size[1], N.offset.x = v.offset.x + v.size[1], N.size[2] += 1) : d === 2 ? (N.size[1] = Math.min(v.size[1], A), v.size[1] -= N.size[1], v.offset.x += N.size[1], N.size[2] += 1, N.offset.y -= 1) : d === 3 && (N.size[2] = Math.min(v.size[2], A), v.size[2] -= N.size[2], v.offset.y += N.size[2], ++N.size[1]), (N.size[1] <= 0 || N.size[2] <= 0) && N.copy(this.dispatches[--p]), (v.size[1] <= 0 || v.size[2] <= 0) && v.copy(this.dispatches[--p]);
         }
       }
     }
     for (let d = 0; d < p; ++d) {
       const m = this.dispatches[d];
-      m.offset.x *= R, m.offset.y *= R;
+      m.offset.x *= D, m.offset.y *= D;
     }
     this.dispatchCount = p;
   }
   // See bend_sss_gpu.h
-  setupCompute(e) {
+  createComputeNode() {
     const {
-      depthNode: t,
-      camera: s,
+      depthNode: e,
+      camera: t,
       sampleCount: o,
-      hardShadowSamples: i,
-      fadeOutSamples: r,
-      outputTexture: u,
-      thickness: a,
-      shadowContrast: l,
-      shadowIntensity: c,
-      bilinearThreshold: h,
-      farDepth: p,
-      nearDepth: d,
-      lightCoordinate: m,
-      dispatchOffset: x
-    } = this, z = Math.floor(o / R) + 2, T = ds("float", z * R), B = () => {
-      const C = j(qe.yz).mul(R).add(x).toConst(), V = m.xy.floor().add(0.5).toConst(), S = m.xy.sub(V).toConst(), H = m.w.greaterThan(0), U = j(C.sign()).toConst(), v = X(C.x.add(U.y)).lessThan(X(C.y.sub(U.x))).toConst(), A = j(
-        v.select(U.y, 0),
-        v.select(0, U.x.negate())
-      ), y = f(A.mul(qe.x).add(C)).toConst(), te = X(y.x).greaterThan(X(y.y)).toConst(), $ = te.select(y.x, y.y).toConst(), W = $.abs().toConst(), se = W.sub(R), I = te.select(S.x, S.y).toVar();
-      I.assign(
-        $.greaterThan(0).select(I.negate(), I)
+      hardShadowSamples: n,
+      fadeOutSamples: i,
+      outputTexture: r,
+      thickness: c,
+      shadowContrast: a,
+      shadowIntensity: h,
+      bilinearThreshold: l,
+      lightCoordinate: u,
+      dispatchOffset: p
+    } = this, d = Math.floor(o / D) + 2, m = fs("float", d * D), x = () => {
+      const w = O(Ke.yz).mul(D).add(p).toConst(), T = u.xy.floor().add(0.5).toConst(), C = u.xy.sub(T).toConst(), j = u.w.greaterThan(0), R = O(w.sign()).toConst(), F = _(w.x.add(R.y)).lessThan(_(w.y.sub(R.x))).toConst(), b = O(
+        F.select(R.y, 0),
+        F.select(0, R.x.negate())
+      ), k = f(b.mul(Ke.x).add(w)).toConst(), W = _(k.x).greaterThan(_(k.y)).toConst(), v = W.select(k.x, k.y).toConst(), A = v.abs().toConst(), N = A.sub(D), $ = W.select(C.x, C.y).toVar();
+      $.assign(
+        v.greaterThan(0).select($.negate(), $)
       );
-      const G = y.add(V).toConst(), E = re(
-        m.xy,
-        G,
-        se.add(I).div(W.add(I))
-      ).toConst(), fe = G.sub(E).toConst(), Y = pe(
-        H.select(
-          xe,
-          xe.bitXor(R - 1)
+      const Y = k.add(T).toConst(), X = ne(
+        u.xy,
+        Y,
+        N.add($).div(A.add($))
+      ).toConst(), ee = Y.sub(X).toConst(), te = G(
+        j.select(
+          we,
+          we.bitXor(D - 1)
         )
-      ).toConst(), M = re(G, E, Y.div(R)).toVar(), L = W.sub(Y).add(I).toConst();
-      return { pixelXY: M, pixelDistance: L, xyDelta: fe, xAxisMajor: te };
-    }, O = (C) => {
-      const V = t.load(C).toVar();
-      return e.renderer.logarithmicDepthBuffer && V.assign(
-        Ae(
-          V,
-          Ve(s),
-          Be(s)
-        )
-      ), ft(
-        C.greaterThanEqual(0).all(),
-        C.lessThan(ve(t)).all()
-      ).select(V, p);
+      ).toConst(), Z = ne(Y, X, te.div(D)).toVar(), q = A.sub(te).add($).toConst();
+      return { pixelXY: Z, pixelDistance: q, xyDelta: ee, xAxisMajor: W };
     };
-    this.computeNode = k(() => {
-      const { pixelXY: C, xyDelta: V, pixelDistance: S, xAxisMajor: H } = B(), U = m.w.negate(), v = d.greaterThan(p).select(-1, 1).toConst(), A = j(C.floor()).toConst();
-      let y, te, $;
-      for (let M = 0; M < z; ++M) {
-        const L = j(C.floor()).toConst(), de = H.select(C.y, C.x).fract().sub(0.5).greaterThan(0).select(1, -1).toConst(), St = j(
-          H.select(0, de),
-          H.select(de, 0)
-        ), oe = O(L).toConst(), Ie = O(L.add(St)).toConst(), Ee = p.sub(oe).abs().toConst(), Nt = ps(
-          oe.sub(Ie).abs(),
-          Ee.mul(h)
-        ), Mt = oe.add(
-          X(oe.sub(Ie)).mul(v)
-        ), bt = Nt.select(oe, Mt), be = M === 0 ? S : U.mul(R * M).add(S).toConst();
-        let ze = bt.sub(m.z).div(be).toConst();
-        M > 0 && (ze = be.greaterThan(0).select(ze, 1e10).toConst()), T.element(xe.add(R * M)).assign(ze), M === 0 && (y = oe, te = Ee, $ = be), C.addAssign(V.mul(U));
+    return U((w) => {
+      const [T, C] = w.renderer.reversedDepthBuffer ? [G(1), G(0)] : [G(0), G(1)], j = (S) => {
+        let P = e.load(S);
+        return w.renderer.logarithmicDepthBuffer && (P = Ue(
+          P,
+          fe(t),
+          xe(t)
+        )), P = P.toConst(), wt(
+          S.greaterThanEqual(0).all(),
+          S.lessThan(e.size()).all()
+        ).select(P, C);
+      }, { pixelXY: R, xyDelta: F, pixelDistance: b, xAxisMajor: k } = x(), W = u.w.negate(), v = T.greaterThan(C).select(-1, 1).toConst(), A = O(R.floor()).toConst();
+      let N, $, Y;
+      for (let S = 0; S < d; ++S) {
+        const P = O(R.floor()).toConst(), de = k.select(R.y, R.x).fract().sub(0.5).greaterThan(0).select(1, -1).toConst(), Ft = O(
+          k.select(0, de),
+          k.select(de, 0)
+        ), se = j(P).toConst(), He = j(P.add(Ft)).toConst(), Ye = C.sub(se).abs().toConst(), Ot = xs(
+          se.sub(He).abs(),
+          Ye.mul(l)
+        ), Ut = se.add(
+          _(se.sub(He)).mul(v)
+        ), jt = Ot.select(se, Ut), De = S === 0 ? b : W.mul(D * S).add(b).toConst();
+        let Be = jt.sub(u.z).div(De).toConst();
+        S > 0 && (Be = De.greaterThan(0).select(Be, 1e10).toConst()), m.element(we.add(D * S)).assign(Be), S === 0 && (N = se, $ = Ye, Y = De), R.addAssign(F.mul(W));
       }
-      ms();
-      const W = y.sub(m.z).div($).toVar(), se = $.add(U).min(a.reciprocal()).mul($).div(te).toConst();
-      W.assign(W.mul(se).sub(v));
-      const I = xe.add(1).toConst(), G = pe(1).toVar();
-      for (let M = 0; M < i; ++M) {
-        const L = W.sub(T.element(I.add(M)).mul(se)).abs();
-        G.assign(G.min(L));
+      gs();
+      const X = N.sub(u.z).div(Y).toVar(), ee = Y.add(W).min(c.reciprocal()).mul(Y).div($).toConst();
+      X.assign(X.mul(ee).sub(v));
+      const te = we.add(1).toConst(), Z = G(1).toVar();
+      for (let S = 0; S < n; ++S) {
+        const P = X.sub(m.element(te.add(S)).mul(ee)).abs();
+        Z.assign(Z.min(P));
       }
-      const E = b(1).toVar();
-      for (let M = i; M < o - r; ++M) {
-        const L = W.sub(T.element(I.add(M)).mul(se)).abs(), he = Z(M & 3).toConst();
-        E.element(he).assign(E.element(he).min(L));
+      const q = z(1).toVar();
+      for (let S = n; S < o - i; ++S) {
+        const P = X.sub(m.element(te.add(S)).mul(ee)).abs(), he = K(S & 3).toConst();
+        q.element(he).assign(q.element(he).min(P));
       }
-      for (let M = o - r; M < o; ++M) {
-        const L = W.sub(T.element(I.add(M)).mul(se)).abs(), he = (M + 1 - (o - r)) / (r + 1) * 0.75, de = Z(M & 3).toConst();
-        E.element(de).assign(E.element(de).min(L.add(he)));
+      for (let S = o - i; S < o; ++S) {
+        const P = X.sub(m.element(te.add(S)).mul(ee)).abs(), he = (S + 1 - (o - i)) / (i + 1) * 0.75, de = K(S & 3).toConst();
+        q.element(de).assign(q.element(de).min(P.add(he)));
       }
-      const fe = l.oneMinus().toConst();
-      G.assign(
-        G.mul(l).add(fe).saturate()
-      ), E.assign(
-        E.mul(l).add(fe).saturate()
+      const Ge = a.oneMinus().toConst();
+      Z.assign(
+        Z.mul(a).add(Ge).saturate()
+      ), q.assign(
+        q.mul(a).add(Ge).saturate()
       );
-      const Y = pe().toVar();
-      Y.assign(E.dot(b(0.25))), Y.assign(ht(G, Y)), fs(u, A, re(1, Y, c));
-    })().compute(
-      0,
-      // Determine this later
-      [R, 1, 1]
-    );
+      const ye = G(0).toVar();
+      ye.assign(q.dot(z(0.25))), ye.assign(ft(Z, ye)), vs(r, A, ne(1, ye, h));
+    })().computeKernel([D, 1, 1]);
   }
   setup(e) {
-    return this.setupCompute(e), this.textureNode;
+    return this.textureNode;
   }
   dispose() {
     this.outputTexture.dispose();
   }
 }
-const Ko = (...n) => new io(...n);
-function Qe(n, e) {
-  let t = 1, s = 0;
-  for (; n > 0; )
-    t /= e, s += t * (n % e), n = Math.floor(n / e);
-  return s;
+const Hn = (...s) => new Io(...s), Lo = /* @__PURE__ */ (() => {
+  const s = new Bs(new Uint8Array(1));
+  return s.format = As, s.minFilter = Qe, s.magFilter = Qe, s.wrapS = Ve, s.wrapT = Ve, s.wrapR = Ve, s.needsUpdate = !0, s;
+})();
+class Wo extends Nt {
+  constructor() {
+    super(Lo), this.url = Hs;
+  }
+  customCacheKey() {
+    return Xs(this.url);
+  }
+  setup(e) {
+    return new Ys().loadAsync(this.url).then((t) => {
+      this.value = t;
+    }).catch((t) => {
+      console.error(t);
+    }), super.setup(e);
+  }
 }
-const Ke = /* @__PURE__ */ Array.from(
+const $o = /* @__PURE__ */ pt(Wo), Yn = /* @__PURE__ */ U(() => $o.sample(M(ke.xy, ys.mod(64)).div(M(128, 128, 64))).r.toConst("stbn")).once()();
+class qo extends Vs {
+  static get type() {
+    return "StorageTexture3DNode";
+  }
+  getDefaultUV() {
+    return M(0.5, 0.5, 0.5);
+  }
+  setUpdateMatrix(e) {
+  }
+  generateUV(e, t) {
+    return t.build(e, this.sampler ? "vec3" : "ivec3");
+  }
+  generateOffset(e, t) {
+    return t.build(e, "ivec3");
+  }
+}
+const Xn = (...s) => new qo(...s);
+function ot(s, e) {
+  let t = 1, o = 0;
+  for (; s > 0; )
+    t /= e, o += t * (s % e), s = Math.floor(s / e);
+  return o;
+}
+const nt = /* @__PURE__ */ Array.from(
   { length: 16 },
-  (n, e) => new P(Qe(e + 1, 2), Qe(e + 1, 3))
-), { resetRendererState: ro, restoreRendererState: ao } = me;
-function uo(n) {
-  return n.isPerspectiveCamera === !0 || n.isOrthographicCamera === !0 || "updateProjectionMatrix" in n && "setViewOffset" in n && "clearViewOffset" in n;
+  (s, e) => new ve(ot(e + 1, 2), ot(e + 1, 3))
+), { resetRendererState: Go, restoreRendererState: Ho } = ge;
+function Yo(s) {
+  return s.isPerspectiveCamera === !0 || s.isOrthographicCamera === !0 || "updateProjectionMatrix" in s && "setViewOffset" in s && "clearViewOffset" in s;
 }
-const lo = /* @__PURE__ */ we({
+const Xo = /* @__PURE__ */ V({
   name: "clipAABB",
   type: "vec4",
   inputs: [
@@ -1131,14 +1303,10 @@ const lo = /* @__PURE__ */ we({
     { name: "minColor", type: "vec4" },
     { name: "maxColor", type: "vec4" }
   ]
-})(([n, e, t, s]) => {
-  const o = s.rgb.add(t.rgb).mul(0.5).toConst(), i = s.rgb.sub(t.rgb).mul(0.5).add(1e-7), r = e.sub(b(o, n.a)).toConst(), a = r.xyz.div(i).abs().toConst(), l = xt(a.x, a.y, a.z).toConst();
-  return ys(
-    l.greaterThan(1),
-    b(o, n.a).add(r.div(l)),
-    e
-  );
-}), _e = [
+})(([s, e, t, o]) => {
+  const n = o.rgb.add(t.rgb).mul(0.5).toConst(), i = o.rgb.sub(t.rgb).mul(0.5).add(1e-7), r = e.sub(z(n, s.a)).toConst(), a = r.xyz.div(i).abs().toConst(), h = Tt(a.x, a.y, a.z).toConst();
+  return h.greaterThan(1).select(z(n, s.a).add(r.div(h)), e);
+}), it = [
   [-1, -1],
   [-1, 1],
   [1, -1],
@@ -1147,17 +1315,17 @@ const lo = /* @__PURE__ */ we({
   [0, -1],
   [0, 1],
   [-1, 0]
-], co = /* @__PURE__ */ ee(
-  (n, e, t, s, o) => {
+], Zo = /* @__PURE__ */ L(
+  (s, e, t, o, n) => {
     const i = t.toVar(), r = t.pow2().toVar();
-    for (const [p, d] of _e) {
-      const m = n.load(e.add(j(p, d))).toConst();
+    for (const [p, d] of it) {
+      const m = s.load(e.add(O(p, d))).toConst();
       i.addAssign(m), r.addAssign(m.pow2());
     }
-    const u = _e.length + 1, a = i.div(u).toConst(), l = Se(r.div(u).sub(a.pow2()).max(0)).mul(o).toConst(), c = a.sub(l).toConst(), h = a.add(l).toConst();
-    return lo(a.clamp(c, h), s, c, h);
+    const c = it.length + 1, a = i.div(c).toConst(), h = be(r.div(c).sub(a.pow2()).max(0)).mul(n).toConst(), l = a.sub(h).toConst(), u = a.add(h).toConst();
+    return Xo(a.clamp(l, u), o, l, u);
   }
-), ho = [
+), _o = [
   [-1, -1],
   [-1, 0],
   [-1, 1],
@@ -1167,70 +1335,71 @@ const lo = /* @__PURE__ */ we({
   [1, -1],
   [1, 0],
   [1, 1]
-], po = /* @__PURE__ */ Pe({
+], Ko = /* @__PURE__ */ Ie({
   closestCoord: "ivec2",
   closestDepth: "float"
-}), mo = /* @__PURE__ */ ee(
-  (n, e) => {
-    const t = j(0).toVar(), s = pe(1).toVar();
-    for (const [o, i] of ho) {
-      const r = e.add(j(o, i)).toConst(), u = n.load(r).r.toConst();
-      K(u.lessThan(s), () => {
-        t.assign(r), s.assign(u);
+}), Qo = /* @__PURE__ */ L(
+  (s, e) => (t) => {
+    const o = O(0).toVar(), n = G(1).toVar();
+    for (const [i, r] of _o) {
+      const c = e.add(O(i, r)).toConst();
+      let a = s.load(c).r;
+      t.renderer.reversedDepthBuffer && (a = a.oneMinus()), a = a.toConst(), ae(a.lessThan(n), () => {
+        o.assign(c), n.assign(a);
       });
     }
-    return po(t, s);
+    return Ko(o, n);
   }
-), fo = ee(
-  (n, e) => {
-    const s = n.mul(e).fract().abs(), o = xt(s, s.oneMinus());
-    return o.x.mul(o.y).oneMinus().div(0.75);
+), Jo = /* @__PURE__ */ L(
+  (s, e) => {
+    const o = s.mul(e).fract().abs(), n = Tt(o, o.oneMinus());
+    return n.x.mul(n.y).oneMinus().div(0.75);
   }
-), Je = /* @__PURE__ */ new P(), xo = /* @__PURE__ */ new Ft(1, 1);
-class et extends _ {
-  constructor(e, t, s, o) {
-    if (super("vec4"), this.temporalAlpha = g(0.05), this.varianceGamma = g(1), this.velocityThreshold = g(0.1), this.depthError = g(1e-3), this.debugShowRejection = !1, this.resolveRT = this.createRenderTarget("Resolve"), this.historyRT = this.createRenderTarget("History"), this.resolveMaterial = new le(), this.mesh = new Ne(), this.needsSyncPostProcessing = !1, this.needsClearHistory = !1, this.resolveNode = ie(this.resolveRT.texture), this.historyNode = ie(this.historyRT.texture), this.previousDepthNode = ie(xo), this.originalProjectionMatrix = new ne(), this.jitterIndex = 0, this.inputNode = e, this.depthNode = t, this.velocityNode = s, !uo(o))
+), rt = /* @__PURE__ */ new ve(), en = /* @__PURE__ */ new $s(1, 1);
+class at extends Q {
+  constructor(e, t, o, n) {
+    if (super("vec4"), this.temporalAlpha = g(0.05), this.varianceGamma = g(1), this.velocityThreshold = g(0.1), this.depthError = g(1e-3), this.debugShowRejection = !1, this.resolveRT = this.createRenderTarget("resolve"), this.historyRT = this.createRenderTarget("history"), this.resolveMaterial = new ce(), this.mesh = new ze(), this.needsSyncRenderPipeline = !1, this.needsClearHistory = !1, this.resolveNode = oe(this.resolveRT.texture), this.historyNode = oe(this.historyRT.texture), this.previousDepthNode = oe(en), this.originalProjectionMatrix = new Se(), this.jitterIndex = 0, this.updateBeforeType = H.FRAME, this.resolveMaterial.name = "TemporalAntialias_resolve", this.mesh.name = "TemporalAntialias", this.inputNode = e, this.depthNode = t, this.velocityNode = o, !Yo(n))
       throw new Error("The provided camera is not supported.");
-    this.camera = o, this.textureNode = Oe(this, this.resolveRT.texture), this.updateBeforeType = Q.FRAME;
+    this.camera = n, this.textureNode = $e(this, this.resolveRT.texture);
   }
   static get type() {
     return "TemporalAntialiasNode";
   }
   customCacheKey() {
-    return je(this.camera.id, +this.debugShowRejection);
+    return We(this.camera.id, +this.debugShowRejection);
   }
   createRenderTarget(e) {
-    const t = new st(1, 1, {
+    const t = new Mt(1, 1, {
       depthBuffer: !1,
-      type: nt,
-      format: ot
-    }), s = t.texture;
-    s.minFilter = ae, s.magFilter = ae, s.generateMipmaps = !1;
-    const o = this.constructor.type;
-    return s.name = e != null ? `${o}.${e}` : o, t;
+      type: Ct,
+      format: zt
+    }), o = t.texture;
+    o.minFilter = ue, o.magFilter = ue, o.generateMipmaps = !1;
+    const n = this.constructor.type;
+    return o.name = e != null ? `${n}_${e}` : n, t;
   }
   getTextureNode() {
     return this.textureNode;
   }
   setSize(e, t) {
-    const { resolveRT: s, historyRT: o } = this;
-    return (e !== o.width || t !== o.height) && (s.setSize(e, t), o.setSize(e, t), this.needsClearHistory = !0), this;
+    const { resolveRT: o, historyRT: n } = this;
+    return (e !== n.width || t !== n.height) && (o.setSize(e, t), n.setSize(e, t), this.needsClearHistory = !0), this;
   }
   clearHistory(e) {
     e.setRenderTarget(this.resolveRT), e.clear(), e.setRenderTarget(this.historyRT), e.clear(), this.needsClearHistory = !1;
   }
   setViewOffset(e, t) {
-    const { camera: s } = this;
-    s.updateProjectionMatrix(), this.originalProjectionMatrix.copy(s.projectionMatrix), Ye.setProjectionMatrix(this.originalProjectionMatrix);
-    const o = Ke[this.jitterIndex], i = o.x - 0.5, r = o.y - 0.5;
-    s.setViewOffset(e, t, i, r, e, t);
+    const { camera: o } = this;
+    o.updateProjectionMatrix(), this.originalProjectionMatrix.copy(o.projectionMatrix), tt.setProjectionMatrix(this.originalProjectionMatrix);
+    const n = nt[this.jitterIndex], i = n.x - 0.5, r = n.y - 0.5;
+    o.setViewOffset(e, t, i, r, e, t);
   }
   clearViewOffset() {
-    this.camera.clearViewOffset(), Ye.setProjectionMatrix(null), this.jitterIndex = (this.jitterIndex + 1) % Ke.length;
+    this.camera.clearViewOffset(), tt.setProjectionMatrix(null), this.jitterIndex = (this.jitterIndex + 1) % nt.length;
   }
   copyDepthTexture(e) {
-    const t = this.depthNode.value, s = this.previousDepthTexture ??= t.clone();
-    (s.image.width !== t.width || s.image.height !== t.height) && (s.image.width = t.width, s.image.height = t.height, s.needsUpdate = !0), e.copyTextureToTexture(t, s), this.previousDepthNode.value = s;
+    const t = this.depthNode.value, o = this.previousDepthTexture ??= t.clone();
+    (o.image.width !== t.width || o.image.height !== t.height) && (o.image.width = t.width, o.image.height = t.height, o.needsUpdate = !0), e.copyTextureToTexture(t, o), this.previousDepthNode.value = o;
   }
   swapBuffers() {
     const { resolveRT: e, historyRT: t } = this;
@@ -1239,136 +1408,153 @@ class et extends _ {
   updateBefore({ renderer: e }) {
     if (e == null)
       return;
-    const t = e.getDrawingBufferSize(Je);
-    this.setSize(t.x, t.y), this.rendererState = ro(e, this.rendererState), this.needsClearHistory && this.clearHistory(e), e.setRenderTarget(this.resolveRT), this.mesh.material = this.resolveMaterial, this.mesh.render(e), ao(e, this.rendererState), Tt(e) && this.copyDepthTexture(e), this.swapBuffers(), this.needsSyncPostProcessing && this.clearViewOffset();
+    const t = e.getDrawingBufferSize(rt);
+    this.setSize(t.x, t.y), this.rendererState = Go(e, this.rendererState), this.needsClearHistory && this.clearHistory(e), e.setRenderTarget(this.resolveRT), this.mesh.material = this.resolveMaterial, this.mesh.render(e), Ho(e, this.rendererState), Pt(e) && this.copyDepthTexture(e), this.swapBuffers(), this.needsSyncRenderPipeline && this.clearViewOffset();
   }
   setupResolveNode({ renderer: e }) {
-    const t = (s) => {
-      const { previousDepthNode: o } = this, i = o.load(j(s.mul(ve(o)).sub(0.5))).toConst();
-      return e.logarithmicDepthBuffer ? Ae(
+    const t = (o) => {
+      const { previousDepthNode: n } = this, i = n.load(O(o.mul(n.size()).sub(0.5))).toConst();
+      return e.logarithmicDepthBuffer ? Ue(
         i,
-        Ve(this.camera),
-        Be(this.camera)
-      ) : i;
+        fe(this.camera),
+        xe(this.camera)
+      ) : e.reversedDepthBuffer ? i.oneMinus() : i;
     };
-    return k(() => {
-      const s = j(ut), o = xs, i = mo(this.depthNode, s).toConst(), r = i.get("closestCoord"), u = i.get("closestDepth"), a = this.velocityNode.load(r).xyz.mul(N(0.5, -0.5, 0.5)).toConst(), l = a.xy.length().div(this.velocityThreshold).oneMinus().saturate(), c = o.sub(a.xy).toConst(), h = t(c), p = e.logarithmicDepthBuffer ? Ae(
-        u,
-        Ve(this.camera),
-        Be(this.camera)
-      ) : u, d = gs(
+    return U(() => {
+      const o = O(ke), n = ws, i = Qo(this.depthNode, o).toConst(), r = i.get("closestCoord"), c = i.get("closestDepth"), a = this.velocityNode.load(r).xyz.mul(M(0.5, -0.5, 0.5)).toConst(), h = a.xy.length().div(this.velocityThreshold).oneMinus().saturate(), l = n.sub(a.xy).toConst(), u = t(l), p = e.logarithmicDepthBuffer ? Ue(
+        c,
+        fe(this.camera),
+        xe(this.camera)
+      ) : c, d = Ts(
         p.add(a.z),
-        h.add(this.depthError)
-      ), m = l.mul(d), x = ft(
-        c.greaterThanEqual(0).all(),
-        c.lessThanEqual(1).all()
-      ).toFloat(), z = u.notEqual(1).toFloat(), T = this.inputNode.load(s).toVar();
-      return K(x.mul(z).mul(m).greaterThan(0), () => {
-        const B = ie(this.historyNode, c), O = co(
+        u.add(this.depthError)
+      ), m = h.mul(d), x = wt(
+        l.greaterThanEqual(0).all(),
+        l.lessThanEqual(1).all()
+      ).toFloat(), w = c.notEqual(1).toFloat(), T = this.inputNode.load(o).toVar();
+      return ae(x.mul(w).mul(m).greaterThan(0), () => {
+        const C = oe(this.historyNode, l), j = Zo(
           this.inputNode,
-          s,
+          o,
           T,
-          B,
+          C,
           this.varianceGamma
-        ), C = re(
+        ), R = ne(
           this.temporalAlpha,
-          0.8,
-          fo(a.xy, ve(this.inputNode))
+          0.4,
+          Jo(a.xy, Ns(this.inputNode))
         ).saturate();
-        T.assign(re(O, T, C));
+        T.assign(ne(j, T, R));
       }).Else(() => {
-        this.debugShowRejection && T.assign(N(1, 0, 0));
+        this.debugShowRejection && T.assign(M(1, 0, 0));
       }), T;
     })();
   }
   setup(e) {
-    const { context: t } = e.context.postProcessing ?? {};
-    if (t != null) {
-      const { onBeforePostProcessing: o } = t;
-      t.onBeforePostProcessing = () => {
-        o?.();
-        const i = e.renderer.getDrawingBufferSize(Je);
-        this.setViewOffset(i.width, i.height);
-      }, this.needsSyncPostProcessing = !0;
+    const t = () => {
+      const n = e.renderer.getDrawingBufferSize(rt);
+      this.setViewOffset(n.width, n.height);
+    };
+    if (e.context.renderPipeline != null) {
+      const { context: n } = e.context.renderPipeline;
+      n.onBeforeRenderPipeline = t, this.needsSyncRenderPipeline = !0;
+    }
+    if (e.context.postProcessing != null) {
+      const { context: n } = e.context.postProcessing;
+      n.onBeforePostProcessing = t, this.needsSyncRenderPipeline = !0;
     }
-    const { resolveMaterial: s } = this;
-    return s.fragmentNode = this.setupResolveNode(e), s.needsUpdate = !0, this.textureNode.uvNode = this.inputNode.uvNode, this.textureNode;
+    const { resolveMaterial: o } = this;
+    return o.fragmentNode = this.setupResolveNode(e), o.needsUpdate = !0, this.textureNode.uvNode = this.inputNode.uvNode, this.textureNode;
   }
   dispose() {
     this.resolveRT.dispose(), this.historyRT.dispose(), this.previousDepthTexture?.dispose(), this.resolveMaterial.dispose(), this.mesh.geometry.dispose(), super.dispose();
   }
 }
-function _o(...n) {
-  if (n.length === 1)
-    return (i, r, u, a) => new et(
-      De(i),
+function Zn(...s) {
+  if (s.length === 1)
+    return (i, r, c, a) => new at(
+      Oe(i),
       r,
-      u,
+      c,
       a
     );
-  const [e, t, s, o] = n;
-  return new et(
-    De(e),
+  const [e, t, o, n] = s;
+  return new at(
+    Oe(e),
     t,
-    s,
-    o
+    o,
+    n
   );
 }
 export {
-  yt as DownsampleThresholdNode,
-  we as FnLayout,
-  ee as FnVar,
-  vt as GaussianBlurNode,
-  Is as HighpVelocityNode,
-  Es as KawaseBlurNode,
-  Xs as LensFlareNode,
-  Vs as MipmapBlurNode,
-  wt as MipmapSurfaceBlurNode,
-  Go as Node,
-  Ks as OutputTexture3DNode,
-  zs as OutputTextureNode,
-  io as ScreenSpaceShadowNode,
-  et as TemporalAntialiasNode,
-  Be as cameraFar,
-  Ve as cameraNear,
-  Co as cameraPositionWorld,
-  Ro as debugFragmentNode,
-  Vo as debugNode,
-  Do as debugVertexNode,
-  Zo as depthToColor,
-  _s as depthToViewZ,
-  jo as dithering,
-  Po as downsampleThreshold,
-  ko as equirectGrid,
-  Qo as equirectToDirectionWorld,
-  Fo as gaussianBlur,
-  Ye as highpVelocity,
-  Bo as hookFunction,
-  Us as interleavedGradientNoise,
-  bo as inverseProjectionMatrix,
-  zo as inverseViewMatrix,
-  Tt as isWebGPU,
-  Oo as kawaseBlur,
-  Io as lensFlare,
-  Ae as logarithmicToPerspectiveDepth,
-  Ao as mipmapBlur,
-  gt as mipmapBlurDownsample,
-  Ds as mipmapBlurUpsample,
-  Uo as mipmapSurfaceBlur,
-  qo as node,
-  Oe as outputTexture,
-  Ho as outputTexture3D,
-  Yo as perspectiveToLogarithmicDepth,
-  No as projectionMatrix,
-  Wo as rayEllipsoidIntersection,
-  Eo as raySphereIntersection,
-  Lo as raySpheresIntersections,
-  Zs as raySpheresIntersectionsStruct,
-  Ko as screenSpaceShadow,
-  Xo as screenToPositionView,
-  _o as temporalAntialias,
-  $o as textureCatmullRom,
-  Js as turbo,
-  Mo as viewMatrix
+  yn as CascadedShadowMapsNode,
+  Bt as DownsampleThresholdNode,
+  V as FnLayout,
+  L as FnVar,
+  At as GaussianBlurNode,
+  ho as HighpVelocityNode,
+  po as KawaseBlurNode,
+  To as LensFlareNode,
+  so as MipmapBlurNode,
+  Vt as MipmapSurfaceBlurNode,
+  Ln as Node,
+  Rn as OnBeforeFrameUpdate,
+  Cn as OnFrameUpdate,
+  Po as OutputTexture3DNode,
+  Qs as OutputTextureNode,
+  Wo as STBNTextureNode,
+  Io as ScreenSpaceShadowNode,
+  qo as StorageTexture3DNode,
+  at as TemporalAntialiasNode,
+  Un as bvecAnd,
+  On as bvecNot,
+  jn as bvecOr,
+  xe as cameraFar,
+  fe as cameraNear,
+  gn as cameraPositionWorld,
+  Nn as debugFragmentNode,
+  wn as debugMaterial,
+  Sn as debugNode,
+  Tn as debugVertexNode,
+  hn as depthToColor,
+  Rt as depthToViewZ,
+  Bn as dithering,
+  zn as downsampleThreshold,
+  An as equirectGrid,
+  dn as equirectToDirectionWorld,
+  Dn as gaussianBlur,
+  tt as highpVelocity,
+  bn as hookFunction,
+  lo as interleavedGradientNoise,
+  fn as inverseProjectionMatrix,
+  xn as inverseViewMatrix,
+  Pt as isWebGPU,
+  Vn as kawaseBlur,
+  Fn as lensFlare,
+  Ue as logarithmicToPerspectiveDepth,
+  Mn as mipmapBlur,
+  Dt as mipmapBlurDownsample,
+  to as mipmapBlurUpsample,
+  Pn as mipmapSurfaceBlur,
+  Wn as node,
+  $e as outputTexture,
+  $n as outputTexture3D,
+  un as perspectiveToLogarithmicDepth,
+  pn as projectionMatrix,
+  In as rayEllipsoidIntersection,
+  En as raySphereIntersection,
+  kn as raySpheresIntersections,
+  Ao as raySpheresIntersectionsStruct,
+  Hn as screenSpaceShadow,
+  ln as screenToPositionView,
+  Yn as stbn,
+  $o as stbnTexture,
+  Xn as storageTexture3D,
+  Zn as temporalAntialias,
+  Gn as textureCatmullRom,
+  qn as textureGather,
+  Zs as turbo,
+  mn as viewMatrix,
+  vn as viewZ
 };
 //# sourceMappingURL=webgpu.js.map