@takram/three-geospatial 0.7.1 → 0.9.0

package/build/webgpu.js

@@ -1,82 +1,181 @@
-import { Vector3 as qe, Mesh as J, Scene as Ze, Camera as Qe, RenderTarget as Se, RGBAFormat as Me, HalfFloatType as Re, LinearFilter as Z, Vector2 as z, Matrix4 as W, AdditiveBlending as Ke, PlaneGeometry as Je, PerspectiveCamera as Ye, SRGBColorSpace as _e, CanvasTexture as Xe, DepthTexture as et } from "three";
-import { reference as $, uniform as v, vec4 as w, positionGeometry as be, texture as I, uv as V, vec2 as p, add as N, luminance as tt, smoothstep as ze, Fn as C, screenCoordinate as Be, time as st, vec3 as y, equirectUV as ot, fwidth as nt, abs as Ve, positionLocal as rt, positionPrevious as it, sub as k, nodeImmutable as at, instancedArray as ue, storage as ut, uvec2 as Ce, If as F, globalId as X, Return as lt, atomicAdd as ct, instanceIndex as ht, mat3 as Pe, struct as oe, min as dt, mul as pt, fract as mt, distance as ft, mix as te, sqrt as Y, dot as Q, color as gt, mat4 as xt, mat2 as vt, bvec4 as yt, uvec4 as wt, ivec4 as Tt, bvec3 as Nt, uvec3 as St, ivec3 as Mt, bvec2 as Rt, ivec2 as T, bool as bt, uint as zt, int as H, float as ne, textureSize as Ae, viewZToLogarithmicDepth as Fe, logarithmicDepthToViewZ as De, perspectiveDepthToViewZ as je, orthographicDepthToViewZ as Bt, PI2 as Vt, PI as Ct, cos as le, sin as ce, viewZToPerspectiveDepth as Pt, screenUV as At, step as Ft, and as Dt, screenSize as jt, max as Ue, select as Ut } from "three/tsl";
-import { NodeMaterial as P, TextureNode as se, TempNode as E, NodeUpdateType as A, RendererUtils as O, QuadMesh as q, Vector2 as It, RenderTarget as kt, RGBAFormat as $t, HalfFloatType as Et, LinearFilter as he, StorageBufferAttribute as Ot, MeshBasicNodeMaterial as Gt, NodeBuilder as Lt, Node as Wt, Texture3DNode as Ht } from "three/webgpu";
-import { Q as re } from "./shared3.js";
-import { i as x } from "./shared.js";
-import { hash as Ie } from "three/src/nodes/core/NodeUtils.js";
-let ee;
-function D(o, e, t) {
-  ee ??= /* @__PURE__ */ new WeakMap();
-  let s = ee.get(o);
-  return s == null && (s = {}, ee.set(o, 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 Os = (o) => D(
-  o,
+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",
-  () => $("projectionMatrix", "mat4", o).setName("projectionMatrix")
-), Gs = (o) => D(
-  o,
+  () => le("projectionMatrix", "mat4", s).setName(
+    "projectionMatrix"
+  )
+) : Ht, mn = (s) => s != null ? J(
+  s,
   "viewMatrix",
-  () => $("matrixWorldInverse", "mat4", o).setName("viewMatrix")
-), Ls = (o) => D(
-  o,
+  () => le("matrixWorldInverse", "mat4", s).setName("viewMatrix")
+) : Yt, fn = (s) => s != null ? J(
+  s,
   "inverseProjectionMatrix",
-  () => $("projectionMatrixInverse", "mat4", o).setName(
+  () => le("projectionMatrixInverse", "mat4", s).setName(
     "inverseProjectionMatrix"
   )
-), Ws = (o) => D(
-  o,
+) : qt, xn = (s) => s != null ? J(
+  s,
   "inverseViewMatrix",
-  () => $("matrixWorld", "mat4", o).setName("inverseViewMatrix")
-), Hs = (o) => D(
-  o,
+  () => le("matrixWorld", "mat4", s).setName("inverseViewMatrix")
+) : Gt, gn = (s) => s != null ? J(
+  s,
   "cameraPositionWorld",
-  () => v(new qe()).setName("cameraPositionWorld").onRenderUpdate((e, { value: t }) => {
-    t.setFromMatrixPosition(o.matrixWorld);
+  () => g("vec3").setName("cameraPositionWorld").onRenderUpdate((e, { value: t }) => {
+    t.setFromMatrixPosition(s.matrixWorld);
   })
-), de = (o) => D(
-  o,
+) : $t, fe = (s) => s != null ? J(
+  s,
   "cameraNear",
-  () => $("near", "float", o).setName("cameraNear")
-), pe = (o) => D(
-  o,
+  () => le("near", "float", s).setName("cameraNear")
+) : je, xe = (s) => s != null ? J(
+  s,
   "cameraFar",
-  () => $("far", "float", o).setName("cameraFar")
-);
-async function ie(o, e) {
-  return await o.debug.getShaderAsync(new Ze(), new Qe(), 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 qs(o, e) {
-  const t = new J(new re(), e);
-  ie(o, 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 Zs(o, e) {
-  const t = new J(new re(), e);
-  ie(o, 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 Qs(o, e) {
-  const t = new P();
-  t.vertexNode = w(be.xy, 0, 1), t.fragmentNode = e;
-  const s = new J(new re(), t);
-  ie(o, s).then((n) => {
-    console.log(n.fragmentShader);
-  }).finally(() => {
-    t.dispose(), s.geometry.dispose();
-  });
+async function Tn(s, e) {
+  return (await Ce(s, e)).vertexShader;
+}
+async function Nn(s, e) {
+  return (await Ce(s, e)).fragmentShader;
+}
+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 Ks(o, e, t) {
-  const s = o[e];
-  return o[e] = ((...n) => (t(...n), s.apply(o, n))), o;
+function bn(s, e, t) {
+  const o = s[e];
+  return s[e] = ((...n) => (t(...n), o.apply(s, n))), s;
 }
-class qt extends se {
+class Qs extends bs {
   static get type() {
     return "OutputTextureNode";
   }
@@ -90,26 +189,26 @@ class qt extends se {
     return new this.constructor(this.owner, this.value);
   }
 }
-const ke = (...o) => new qt(...o);
-class _ extends E {
+const $e = (...s) => new Qs(...s);
+class Re extends Q {
   constructor(e) {
-    super("vec4"), this.resolutionScale = 1, this.renderTargets = [], this.inputNode = e, this.updateBeforeType = A.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 Se(1, 1, {
+    const t = new Mt(1, 1, {
       depthBuffer: !1,
-      type: Re,
-      format: Me
-    }), s = t.texture;
-    s.minFilter = Z, s.magFilter = Z, s.generateMipmaps = !1;
+      type: Ct,
+      format: zt
+    }), o = t.texture;
+    o.minFilter = ue, o.magFilter = ue, o.generateMipmaps = !1;
     const n = this.constructor.type;
-    return s.name = e != null ? `${n}.${e}` : n, this.renderTargets.push(t), t;
+    return o.name = e != null ? `${n}_${e}` : n, this.renderTargets.push(t), t;
   }
   getTextureNode() {
-    return x(
+    return y(
       this.textureNode != null,
       "outputTexture must be specified before getTextureNode() is called."
     ), this.textureNode;
@@ -118,17 +217,17 @@ class _ extends E {
     return this.textureNode?.value ?? null;
   }
   set outputTexture(e) {
-    this.textureNode = e != null ? ke(this, e) : void 0;
+    this.textureNode = e != null ? $e(this, e) : void 0;
   }
   setup(e) {
-    const { inputNode: t, textureNode: s } = this;
-    return x(
+    const { inputNode: t, textureNode: o } = this;
+    return y(
       t != null,
       "inputNode must be specified before being setup."
-    ), x(
-      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 _ extends E {
     super.dispose();
   }
 }
-const { resetRendererState: Zt, restoreRendererState: Qt } = O;
-class ae extends _ {
+const { resetRendererState: Js, restoreRendererState: eo } = ge;
+class qe extends Re {
   constructor(e, t) {
-    super(e), this.downsampleRTs = [], this.upsampleRTs = [], this.downsampleMaterial = new P(), this.upsampleMaterial = new P(), this.mesh = new q(), this.inputTexelSize = v(new z()), this.downsampleNode = I();
-    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 n = Math.max(Math.round(e * s), 1), r = Math.max(Math.round(t * s), 1);
-    const { downsampleRTs: i, upsampleRTs: u } = this;
-    for (let a = 0; a < i.length; ++a)
-      n = Math.max(Math.round(n / 2), 1), r = Math.max(Math.round(r / 2), 1), i[a].setSize(n, r), a < u.length && u[a].setSize(n, r);
+    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)
+      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 ae extends _ {
       return;
     const {
       downsampleRTs: t,
-      upsampleRTs: s,
+      upsampleRTs: o,
       mesh: n,
-      inputNode: r,
-      inputTexelSize: i,
-      downsampleNode: u
+      inputNode: i,
+      inputTexelSize: r,
+      downsampleNode: c
     } = this;
-    x(r != null);
-    const { width: a, height: h } = r.value;
+    y(i != null);
+    const { width: a, height: h } = i.value;
     this.setSize(a, h);
-    const c = r.value;
-    this.rendererState = Zt(e, this.rendererState), n.material = this.downsampleMaterial;
-    for (const l of t) {
-      const { width: d, height: m } = r.value;
-      i.value.set(1 / d, 1 / m), e.setRenderTarget(l), n.render(e), r.value = l.texture;
+    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(u), n.render(e), i.value = u.texture;
     }
     n.material = this.upsampleMaterial;
-    for (let l = s.length - 1; l >= 0; --l) {
-      const d = s[l], { width: m, height: f } = r.value;
-      i.value.set(1 / m, 1 / f), u.value = t[l].texture, e.setRenderTarget(d), n.render(e), r.value = d.texture;
+    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;
     }
-    Qt(e, this.rendererState), r.value = c;
+    eo(e, this.rendererState), i.value = l;
   }
   setup(e) {
     const { inputNode: t } = this;
-    x(t != null);
-    const { downsampleMaterial: s, upsampleMaterial: n } = this;
-    return s.fragmentNode = this.setupDownsampleNode(e), n.fragmentNode = this.setupUpsampleNode(e), s.needsUpdate = !0, n.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 ae extends _ {
     this.downsampleMaterial.dispose(), this.upsampleMaterial.dispose(), this.mesh.geometry.dispose(), super.dispose();
   }
 }
-const $e = (o, e) => {
-  const t = V(), s = w(1, 1, -1, -1).mul(e.xyxy).add(t.xyxy).toVertexStage(), n = w(2, 2, -2, -2).mul(e.xyxy).add(t.xyxy).toVertexStage(), r = s.zy, i = s.xy, u = s.zw, a = s.xw, h = p(t.x, n.y), c = p(n.z, t.y), l = p(n.x, t.y), d = p(t.x, n.w), m = n.zy, f = n.xy, g = n.zw, R = n.xw;
-  return N(
-    N(
-      o.sample(t),
-      o.sample(r),
-      o.sample(i),
-      o.sample(u),
-      o.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),
-    N(
-      o.sample(h),
-      o.sample(c),
-      o.sample(l),
-      o.sample(d)
+    B(
+      s.sample(h),
+      s.sample(l),
+      s.sample(u),
+      s.sample(p)
     ).mul(1 / 16),
-    N(
-      o.sample(m),
-      o.sample(f),
-      o.sample(g),
-      o.sample(R)
+    B(
+      s.sample(d),
+      s.sample(m),
+      s.sample(x),
+      s.sample(w)
     ).mul(1 / 32)
   );
-}, Kt = (o, e) => {
-  const t = V(), s = w(1, 1, -1, -1).mul(e.xyxy).add(t.xyxy).toVertexStage(), n = p(t.x, s.y), r = p(s.z, t.y), i = p(s.x, t.y), u = p(t.x, s.w), a = s.zy, h = s.xy, c = s.zw, l = s.xw;
-  return N(
-    o.sample(t).mul(0.25),
-    N(
-      o.sample(n),
-      o.sample(r),
-      o.sample(i),
-      o.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),
-    N(
-      o.sample(a),
-      o.sample(h),
-      o.sample(c),
-      o.sample(l)
+    B(
+      s.sample(a),
+      s.sample(h),
+      s.sample(l),
+      s.sample(u)
     ).mul(0.0625)
   );
 };
-class Jt extends ae {
+class so extends qe {
   static get type() {
     return "MipmapBlurNode";
   }
@@ -242,149 +343,132 @@ class Jt extends ae {
     super(e, t), this.resolutionScale = 0.5;
   }
   setupDownsampleNode(e) {
-    return x(this.inputNode != null), $e(this.inputNode, this.inputTexelSize);
+    return y(this.inputNode != null), Dt(this.inputNode, this.inputTexelSize);
   }
   setupUpsampleNode(e) {
-    return x(this.inputNode != null), Kt(this.inputNode, this.inputTexelSize);
+    return y(this.inputNode != null), to(this.inputNode, this.inputTexelSize);
   }
 }
-const Js = (...o) => new Jt(...o), { resetRendererState: Yt, restoreRendererState: _t } = O;
-class Xt extends _ {
+const Mn = (...s) => new so(...s), { resetRendererState: oo, restoreRendererState: no } = ge;
+class io extends Re {
   constructor(e) {
-    super(e), this.material = new P(), this.mesh = new q(this.material), this.inputTexelSize = v(new z()), 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, n = Math.max(Math.round(e * s), 1), r = Math.max(Math.round(t * s), 1);
-    return this.renderTarget.setSize(n, r), 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;
-    x(t != null);
-    const { width: s, height: n } = t.value;
-    this.setSize(s, n), this.inputTexelSize.value.set(1 / s, 1 / n), this.rendererState = Yt(e, this.rendererState), e.setRenderTarget(this.renderTarget), this.mesh.render(e), _t(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;
-    x(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 Ee extends Xt {
+class Bt extends io {
   constructor(e) {
-    super(e), this.thresholdLevel = v(5), this.thresholdRange = v(1), this.resolutionScale = 0.5;
+    super(e), this.thresholdLevel = g(5), this.thresholdRange = g(1), this.resolutionScale = 0.5;
   }
   static get type() {
     return "DownsampleThresholdNode";
   }
   setupOutputNode() {
-    const { inputNode: e, thresholdLevel: t, thresholdRange: s, inputTexelSize: n } = this;
-    x(e != null);
-    const r = $e(e, n), i = tt(r.rgb), u = ze(
+    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),
-      i
+      t.add(o),
+      r
     );
-    return w(r.rgb, i).mul(u);
+    return z(i.rgb, r).mul(c);
   }
 }
-const Ys = (...o) => new Ee(...o);
-function me(o) {
-  if (typeof o == "string")
-    return o;
-  if (o.layout.name == null)
-    throw new Error("Struct name is required.");
-  return o.layout.name;
-}
-function K({
-  typeOnly: o = !1,
-  ...e
-}) {
-  return o ? (t) => C(t) : (t) => C(t).setLayout({
-    ...e,
-    type: me(e.type),
-    inputs: e.inputs?.map((s) => ({
-      ...s,
-      type: me(s.type)
-    })) ?? []
-  });
-}
-function G(o) {
-  return C((e, t) => {
-    const s = o(...e);
-    return typeof s == "function" ? s(t) : s;
-  });
-}
-const { resetRendererState: es, restoreRendererState: ts } = O;
-class ss extends _ {
+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 P(), this.mesh = new q(this.material), this.inputTexelSize = v(new z()), this.direction = v(new z()), 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, n = Math.max(Math.round(e * s), 1), r = Math.max(Math.round(t * s), 1);
-    return this.horizontalRT.setSize(n, r), this.verticalRT.setSize(n, r), 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: n, inputNode: r, direction: i } = this;
-    x(r != null);
-    const { width: u, height: a } = r.value;
-    this.setSize(u, a), this.inputTexelSize.value.set(1 / u, 1 / a);
-    const h = r.value;
-    this.rendererState = es(e, this.rendererState);
-    for (let c = 0; c < this.iterations; ++c)
-      i.value.set(1, 0), e.setRenderTarget(t), n.render(e), r.value = t.texture, i.value.set(0, 1), e.setRenderTarget(s), n.render(e), r.value = s.texture;
-    ts(e, this.rendererState), r.value = h;
+    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;
-    x(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 fe(o) {
-  if (x(o >= 0), o === 0)
+function et(s) {
+  if (y(s >= 0), s === 0)
     return new Float64Array(0);
-  if (o === 1)
+  if (s === 1)
     return new Float64Array([1]);
-  let e = new Float64Array(o), t = new Float64Array(o), s = t;
-  for (let n = 1; n <= o; ++n) {
-    for (let r = 0; r < n; ++r)
-      t[r] = r === 0 || r === n - 1 ? 1 : e[r - 1] + e[r];
-    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(o, e = 2) {
-  x(o >= 3);
-  const t = o + e * 2, s = e > 0 ? fe(t).slice(e, -e) : fe(t), n = Math.floor((s.length - 1) / 2), r = s.reduce((l, d) => l + d, 0), i = s.slice(n), u = [...Array(n + 1).keys()], a = new Float64Array(Math.floor(u.length / 2)), h = new Float64Array(a.length);
-  a[0] = i[0] / r;
-  for (let l = 1, d = 1; l < u.length - 1; l += 2, ++d) {
-    const m = u[l], f = u[l + 1], g = i[l], R = i[l + 1], S = g + R, B = (m * g + f * R) / S;
-    a[d] = S / r, h[d] = B;
-  }
-  const c = (a.reduce((l, d) => l + d, 0) - a[0] * 0.5) * 2;
-  if (c !== 0) {
-    const l = 1 / c;
-    for (let d = 0; d < a.length; ++d)
-      a[d] *= l;
+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 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 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] *= u;
   }
   return {
     offsets: h,
     weights: a
   };
 }
-class Oe extends ss {
+class At extends co {
   static get type() {
     return "GaussianBlurNode";
   }
@@ -392,61 +476,64 @@ class Oe extends ss {
     super(e), this.kernelSize = t;
   }
   setupOutputNode(e) {
-    const { inputNode: t, inputTexelSize: s, direction: n } = this;
-    x(t != null);
-    const { offsets: r, weights: i } = os(this.kernelSize);
-    return C(() => {
-      const u = V(), a = n.mul(s).toVertexStage(), h = t.sample(u).mul(i[0]);
-      for (let c = 1; c < r.length; ++c) {
-        const l = a.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(
-          N(
-            t.sample(u.add(l)),
-            t.sample(u.sub(l))
-          ).mul(i[c])
+          B(
+            t.sample(c.add(u)),
+            t.sample(c.sub(u))
+          ).mul(r[l])
         );
       }
       return h;
     })();
   }
 }
-const _s = (...o) => new Oe(...o), ns = (o) => o.dot(p(0.06711056, 583715e-8)).fract().mul(52.9829189).fract(), Xs = /* @__PURE__ */ C(() => {
-  const o = p(Be.xy).add(st.fract().mul(1337)), e = ns(o);
-  return y(e, e.oneMinus(), e).sub(0.5).div(255);
-}).once()(), eo = (o, e, t = p(90, 45)) => {
-  const s = ot(o), n = nt(s), r = e.mul(n).mul(0.5), i = Ve(s.mul(t).fract().sub(0.5)).div(t), u = ze(r, r.add(n), i).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 rs extends E {
+class ho extends Q {
   constructor() {
-    super("vec3"), this.currentProjectionMatrix = v(new W()), this.previousProjectionMatrix = v("mat4"), this.currentModelViewMatrix = v(new W()), this.previousModelViewMatrix = v("mat4"), this.objectModelViewMatrices = /* @__PURE__ */ new WeakMap(), this.updateType = A.FRAME, this.updateBeforeType = A.OBJECT, this.updateAfterType = A.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";
   }
+  setProjectionMatrix(e) {
+    return this.projectionMatrix = e, this;
+  }
   // Executed once per frame:
   update({ camera: e }) {
     if (e == null)
       return;
     const {
       currentProjectionMatrix: t,
-      previousProjectionMatrix: s
+      previousProjectionMatrix: o
     } = this, n = this.projectionMatrix ?? e.projectionMatrix;
-    s.value == null ? s.value = new W().copy(n) : s.value.copy(t.value), t.value.copy(n);
+    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,
+      currentModelViewMatrix: o,
       previousModelViewMatrix: n,
-      objectModelViewMatrices: r
+      objectModelViewMatrices: i
     } = this;
-    s.value.multiplyMatrices(
+    o.value.multiplyMatrices(
       t.matrixWorldInverse,
       e.matrixWorld
-    ), n.value = r.get(e) ?? s.value;
+    ), n.value = i.get(e) ?? o.value;
   }
   // Executed once per object after rendering:
   updateAfter({ object: e }) {
@@ -454,18 +541,18 @@ class rs extends E {
       return;
     const {
       currentModelViewMatrix: t,
-      objectModelViewMatrices: s
+      objectModelViewMatrices: o
     } = this;
-    let n = s.get(e);
-    n == null && (n = new W(), s.set(e, n)), n.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(rt).toVertexStage(), s = this.previousProjectionMatrix.mul(this.previousModelViewMatrix).mul(it).toVertexStage(), n = t.xyz.div(t.w), r = s.xyz.div(s.w);
-    return k(n, r);
+    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 to = /* @__PURE__ */ at(rs);
-class is extends ae {
+const tt = /* @__PURE__ */ pt(ho);
+class po extends qe {
   static get type() {
     return "KawaseBlurNode";
   }
@@ -473,49 +560,49 @@ class is extends ae {
     super(e, t), this.resolutionScale = 0.5;
   }
   setupDownsampleNode(e) {
-    const { inputNode: t, inputTexelSize: s } = this;
-    x(t != null);
-    const n = V(), r = w(1, 1, -1, -1).mul(s.xyxy.mul(0.5)).add(n.xyxy).toVertexStage(), i = r.zy, u = r.xy, a = r.xw, h = r.zw;
-    return N(
+    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(i),
-      t.sample(u),
+      t.sample(r),
+      t.sample(c),
       t.sample(a),
       t.sample(h)
     ).mul(1 / 8);
   }
   setupUpsampleNode(e) {
-    const { inputNode: t, inputTexelSize: s } = this;
-    x(t != null);
-    const n = V(), r = w(1, 1, -1, -1).mul(s.xyxy.mul(0.5)).add(n.xyxy).toVertexStage(), i = r.zy, u = r.xy, a = r.xw, h = r.zw, c = p(r.z, n.y), l = p(r.x, n.y), d = p(n.x, r.y), m = p(n.x, r.w);
-    return N(
-      N(
-        t.sample(i),
-        t.sample(u),
+    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(c),
         t.sample(a),
         t.sample(h)
       ).mul(1 / 12),
-      N(
-        t.sample(c),
+      B(
         t.sample(l),
-        t.sample(d),
-        t.sample(m)
+        t.sample(u),
+        t.sample(p),
+        t.sample(d)
       ).mul(1 / 6)
     );
   }
 }
-const so = (...o) => new is(...o);
-class as extends E {
+const Vn = (...s) => new po(...s);
+class mo extends Q {
   constructor(e) {
-    super("vec3"), this.intensity = v(1e-5), this.inputNode = e;
+    super("vec3"), this.intensity = g(1e-5), this.inputNode = e;
   }
   static get type() {
     return "LensGhostNode";
   }
   setup(e) {
-    const { inputNode: t, intensity: s } = this;
-    x(t != null);
-    const n = K({
+    const { inputNode: t, intensity: o } = this;
+    y(t != null);
+    const n = V({
       name: "sampleGhost",
       type: "vec3",
       inputs: [
@@ -524,77 +611,33 @@ class as extends E {
         { name: "color", type: "vec3" },
         { name: "offset", type: "float" }
       ]
-    })(([a, h, c, l]) => {
-      const d = h.mul(l).add(a.oneMinus()).saturate(), m = t.sample(d).rgb.mul(c), f = k(0.5, d).length().mul(1 / (Math.SQRT2 / 4)).saturate();
-      return m.mulAssign(f.oneMinus().pow(3)), m;
-    }), r = V(), i = r.sub(0.5);
-    return N(
-      n(r, i, y(0.8, 0.8, 1), -5),
-      n(r, i, y(1, 0.8, 0.4), -1.5),
-      n(r, i, y(0.9, 1, 0.8), -0.4),
-      n(r, i, y(1, 0.8, 0.4), -0.2),
-      n(r, i, y(0.9, 0.7, 0.7), -0.1),
-      n(r, i, y(0.5, 1, 0.4), 0.7),
-      n(r, i, y(0.5, 0.5, 0.5), 1),
-      n(r, i, y(1, 1, 0.6), 2.5),
-      n(r, i, y(0.5, 0.8, 1), 10)
-    ).mul(s);
-  }
-}
-const { resetRendererState: us, restoreRendererState: ls } = O;
-function cs() {
-  const o = new kt(1, 1, {
-    depthBuffer: !1,
-    type: Et,
-    format: $t
-  }), e = o.texture;
-  return e.minFilter = he, e.magFilter = he, e.generateMipmaps = !1, o;
-}
-const hs = /* @__PURE__ */ new It();
-class Ge extends se {
-  constructor(e, t) {
-    const s = cs();
-    super(s.texture, t ?? V()), this.resolutionScale = 1, this.material = new P(), this.mesh = new q(this.material), this.node = e, this.renderTarget = s, this.updateBeforeType = A.FRAME;
-  }
-  static get type() {
-    return "RTTextureNode";
-  }
-  setSize(e, t) {
-    const { resolutionScale: s } = this, n = Math.max(Math.round(e * s), 1), r = Math.max(Math.round(t * s), 1);
-    return this.renderTarget.setSize(n, r), this;
-  }
-  updateBefore({ renderer: e }) {
-    if (e == null)
-      return;
-    const t = e.getDrawingBufferSize(hs);
-    this.setSize(t.x, t.y), this.rendererState = us(e, this.rendererState), e.setRenderTarget(this.renderTarget), this.mesh.render(e), ls(e, this.rendererState);
-  }
-  setup(e) {
-    const { material: t } = this;
-    return t.fragmentNode = this.node.context(e.getContext()), t.needsUpdate = !0, super.setup(e);
-  }
-  dispose() {
-    this.renderTarget.dispose(), this.material.dispose(), this.mesh.geometry.dispose(), super.dispose();
-  }
-  // @ts-expect-error Ignore
-  clone() {
-    const e = new se(this.value, this.uvNode, this.levelNode);
-    return e.sampler = this.sampler, e.referenceNode = this, e;
+    })(([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 = 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 ds = (...o) => new Ge(...o), Le = (o, e) => {
-  let t;
-  return o.isTextureNode === !0 || o.isSampleNode === !0 ? t = o : o.getTextureNode != null ? t = o.getTextureNode() : (t = new Ge(o), e != null && (t.value.name = e)), t;
-}, { resetRendererState: ps, restoreRendererState: ms } = O;
-function fs() {
-  const s = document.createElement("canvas");
-  s.width = 256, s.height = 32;
-  const n = s.getContext("2d");
-  x(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 r = n.createLinearGradient(0, 0, 256, 0);
-  return r.addColorStop(0, "#000000"), r.addColorStop(0.5, "#ffffff"), r.addColorStop(1, "#000000"), n.fillStyle = r, n.fill(), new Xe(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 ge = /* @__PURE__ */ oe({
+const st = /* @__PURE__ */ Ie({
   color: "vec3",
   luminance: "float",
   position: "vec2",
@@ -602,69 +645,71 @@ const ge = /* @__PURE__ */ oe({
   sin: "float",
   cos: "float"
 });
-class gs extends _ {
+class vo extends Re {
   constructor(e) {
-    super(e), this.spikePairCount = 6, this.wireframe = !1, this.intensity = v(1e-5), this.sizeScale = v(new z(1.5, 0.01)), this.luminanceThreshold = v(100), this.counterBuffer = new Ot(1, 1), this.instanceBuffer = ue(1, ge), this.renderTarget = this.createRenderTarget(), this.material = new Gt({
+    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: Ke
-    }), this.mesh = new J(new Je(1, 1), this.material), this.camera = new Ye(), this.inputTexelSize = v(new z()), this.outputTexelSize = v(new z()), this.geometryRatio = v(new z()), 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 Ie(this.spikePairCount, +this.wireframe);
+    return We(this.spikePairCount, +this.wireframe);
   }
   setSize(e, t) {
-    const { resolutionScale: s } = this, n = Math.max(Math.round(e * s), 1), r = Math.max(Math.round(t * s), 1);
-    this.renderTarget.setSize(n, r);
-    const i = Math.floor(n / 2), u = Math.floor(r / 2), a = i * u;
-    return this.instanceBuffer.bufferCount < a && (this.instanceBuffer.dispose(), this.instanceBuffer = ue(a, ge), this.setupCompute(i, 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;
-    x(t != null);
-    const { width: s, height: n } = t.value;
-    this.setSize(s, n);
-    const { computeNode: r, counterBuffer: i, renderTarget: u } = this;
-    x(r != null), this.inputTexelSize.value.set(1 / s, 1 / n);
-    const a = s / n;
+    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: h, height: c } = u;
-    this.outputTexelSize.value.set(1 / h, 1 / c), i.array[0] = 0, i.needsUpdate = !0, e.compute(r), e.getArrayBufferAsync(i).then((l) => {
-      this.mesh.count = new Uint32Array(l)[0];
-    }).catch((l) => {
-      console.error(l);
-    }), this.rendererState = ps(e, this.rendererState), e.setRenderTarget(u), e.render(this.mesh, this.camera), ms(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,
+      spikePairCount: o,
       inputNode: n,
-      counterBuffer: r,
-      instanceBuffer: i,
-      outputTexelSize: u
+      indirectBuffer: i,
+      instanceBuffer: r,
+      outputTexelSize: c
     } = this;
-    x(n != null);
-    const a = ut(
-      r,
+    y(n != null);
+    const a = ss(
+      i,
       "uint",
-      r.count
+      i.count
     ).toAtomic();
-    this.computeNode = C(() => {
-      const h = Ce(e, t);
-      F(X.xy.greaterThanEqual(h).any(), () => {
-        lt();
+    this.computeNode = U(() => {
+      const h = re(e, t);
+      ae(Ae.xy.greaterThanEqual(h).any(), () => {
+        os();
       });
-      const c = p(X.xy).mul(u).mul(2), l = n.sample(c), d = l.a;
-      F(d.greaterThan(0.1), () => {
-        const m = ct(a.element(0), s);
-        for (let f = 0; f < s; ++f) {
-          const g = i.element(m.add(f));
-          g.get("color").assign(l.rgb), g.get("luminance").assign(d), g.get("position").assign(X.xy), g.get("scale").assign(f % 2 === 0 ? 1 : 0.5);
-          const R = Math.PI * (3 - Math.sqrt(5)), S = Math.PI / s * f + R;
-          g.get("sin").assign(Math.sin(S)), g.get("cos").assign(Math.cos(S));
+      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(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));
         }
       });
     })().compute(
@@ -677,29 +722,29 @@ class gs extends _ {
     const {
       inputNode: e,
       spikeNode: t,
-      instanceBuffer: s,
+      instanceBuffer: o,
       luminanceThreshold: n,
-      intensity: r,
-      sizeScale: i,
-      outputTexelSize: u,
+      intensity: i,
+      sizeScale: r,
+      outputTexelSize: c,
       geometryRatio: a
     } = this;
-    x(e != null), x(t != null);
-    const h = s.element(ht);
-    this.material.colorNode = this.wireframe ? w(1) : t.mul(h.get("color").mul(r)), this.material.vertexNode = C(() => {
-      const c = h.get("sin"), l = h.get("cos"), d = Pe(l, c, 0, c.negate(), l, 0, 0, 0, 1), f = h.get("position").mul(u).mul(2), g = f.flipY().mul(2).sub(1), S = h.get("luminance").div(n).saturate(), B = p(S, 1).mul(
+    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"),
-        i,
+        r,
         // Make the spike to shrink at screen borders:
-        f.sub(0.5).length().mul(2).oneMinus().mul(0.5).add(0.5)
-      ), L = d.mul(be.mul(w(B, 1, 1))).mul(a).add(y(g, 0));
-      return w(L, 1);
+        m.sub(0.5).length().mul(2).oneMinus().mul(0.5).add(0.5)
+      ), 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 = fs();
-      t.colorSpace = _e, this.spikeNode = I(t);
+      const t = go();
+      t.colorSpace = ks, this.spikeNode = oe(t);
     }
     return this.setupMaterial(), super.setup(e);
   }
@@ -707,10 +752,10 @@ class gs extends _ {
     this.renderTarget.dispose(), this.material.dispose(), this.mesh.geometry.dispose(), super.dispose();
   }
 }
-const xs = /* @__PURE__ */ new z();
-class vs extends E {
+const yo = /* @__PURE__ */ new ve();
+class wo extends Q {
   constructor(e) {
-    super("vec3"), this.intensity = v(1e-5), this.chromaticAberration = v(5e-3), this.aspectRatio = v(0), this.inputNode = e, this.updateBeforeType = A.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";
@@ -718,13 +763,13 @@ class vs extends E {
   updateBefore({ renderer: e }) {
     if (e == null)
       return;
-    const { width: t, height: s } = e.getDrawingBufferSize(xs);
-    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: n, aspectRatio: r } = this;
-    x(t != null);
-    const i = K({
+    const { inputNode: t, intensity: o, chromaticAberration: n, aspectRatio: i } = this;
+    y(t != null);
+    const r = V({
       name: "cubicRingMask",
       type: "float",
       inputs: [
@@ -732,101 +777,101 @@ class vs extends E {
         { name: "radius", type: "float" },
         { name: "thickness", type: "float" }
       ]
-    })(([c, l, d]) => {
-      const m = dt(Ve(c.sub(l)).div(d), 1);
-      return pt(m, m, k(3, m.mul(2))).oneMinus();
-    }), u = K({
+    })(([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, l]) => {
-      const d = p(r, 1), m = c.sub(0.5).mul(d).normalize().div(d), f = y(n).mul(y(-1, 0, 1)), g = mt(m.mul(l).add(c.oneMinus())), R = y(
-        t.sample(m.mul(f.r).add(g)).r,
-        t.sample(m.mul(f.g).add(g)).g,
-        t.sample(m.mul(f.b).add(g)).b
-      ), S = c.sub(p(0.5, 0)).mul(d).add(p(0.5, 0)), B = ft(S, p(0.5)).saturate();
-      return R.mulAssign(i(B, 0.45, 0.25)), R;
-    }), a = V();
-    return u(a, 0.3).mul(s);
+    })(([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 = 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 b = (o) => o.greaterThanEqual(0).all().and(o.lessThanEqual(1).all()).toFloat();
-class We extends ae {
+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 = v(0.85), this.resolutionScale = 0.5;
+    super(e, t), this.blendAmount = g(0.85), this.resolutionScale = 0.5;
   }
   static get type() {
     return "MipmapSurfaceBlurNode";
   }
   setupDownsampleNode(e) {
-    const { inputNode: t, inputTexelSize: s } = this;
-    return x(t != null), C(() => {
-      const n = V(), r = w(1, 1, -1, -1).mul(s.xyxy).add(n.xyxy).toVertexStage(), i = w(2, 2, -2, -2).mul(s.xyxy).add(n.xyxy).toVertexStage(), u = r.zy, a = r.xy, h = r.zw, c = r.xw, l = i.zy, d = i.xy, m = i.zw, f = i.xw, g = p(n.x, i.y), R = p(i.z, n.y), S = p(i.x, n.y), B = p(n.x, i.w), L = 1 / 4 / 2, j = 1 / 9 / 2, U = t.sample(n).mul(j);
-      let M;
-      return M = w(
-        b(u),
-        b(a),
-        b(h),
-        b(c)
-      ).mul(L), U.addAssign(
-        t.sample(u).mul(M.x),
-        t.sample(a).mul(M.y),
-        t.sample(h).mul(M.z),
-        t.sample(c).mul(M.w)
-      ), M = w(
-        b(l),
-        b(d),
-        b(m),
-        b(f)
-      ).mul(j), U.addAssign(
-        t.sample(l).mul(M.x),
-        t.sample(d).mul(M.y),
-        t.sample(m).mul(M.z),
-        t.sample(f).mul(M.w)
-      ), M = w(
-        b(g),
-        b(R),
-        b(S),
-        b(B)
-      ).mul(j), U.addAssign(
-        t.sample(g).mul(M.x),
-        t.sample(R).mul(M.y),
-        t.sample(S).mul(M.z),
-        t.sample(B).mul(M.w)
-      ), U;
+    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: n } = this;
-    x(t != null);
-    const r = V(), i = w(1, 1, -1, -1).mul(s.xyxy).add(r.xyxy).toVertexStage(), u = p(r.x, i.y), a = p(i.z, r.y), h = p(i.x, r.y), c = p(r.x, i.w), l = i.zy, d = i.xy, m = i.zw, f = i.xw, g = N(
-      t.sample(r).mul(1 / 4),
-      N(
-        t.sample(u),
+    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),
+      B(
+        t.sample(c),
         t.sample(a),
         t.sample(h),
-        t.sample(c)
+        t.sample(l)
       ).mul(1 / 8),
-      N(
-        t.sample(l),
+      B(
+        t.sample(u),
+        t.sample(p),
         t.sample(d),
-        t.sample(m),
-        t.sample(f)
+        t.sample(m)
       ).mul(1 / 16)
     );
-    return te(n.sample(r), g, this.blendAmount);
+    return ne(n.sample(i), x, this.blendAmount);
   }
 }
-const oo = (...o) => new We(...o);
-function He(o) {
-  return (o instanceof Lt ? o.renderer.backend : "backend" in o ? o.backend : o).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 ys extends E {
+class To extends Q {
   constructor(e) {
-    super("vec4"), this.bloomIntensity = v(0.05), this.inputNode = e, this.thresholdNode = new Ee(), this.blurNode = new Oe(), this.ghostNode = new as(), this.haloNode = new vs(), this.bloomNode = new We(null, 8), this.glareNode = new gs(), this.featuresNode = ds(N(this.ghostNode, this.haloNode)), this.featuresNode.value.name = "LensFlareNode.Features", this.featuresNode.resolutionScale = 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";
@@ -834,82 +879,139 @@ class ys extends E {
   setup(e) {
     const {
       inputNode: t,
-      thresholdNode: s,
+      thresholdNode: o,
       blurNode: n,
-      ghostNode: r,
-      haloNode: i,
-      bloomNode: u,
+      ghostNode: i,
+      haloNode: r,
+      bloomNode: c,
       featuresNode: a,
       glareNode: h
     } = this;
-    x(t != null);
-    const c = s.getTextureNode(), l = n.getTextureNode();
-    s.inputNode = t, n.inputNode = c, r.inputNode = l, i.inputNode = l, u.inputNode = c, h.inputNode = c;
-    const d = u.getTextureNode().mul(this.bloomIntensity), m = h.getTextureNode();
-    return C(() => {
-      const f = t;
-      return f.addAssign(d), He(e) && f.addAssign(m), f.add(a);
+    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), 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 no = (o) => new ys(
-  o != null ? Le(o, "LensFlareNode.Input") : null
-), ro = /* @__PURE__ */ G(
-  (o, e, t, s) => {
-    const n = o.sub(t), r = Q(e, n), i = Q(n, n).sub(s.pow2()), u = r.pow2().sub(i).toVar(), a = p(-1);
-    return F(u.greaterThanEqual(0), () => {
-      const h = Y(u);
-      a.assign(p(r.negate().sub(h), r.negate().add(h)));
+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;
   }
-), ws = /* @__PURE__ */ oe(
-  { near: "vec4", far: "vec4" },
-  "raySpheresIntersections"
-), io = /* @__PURE__ */ G(
-  (o, e, t, s) => {
-    const n = o.sub(t), r = Q(e, n), i = Q(n, n).sub(s.pow2()), u = r.pow2().sub(i).toVar(), a = w(-1), h = w(-1);
-    return F(u.greaterThanEqual(0), () => {
-      const c = Y(u);
-      a.assign(r.negate().sub(c)), h.assign(r.negate().add(c));
-    }), ws(a, h);
-  }
-), ao = /* @__PURE__ */ G(
-  (o, e, t) => {
-    const s = o.div(t), n = e.div(t), r = n.dot(n), i = s.dot(n), u = s.dot(s), a = i.pow2().sub(r.mul(u.sub(1))).toVar(), h = p(-1);
-    return F(a.greaterThanEqual(0), () => {
-      const c = Y(a);
-      h.assign(p(i.negate().sub(c), i.negate().add(c)).div(r));
+), 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;
   }
-), Ts = {
-  float: ne,
-  int: H,
-  uint: zt,
-  bool: bt,
-  vec2: p,
-  ivec2: T,
-  uvec2: Ce,
-  bvec2: Rt,
-  vec3: y,
-  ivec3: Mt,
-  uvec3: St,
-  bvec3: Nt,
-  vec4: w,
-  ivec4: Tt,
-  uvec4: wt,
-  bvec4: yt,
-  mat2: vt,
-  mat3: Pe,
-  mat4: xt,
-  color: gt
-}, uo = Wt;
-function lo(o) {
-  return Ts[o];
+), Vo = {
+  float: G,
+  int: K,
+  uint: ms,
+  bool: Me,
+  vec2: f,
+  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 Ns extends Ht {
+class Po extends Nt {
   static get type() {
     return "OutputTexture3DNode";
   }
@@ -923,58 +1025,276 @@ class Ns extends Ht {
     return new this.constructor(this.owner, this.value);
   }
 }
-const co = (...o) => new Ns(...o), ho = /* @__PURE__ */ G(
-  (o, e) => {
-    const t = p(Ae(o)), s = t.reciprocal(), n = e.mul(t), r = n.sub(0.5).floor().add(0.5), i = n.sub(r), u = i.mul(i.mul(i.mul(0.5).oneMinus()).sub(0.5)), a = i.mul(i).mul(i.mul(1.5).sub(2.5)).add(1), h = i.mul(i.mul(k(2, i.mul(1.5))).add(0.5)), c = i.mul(i).mul(i.mul(0.5).sub(0.5)), l = a.add(h), d = h.div(a.add(h)), m = r.sub(1).mul(s), f = r.add(2).mul(s), g = r.add(d).mul(s);
-    return N(
-      o.sample(p(m.x, m.y)).mul(u.x).mul(u.y),
-      o.sample(p(g.x, m.y)).mul(l.x).mul(u.y),
-      o.sample(p(f.x, m.y)).mul(c.x).mul(u.y),
-      o.sample(p(m.x, g.y)).mul(u.x).mul(l.y),
-      o.sample(p(g.x, g.y)).mul(l.x).mul(l.y),
-      o.sample(p(f.x, g.y)).mul(c.x).mul(l.y),
-      o.sample(p(m.x, f.y)).mul(u.x).mul(c.y),
-      o.sample(p(g.x, f.y)).mul(l.x).mul(c.y),
-      o.sample(p(f.x, f.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)
+    );
+  }
+), D = 64;
+function Te(s) {
+  return Math.floor(Math.max(0, s) / D);
+}
+class Oo {
+  constructor() {
+    this.size = [0, 0, 0], this.offset = { x: 0, y: 0 };
+  }
+  copy(e) {
+    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 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 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 We(
+      this.camera?.id ?? -1,
+      this.mainLight?.id ?? -1,
+      this.sampleCount,
+      this.hardShadowSamples,
+      this.fadeOutSamples
     );
   }
-);
-function xe(o, e) {
-  let t = 1, s = 0;
-  for (; o > 0; )
-    t /= e, s += t * (o % e), o = Math.floor(o / e);
-  return s;
+  getTextureNode() {
+    return this.textureNode;
+  }
+  setSize(e, t) {
+    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 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: 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), 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, 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 - 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 *= D, m.offset.y *= D;
+    }
+    this.dispatchCount = p;
+  }
+  // See bend_sss_gpu.h
+  createComputeNode() {
+    const {
+      depthNode: e,
+      camera: t,
+      sampleCount: o,
+      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 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(), Z = ne(Y, X, te.div(D)).toVar(), q = A.sub(te).add($).toConst();
+      return { pixelXY: Z, pixelDistance: q, xyDelta: ee, xAxisMajor: W };
+    };
+    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));
+      }
+      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 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 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 Ge = a.oneMinus().toConst();
+      Z.assign(
+        Z.mul(a).add(Ge).saturate()
+      ), q.assign(
+        q.mul(a).add(Ge).saturate()
+      );
+      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.textureNode;
+  }
+  dispose() {
+    this.outputTexture.dispose();
+  }
+}
+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 $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 ve = /* @__PURE__ */ Array.from(
+const nt = /* @__PURE__ */ Array.from(
   { length: 16 },
-  (o, e) => new z(xe(e + 1, 2), xe(e + 1, 3))
-), Ss = (o, e, t, { perspective: s = !0, logarithmic: n = !1 } = {}) => n ? De(o, e, t) : s ? je(o, e, t) : Bt(o, e, t), ye = (o, e, t) => {
-  const s = De(o, e, t);
-  return Pt(s, e, t);
-}, po = (o, e, t) => {
-  const s = je(o, e, t);
-  return Fe(s, e, t);
-}, mo = (o, e, t, s, n) => {
-  const r = s.element(H(2)).element(H(3)), i = s.element(H(3)).element(H(3)), a = w(y(o.flipY(), e).mul(2).sub(1), 1).mul(t.mul(r).add(i));
-  return n.mul(a).xyz;
-}, we = [
-  /* @__PURE__ */ y(58.1375, 2.7747, 26.8183),
-  /* @__PURE__ */ y(-150.5666, 4.2109, -88.5066),
-  /* @__PURE__ */ y(130.5887, -14.0195, 109.0745),
-  /* @__PURE__ */ y(-42.3277, 4.8052, -60.1097),
-  /* @__PURE__ */ y(4.5974, 2.1856, 12.5925),
-  /* @__PURE__ */ y(0.1357, 0.0914, 0.1067)
-], Ms = (o) => we.slice(1).reduce((e, t) => t.add(o.mul(e)), we[0]), fo = (o, e, t, s) => {
-  const n = Ss(o, e, t, s);
-  return Ms(Fe(n, e, t));
-}, go = (o) => {
-  const e = k(0.5, o.x).mul(Vt), t = k(o.y, 0.5).mul(Ct), s = le(t);
-  return y(s.mul(le(e)), ce(t), s.mul(ce(e)));
-}, { resetRendererState: Rs, restoreRendererState: bs } = O;
-function zs(o) {
-  return o.isPerspectiveCamera === !0 || o.isOrthographicCamera === !0 || "updateProjectionMatrix" in o && "setViewOffset" in o && "clearViewOffset" in o;
+  (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 Bs = /* @__PURE__ */ K({
+const Xo = /* @__PURE__ */ V({
   name: "clipAABB",
   type: "vec4",
   inputs: [
@@ -983,105 +1303,103 @@ const Bs = /* @__PURE__ */ K({
     { name: "minColor", type: "vec4" },
     { name: "maxColor", type: "vec4" }
   ]
-})(([o, e, t, s]) => {
-  const n = s.rgb.add(t.rgb).mul(0.5), r = s.rgb.sub(t.rgb).mul(0.5).add(1e-7), i = e.sub(w(n, o.a)), a = i.xyz.div(r).abs(), h = Ue(a.x, a.y, a.z);
-  return Ut(
-    h.greaterThan(1),
-    w(n, o.a).add(i.div(h)),
-    e
-  );
-}), Te = [
-  /* @__PURE__ */ T(-1, -1),
-  /* @__PURE__ */ T(-1, 1),
-  /* @__PURE__ */ T(1, -1),
-  /* @__PURE__ */ T(1, 1),
-  /* @__PURE__ */ T(1, 0),
-  /* @__PURE__ */ T(0, -1),
-  /* @__PURE__ */ T(0, 1),
-  /* @__PURE__ */ T(-1, 0)
-], Vs = /* @__PURE__ */ G(
-  (o, e, t, s, n) => {
-    const r = t.toVar(), i = t.pow2().toVar();
-    for (const d of Te) {
-      const m = o.load(e.add(d));
-      r.addAssign(m), i.addAssign(m.pow2());
+})(([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],
+  [1, 1],
+  [1, 0],
+  [0, -1],
+  [0, 1],
+  [-1, 0]
+], Zo = /* @__PURE__ */ L(
+  (s, e, t, o, n) => {
+    const i = t.toVar(), r = t.pow2().toVar();
+    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 = ne(Te.length + 1), a = r.div(u), h = Y(i.div(u).sub(a.pow2()).max(0)).mul(n), c = a.sub(h), l = a.add(h);
-    return Bs(a.clamp(c, l), s, c, l);
-  }
-), Cs = [
-  /* @__PURE__ */ T(-1, -1),
-  /* @__PURE__ */ T(-1, 0),
-  /* @__PURE__ */ T(-1, 1),
-  /* @__PURE__ */ T(0, -1),
-  /* @__PURE__ */ T(0, 0),
-  /* @__PURE__ */ T(0, 1),
-  /* @__PURE__ */ T(1, -1),
-  /* @__PURE__ */ T(1, 0),
-  /* @__PURE__ */ T(1, 1)
-], Ps = /* @__PURE__ */ oe({
-  coord: "ivec2",
-  depth: "float"
-}), As = /* @__PURE__ */ G(
-  (o, e) => {
-    const t = ne(1), s = T(0);
-    for (const n of Cs) {
-      const r = e.add(n).toVar(), i = o.load(r).toVar();
-      F(i.r.lessThan(t), () => {
-        s.assign(r), t.assign(i.r);
+    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);
+  }
+), _o = [
+  [-1, -1],
+  [-1, 0],
+  [-1, 1],
+  [0, -1],
+  [0, 0],
+  [0, 1],
+  [1, -1],
+  [1, 0],
+  [1, 1]
+], Ko = /* @__PURE__ */ Ie({
+  closestCoord: "ivec2",
+  closestDepth: "float"
+}), 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 Ps(s, t);
+    return Ko(o, n);
+  }
+), 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);
   }
-), Ne = /* @__PURE__ */ new z(), Fs = /* @__PURE__ */ new et(1, 1);
-class Ds extends E {
-  constructor(e, t, s, n, r) {
-    if (super("vec4"), this.temporalAlpha = v(0.05), this.varianceGamma = v(1), this.velocityThreshold = v(0.1), this.depthError = v(1e-3), this.debugShowRejection = !1, this.resolveRT = this.createRenderTarget("Resolve"), this.historyRT = this.createRenderTarget("History"), this.resolveMaterial = new P(), this.copyMaterial = new P(), this.mesh = new q(), this.needsSyncPostProcessing = !1, this.needsClearHistory = !1, this.resolveNode = I(this.resolveRT.texture), this.historyNode = I(this.historyRT.texture), this.previousDepthNode = I(Fs), this.originalProjectionMatrix = new W(), this.jitterIndex = 0, this.velocityNodeImmutable = e, this.inputNode = t, this.depthNode = s, this.velocityNode = n, !zs(r))
+), 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 = r, this.textureNode = ke(this, this.resolveRT.texture), this.updateBeforeType = A.FRAME;
+    this.camera = n, this.textureNode = $e(this, this.resolveRT.texture);
   }
   static get type() {
     return "TemporalAntialiasNode";
   }
   customCacheKey() {
-    return Ie(this.camera.id, +this.debugShowRejection);
+    return We(this.camera.id, +this.debugShowRejection);
   }
   createRenderTarget(e) {
-    const t = new Se(1, 1, {
+    const t = new Mt(1, 1, {
       depthBuffer: !1,
-      type: Re,
-      format: Me
-    }), s = t.texture;
-    s.minFilter = Z, s.magFilter = Z, s.generateMipmaps = !1;
+      type: Ct,
+      format: zt
+    }), o = t.texture;
+    o.minFilter = ue, o.magFilter = ue, o.generateMipmaps = !1;
     const n = this.constructor.type;
-    return s.name = e != null ? `${n}.${e}` : n, t;
+    return o.name = e != null ? `${n}_${e}` : n, t;
   }
   getTextureNode() {
     return this.textureNode;
   }
-  setProjectionMatrix(e) {
-    const { velocityNodeImmutable: t } = this;
-    t != null && (t.projectionMatrix = e);
-  }
   setSize(e, t) {
-    const { resolveRT: s, historyRT: n } = this;
-    return (e !== n.width || t !== n.height) && (s.setSize(e, t), n.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(), e.setRenderTarget(this.historyRT), this.mesh.material = this.copyMaterial, this.mesh.render(e), this.needsClearHistory = !1;
+    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), this.setProjectionMatrix(this.originalProjectionMatrix);
-    const n = ve[this.jitterIndex], r = n.x - 0.5, i = n.y - 0.5;
-    s.setViewOffset(e, t, r, i, 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(), this.setProjectionMatrix(null), this.jitterIndex = (this.jitterIndex + 1) % ve.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;
@@ -1090,128 +1408,153 @@ class Ds extends E {
   updateBefore({ renderer: e }) {
     if (e == null)
       return;
-    const t = e.getDrawingBufferSize(Ne);
-    this.setSize(t.x, t.y), this.rendererState = Rs(e, this.rendererState), this.needsClearHistory && this.clearHistory(e), e.setRenderTarget(this.resolveRT), this.mesh.material = this.resolveMaterial, this.mesh.render(e), bs(e, this.rendererState), He(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: n } = this, r = n.load(T(s.mul(Ae(n)).sub(0.5))).toVar();
-      return e.logarithmicDepthBuffer ? ye(
-        r,
-        de(this.camera),
-        pe(this.camera)
-      ) : r;
+    const t = (o) => {
+      const { previousDepthNode: n } = this, i = n.load(O(o.mul(n.size()).sub(0.5))).toConst();
+      return e.logarithmicDepthBuffer ? Ue(
+        i,
+        fe(this.camera),
+        xe(this.camera)
+      ) : e.reversedDepthBuffer ? i.oneMinus() : i;
     };
-    return C(() => {
-      const s = T(Be), n = At, r = this.inputNode.load(s), i = As(this.depthNode, s), u = i.get("coord"), a = this.velocityNode.load(u).xyz.mul(y(0.5, -0.5, 0.5)).toVar(), h = a.xy.length().div(this.velocityThreshold).oneMinus().saturate(), c = n.sub(a.xy).toVar(), l = t(c), d = e.logarithmicDepthBuffer ? ye(
-        i.get("depth"),
-        de(this.camera),
-        pe(this.camera)
-      ) : i.get("depth"), m = Ft(
-        d.add(a.z),
-        l.add(this.depthError)
-      ), f = h.mul(m), g = Dt(
-        c.greaterThanEqual(0).all(),
-        c.lessThanEqual(1).all()
-      ).toFloat(), R = i.get("depth").notEqual(1).toFloat(), S = w(0).toVar();
-      return F(g.mul(R).mul(f).greaterThan(0), () => {
-        const B = I(this.historyNode, c), L = Vs(
+    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),
+        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,
-          r,
-          B,
+          o,
+          T,
+          C,
           this.varianceGamma
-        ), j = a.xy.abs().mul(jt), U = Ue(j.x, j.y).fract().mul(0.5), M = te(
+        ), R = ne(
           this.temporalAlpha,
-          0.8,
-          U
+          0.4,
+          Jo(a.xy, Ns(this.inputNode))
         ).saturate();
-        S.assign(te(L, r, M));
+        T.assign(ne(j, T, R));
       }).Else(() => {
-        S.assign(r), this.debugShowRejection && S.assign(y(1, 0, 0));
-      }), S;
+        this.debugShowRejection && T.assign(M(1, 0, 0));
+      }), T;
     })();
   }
   setup(e) {
-    const { context: t } = e.getContext().postProcessing ?? {};
-    if (t != null) {
-      const { onBeforePostProcessing: r } = t;
-      t.onBeforePostProcessing = () => {
-        r?.();
-        const i = e.renderer.getDrawingBufferSize(Ne);
-        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;
     }
-    const { resolveMaterial: s, copyMaterial: n } = this;
-    return s.fragmentNode = this.setupResolveNode(e), s.needsUpdate = !0, n.fragmentNode = this.inputNode, n.needsUpdate = !0, this.textureNode.uvNode = this.inputNode.uvNode, this.textureNode;
+    if (e.context.postProcessing != null) {
+      const { context: n } = e.context.postProcessing;
+      n.onBeforePostProcessing = t, this.needsSyncRenderPipeline = !0;
+    }
+    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.copyMaterial.dispose(), this.mesh.geometry.dispose(), super.dispose();
+    this.resolveRT.dispose(), this.historyRT.dispose(), this.previousDepthTexture?.dispose(), this.resolveMaterial.dispose(), this.mesh.geometry.dispose(), super.dispose();
   }
 }
-const xo = (o) => (e, t, s, n) => new Ds(
-  o,
-  Le(e, "TemporalAntialiasNode.Input"),
-  t,
-  s,
-  n
-);
+function Zn(...s) {
+  if (s.length === 1)
+    return (i, r, c, a) => new at(
+      Oe(i),
+      r,
+      c,
+      a
+    );
+  const [e, t, o, n] = s;
+  return new at(
+    Oe(e),
+    t,
+    o,
+    n
+  );
+}
 export {
-  Ee as DownsampleThresholdNode,
-  K as FnLayout,
-  G as FnVar,
-  Oe as GaussianBlurNode,
-  rs as HighpVelocityNode,
-  is as KawaseBlurNode,
-  ys as LensFlareNode,
-  Jt as MipmapBlurNode,
-  We as MipmapSurfaceBlurNode,
-  uo as Node,
-  Ns as OutputTexture3DNode,
-  qt as OutputTextureNode,
-  Ge as RTTextureNode,
-  Ds as TemporalAntialiasNode,
-  pe as cameraFar,
-  de as cameraNear,
-  Hs as cameraPositionWorld,
-  Le as convertToTexture,
-  qs as debugFragmentNode,
-  Qs as debugNode,
-  Zs as debugVertexNode,
-  fo as depthToColor,
-  Ss as depthToViewZ,
-  Xs as dithering,
-  Ys as downsampleThreshold,
-  eo as equirectGrid,
-  go as equirectToDirectionWorld,
-  _s as gaussianBlur,
-  to as highpVelocity,
-  Ks as hookFunction,
-  ns as interleavedGradientNoise,
-  Ls as inverseProjectionMatrix,
-  Ws as inverseViewMatrix,
-  He as isWebGPU,
-  so as kawaseBlur,
-  no as lensFlare,
-  ye as logarithmicToPerspectiveDepth,
-  Js as mipmapBlur,
-  $e as mipmapBlurDownsample,
-  Kt as mipmapBlurUpsample,
-  oo as mipmapSurfaceBlur,
-  lo as node,
-  ke as outputTexture,
-  co as outputTexture3D,
-  po as perspectiveToLogarithmicDepth,
-  Os as projectionMatrix,
-  ao as rayEllipsoidIntersection,
-  ro as raySphereIntersection,
-  io as raySpheresIntersections,
-  ws as raySpheresIntersectionsStruct,
-  ds as rtTexture,
-  mo as screenToPositionView,
-  xo as temporalAntialias,
-  ho as textureCatmullRom,
-  Ms as turbo,
-  Gs 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