shaders 2.2.0 → 2.2.2

package/dist/core/GlassTiles-5MyBj1ff.js

@@ -0,0 +1,53 @@
+import { k as b, m as R } from "./three.tsl-BqgDcRt9.js";
+R();
+const V = {
+  name: "GlassTiles",
+  category: "Distortions",
+  description: "Refraction-like distortion in a tile grid pattern",
+  requiresRTT: !0,
+  requiresChild: !0,
+  props: {
+    intensity: {
+      default: 1,
+      description: "The intensity of the glass tiles effect",
+      ui: {
+        type: "range",
+        min: 0,
+        max: 5,
+        step: 0.1,
+        label: "Intensity"
+      }
+    },
+    tileCount: {
+      default: 100,
+      description: "Number of tiles across the shortest dimension",
+      ui: {
+        type: "range",
+        min: 1,
+        max: 200,
+        step: 1,
+        label: "Tile Count"
+      }
+    }
+  },
+  uvTransformNode: ({ uv: o, uniforms: s, viewportSize: i }) => {
+    const { vec2: r, floor: a, select: l } = b, p = s.intensity.uniform, t = s.tileCount.uniform, e = i.x.div(i.y), n = r(l(e.greaterThanEqual(1), t.mul(e), t), l(e.lessThan(1), t.div(e), t)), c = a(o.mul(n)).div(n), d = o.sub(c), T = r(0.5, 0.5), h = p.mul(0.025), u = d.div(r(1, 1).div(n)).sub(T).mul(h);
+    return d.add(u).add(c);
+  },
+  fragmentNode: ({ uniforms: o, childNode: s, dimensions: i, onCleanup: r }) => {
+    const { vec2: a, vec4: l, floor: p, mul: t, div: e, sub: n, add: c, screenUV: d, uniform: T, convertToTexture: h } = b;
+    if (!s)
+      return console.error("You must pass a child component into the Glass Tiles shader."), l(0);
+    const u = h(s);
+    r(() => {
+      u?.renderTarget?.dispose && u.renderTarget.dispose();
+    });
+    const m = T(i.width / i.height), g = d, x = o.intensity.uniform, f = o.tileCount.uniform, C = a(m.greaterThanEqual(1).select(t(f, m), f), m.lessThan(1).select(e(f, m), f)), v = e(p(t(g, C)), C), y = n(g, v), U = a(0.5, 0.5), _ = t(x, 0.025), q = c(c(y, t(n(e(y, e(a(1), C)), U), _)), v);
+    return l(u.sample(q));
+  }
+};
+var N = V;
+export {
+  V as n,
+  N as t
+};

package/dist/core/{Glow-BD0t9E1L.js → Glow-DvJj7BB7.js}

@@ -1,8 +1,9 @@
-import { O as U, m as k } from "./three.tsl-CgyjOhns.js";
-k();
+import { k as U, m as j } from "./three.tsl-BqgDcRt9.js";
+j();
 const B = {
   name: "Glow",
-  category: "Effects",
+  category: "Stylize",
+  description: "Soft glow effect with adjustable intensity",
   requiresRTT: !0,
   requiresChild: !0,
   props: {
@@ -41,26 +42,26 @@ const B = {
     }
   },
   fragmentNode: ({ uniforms: s, childNode: a, onCleanup: g }) => {
-    const { vec2: c, vec3: h, vec4: r, float: t, max: d, dot: w, screenUV: f, convertToTexture: b, viewportSize: x, Fn: y } = U;
+    const { vec2: c, vec3: h, vec4: r, float: t, max: d, dot: w, screenUV: f, convertToTexture: b, viewportSize: y, Fn: x } = U;
     if (!a) return r(0, 0, 0, 0);
     const o = b(a);
     g(() => {
       o?.renderTarget?.dispose && o.renderTarget.dispose();
     });
-    const u = o.sample(f), v = y(() => {
-      const z = s.size.uniform, G = s.threshold.uniform, S = c(1).div(x), n = r(0, 0, 0, 0).toVar(), e = 5;
+    const u = o.sample(f), v = x(() => {
+      const z = s.size.uniform, S = s.threshold.uniform, G = c(1).div(y), n = r(0, 0, 0, 0).toVar(), e = 5;
       for (let i = -e; i <= e; i++) for (let l = -e; l <= e; l++) {
-        const C = c(t(i), t(l)).mul(S).mul(z), V = f.add(C), p = o.sample(V), q = w(p.rgb, h(0.299, 0.587, 0.114)), E = d(t(0), q.sub(G)), R = p.mul(E);
+        const C = c(t(i), t(l)).mul(G).mul(z), V = f.add(C), m = o.sample(V), k = w(m.rgb, h(0.299, 0.587, 0.114)), q = d(t(0), k.sub(S)), R = m.mul(q);
         n.assign(n.add(R));
       }
       const _ = t((e * 2 + 1) * (e * 2 + 1));
       return n.div(_);
-    })(), T = s.intensity.uniform, m = v.mul(T);
-    return r(u.rgb.add(m.rgb), d(u.a, m.a));
+    })(), T = s.intensity.uniform, p = v.mul(T);
+    return r(u.rgb.add(p.rgb), d(u.a, p.a));
   }
 };
-var F = B;
+var E = B;
 export {
   B as n,
-  F as t
+  E as t
 };

package/dist/core/{Godrays-CPIAbymT.js → Godrays-cUzAKVXn.js}

@@ -1,17 +1,19 @@
-import { O as U, m as q, t as A } from "./three.tsl-CgyjOhns.js";
-import { o as L, r as _ } from "./transformations-Bs66Qh16.js";
-q();
-const M = {
+import { k as A, m as E, t as M } from "./three.tsl-BqgDcRt9.js";
+import { o as j, r as _ } from "./transformations-DBjTkQ5b.js";
+E();
+const z = {
   name: "Godrays",
-  category: "Effects",
+  category: "Base Layers",
+  description: "Volumetric light rays emanating from a point",
   requiresRTT: !1,
+  acceptsUVContext: !0,
   props: {
     center: {
       default: {
         x: 0,
         y: 0
       },
-      transform: L,
+      transform: j,
       description: "The center point of the god rays",
       ui: {
         type: "position",
@@ -81,24 +83,24 @@ const M = {
       }
     }
   },
-  fragmentNode: ({ uniforms: s }) => {
-    const { vec2: c, vec4: R, float: a, sin: T, atan2: v, length: D, pow: h, smoothstep: P, mix: m, clamp: x, screenUV: S, time: w, PI: B, Fn: b } = U, E = c(s.center.uniform.x, s.center.uniform.y.oneMinus()), d = S.sub(E), C = b(([n]) => {
-      const t = n.floor(), e = n.fract(), o = (u) => T(u.x.mul(127.1).add(u.y.mul(311.7))).mul(43758.5453).fract(), l = o(t), r = o(t.add(c(1, 0))), y = o(t.add(c(0, 1))), p = o(t.add(c(1, 1))), i = e.mul(e).mul(e.mul(-2).add(3));
-      return m(m(l, r, i.x), m(y, p, i.x), i.y);
-    }), f = b(([n, t, e, o]) => {
-      const l = v(n.y, n.x), r = c(l.mul(e), t), y = c(l.mod(B.mul(2)).mul(e), t), p = h(C(r), o);
+  fragmentNode: ({ uniforms: e, uvContext: v }) => {
+    const { vec2: i, vec4: R, float: a, sin: T, atan2: B, length: D, pow: h, smoothstep: P, mix: m, clamp: x, screenUV: S, time: U, PI: w, Fn: g } = A, F = v ?? S, G = i(e.center.uniform.x, e.center.uniform.y.oneMinus()), d = F.sub(G), C = g(([n]) => {
+      const t = n.floor(), s = n.fract(), o = (u) => T(u.x.mul(127.1).add(u.y.mul(311.7))).mul(43758.5453).fract(), l = o(t), r = o(t.add(i(1, 0))), y = o(t.add(i(0, 1))), p = o(t.add(i(1, 1))), c = s.mul(s).mul(s.mul(-2).add(3));
+      return m(m(l, r, c.x), m(y, p, c.x), c.y);
+    }), f = g(([n, t, s, o]) => {
+      const l = B(n.y, n.x), r = i(l.mul(s), t), y = i(l.mod(w.mul(2)).mul(s), t), p = h(C(r), o);
       return m(h(C(y), o), p, P(-0.15, 0.15, n.x));
-    }), k = b(() => {
-      const n = w.mul(s.speed.uniform).mul(0.2), t = D(d), e = a(6.5).mul(A(s.spotty.uniform)), o = a(4).sub(a(3).mul(x(s.intensity.uniform, 0, 1))), l = a(6).mul(s.density.uniform), r = a(0).toVar(), y = t.mul(1).sub(n.mul(3)), p = t.mul(0.5).mul(a(1).add(e)).sub(n.mul(2)), i = l.mul(5), u = f(d, y, i, o).toVar();
-      u.assign(u.mul(f(d, p, i.mul(4), o))), r.assign(r.add(u));
-      const I = t.mul(1.4).sub(n.mul(2.5)), N = t.mul(0.7).mul(a(1).add(e)).sub(n.mul(1.8)), V = l.mul(4.5), g = f(d, I, V, o).toVar();
-      return g.assign(g.mul(f(d, N, V.mul(3.5), o))), r.assign(r.add(g.mul(0.7))), x(r, 0, 1);
-    })(), F = s.rayColor.uniform.rgb, G = s.backgroundColor.uniform.rgb;
-    return R(m(G, F, k), s.backgroundColor.uniform.a.add(k.mul(s.rayColor.uniform.a)));
+    }), k = g(() => {
+      const n = U.mul(e.speed.uniform).mul(0.2), t = D(d), s = a(6.5).mul(M(e.spotty.uniform)), o = a(4).sub(a(3).mul(x(e.intensity.uniform, 0, 1))), l = a(6).mul(e.density.uniform), r = a(0).toVar(), y = t.mul(1).sub(n.mul(3)), p = t.mul(0.5).mul(a(1).add(s)).sub(n.mul(2)), c = l.mul(5), u = f(d, y, c, o).toVar();
+      u.assign(u.mul(f(d, p, c.mul(4), o))), r.assign(r.add(u));
+      const N = t.mul(1.4).sub(n.mul(2.5)), q = t.mul(0.7).mul(a(1).add(s)).sub(n.mul(1.8)), V = l.mul(4.5), b = f(d, N, V, o).toVar();
+      return b.assign(b.mul(f(d, q, V.mul(3.5), o))), r.assign(r.add(b.mul(0.7))), x(r, 0, 1);
+    })(), I = e.rayColor.uniform.rgb, L = e.backgroundColor.uniform.rgb;
+    return R(m(L, I, k), e.backgroundColor.uniform.a.add(k.mul(e.rayColor.uniform.a)));
   }
 };
-var z = M;
+var K = z;
 export {
-  M as n,
-  z as t
+  z as n,
+  K as t
 };

package/dist/core/{Grayscale-BtOqK43k.js → Grayscale-oWIF3PV5.js}

@@ -1,9 +1,10 @@
-import { O as o, m as s } from "./three.tsl-CgyjOhns.js";
+import { k as o, m as s } from "./three.tsl-BqgDcRt9.js";
 import { t as a } from "./ColorAdjustment-CKwpE_4M.js";
 s();
 const n = {
   name: "Grayscale",
-  category: "Color Adjustments",
+  category: "Adjustments",
+  description: "Convert colors to black and white",
   requiresChild: !0,
   props: {},
   fragmentNode: ({ childNode: e }) => {

package/dist/core/Grid-Bov7AA9m.js

@@ -0,0 +1,51 @@
+import { k as b, m as T } from "./three.tsl-BqgDcRt9.js";
+import { r as _ } from "./transformations-DBjTkQ5b.js";
+T();
+const C = {
+  name: "Grid",
+  category: "Base Layers",
+  description: "Simple grid lines pattern with adjustable thickness",
+  acceptsUVContext: !0,
+  props: {
+    color: {
+      default: "#ffffff",
+      transform: _,
+      description: "The color of the grid lines",
+      ui: {
+        type: "color",
+        label: "Color"
+      }
+    },
+    cells: {
+      default: 10,
+      description: "Number of cells along the shortest canvas edge (creates square cells)",
+      ui: {
+        type: "range",
+        min: 1,
+        max: 50,
+        step: 1,
+        label: "Cells"
+      }
+    },
+    thickness: {
+      default: 1,
+      description: "Thickness of grid lines (normalized, 0.0-1.0)",
+      ui: {
+        type: "range",
+        min: 0,
+        max: 5,
+        step: 0.1,
+        label: "Thickness"
+      }
+    }
+  },
+  fragmentNode: ({ uniforms: e, uvContext: l }) => {
+    const { vec2: a, vec4: d, fract: m, max: p, screenUV: f, viewportSize: o, fwidth: u, smoothstep: n } = b, i = l ?? f, h = o.x.div(o.y), g = a(i.x.mul(h), i.y.oneMinus()), x = e.cells.uniform, r = g.mul(x), t = m(r), s = e.thickness.uniform.mul(0.01), y = t.x.min(t.x.oneMinus()), k = t.y.min(t.y.oneMinus()), c = u(r), v = p(n(s.add(c.x), s, y), n(s.add(c.y), s, k));
+    return d(e.color.uniform.rgb, e.color.uniform.a.mul(v));
+  }
+};
+var V = C;
+export {
+  C as n,
+  V as t
+};

package/dist/core/GridDistortion-CWYom5Dw.js

@@ -0,0 +1,148 @@
+import { O as $, k as B, m as J } from "./three.tsl-BqgDcRt9.js";
+import { t as K } from "./edges-B-tVdqcI.js";
+import { a as Q } from "./transformations-DBjTkQ5b.js";
+import { DataTexture as ee, FloatType as te, LinearFilter as C, RGFormat as ae } from "three";
+J();
+var ie = 20, f = /* @__PURE__ */ new WeakMap(), re = (e) => {
+  let t = f.get(e);
+  const s = e?.gridSize?.uniform?.value ? Math.max(8, Math.min(128, Math.floor(e.gridSize.uniform.value))) : ie;
+  if (t && t.gridSize !== s && (t.texture.dispose(), t = void 0, f.delete(e)), !t) {
+    const l = new Float32Array(s * s * 2), n = new ee(l, s, s, ae, te);
+    n.magFilter = C, n.minFilter = C, n.needsUpdate = !0, t = {
+      texture: n,
+      data: l,
+      tslNode: $(n),
+      gridSize: s
+    }, f.set(e, t);
+  }
+  return t;
+};
+const se = {
+  name: "GridDistortion",
+  category: "Interactive",
+  description: "Interactive grid distortion controlled by mouse position",
+  requiresRTT: !0,
+  requiresChild: !0,
+  props: {
+    intensity: {
+      default: 1,
+      description: "Strength of the distortion effect",
+      ui: {
+        type: "range",
+        min: 0,
+        max: 5,
+        step: 0.1,
+        label: "Intensity"
+      }
+    },
+    swirl: {
+      default: 0,
+      description: "Amount of swirl motion",
+      ui: {
+        type: "range",
+        min: 0,
+        max: 2,
+        step: 0.1,
+        label: "Swirl"
+      }
+    },
+    decay: {
+      default: 3,
+      description: "Rate of distortion decay (higher = faster)",
+      ui: {
+        type: "range",
+        min: 0,
+        max: 10,
+        step: 0.1,
+        label: "Decay"
+      }
+    },
+    radius: {
+      default: 1,
+      description: "Radius of the distortion effect",
+      ui: {
+        type: "range",
+        min: 0,
+        max: 3,
+        step: 0.01,
+        label: "Radius"
+      }
+    },
+    gridSize: {
+      default: 20,
+      description: "Resolution of the distortion grid (higher = more detailed)",
+      ui: {
+        type: "range",
+        min: 8,
+        max: 128,
+        step: 1,
+        label: "Grid Size"
+      }
+    },
+    edges: {
+      default: "stretch",
+      description: "How to handle edges when distortion pushes content out of bounds",
+      transform: Q,
+      ui: {
+        type: "select",
+        options: [
+          {
+            label: "Stretch",
+            value: "stretch"
+          },
+          {
+            label: "Transparent",
+            value: "transparent"
+          },
+          {
+            label: "Mirror",
+            value: "mirror"
+          },
+          {
+            label: "Wrap",
+            value: "wrap"
+          }
+        ],
+        label: "Edges"
+      }
+    }
+  },
+  fragmentNode: ({ uniforms: e, onBeforeRender: t, childNode: s, onCleanup: l }) => {
+    const { vec2: n, vec4: k, float: g, uniform: T, screenUV: w, convertToTexture: H } = B, { texture: z, data: a, tslNode: L, gridSize: d } = re(e), h = T(0), v = T(0);
+    let F = 0.5, I = 0.5, R = Date.now();
+    if (t(({ pointer: o }) => {
+      const G = Date.now(), i = Math.min((G - R) / 1e3, 0.016);
+      R = G;
+      const V = i > 0 ? (o.x - F) / i : 0, X = i > 0 ? (o.y - I) / i : 0;
+      h.value = h.value * 0.85 + V * 0.15, v.value = v.value * 0.85 + X * 0.15;
+      const Y = e.decay.uniform.value, q = e.intensity.uniform.value, y = e.radius.uniform.value * 0.05, M = e.swirl.uniform.value;
+      for (let u = 0; u < d; u++) for (let m = 0; m < d; m++) {
+        const r = (u * d + m) * 2;
+        a[r] *= 1 - Y * i, a[r + 1] *= 1 - Y * i;
+        const j = (m + 0.5) / d, P = (u + 0.5) / d, S = j - o.x, b = P - o.y, D = Math.sqrt(S * S + b * b);
+        if (D < y * 2 && Math.abs(V) + Math.abs(X) > 0.01) {
+          const p = Math.exp(-D * D / (y * y));
+          if (a[r] += h.value * p * q * i * 0.5, a[r + 1] += v.value * p * q * i * 0.5, M > 0) {
+            const A = Math.atan2(b, S) + Math.PI * 0.5;
+            a[r] += Math.cos(A) * M * p * i * 2, a[r + 1] += Math.sin(A) * M * p * i * 2;
+          }
+        }
+        a[r] = Math.max(-1, Math.min(1, a[r])), a[r + 1] = Math.max(-1, Math.min(1, a[r + 1]));
+      }
+      z.needsUpdate = !0, F = o.x, I = o.y;
+    }), l(() => {
+      z.dispose(), f.delete(e);
+    }), !s) return k(0, 0, 0, 0);
+    const c = H(s);
+    l(() => {
+      c?.renderTarget?.dispose && c.renderTarget.dispose();
+    });
+    const N = e.gridSize.uniform, x = g(1).div(N), O = w.div(x).floor().mul(x).add(x.mul(0.5)), W = L.sample(O).xy, _ = g(0.1), U = g(-0.1), Z = W.clamp(n(U, U), n(_, _)), E = w.sub(Z);
+    return K(E, c.sample(E), c, e.edges.uniform);
+  }
+};
+var ce = se;
+export {
+  se as n,
+  ce as t
+};

package/dist/core/Group-CPk-7fiA.js

@@ -0,0 +1,18 @@
+import { k as r, m as o } from "./three.tsl-BqgDcRt9.js";
+o();
+const i = {
+  name: "Group",
+  category: "Utilities",
+  description: "Container for organizing and composing child effects",
+  requiresChild: !0,
+  props: {},
+  fragmentNode: ({ childNode: e }) => {
+    const { vec4: t } = r;
+    return e || t(0);
+  }
+};
+var s = i;
+export {
+  i as n,
+  s as t
+};

package/dist/core/{Halftone-B_MuXCD8.js → Halftone-F7fsdu7W.js}

@@ -1,9 +1,10 @@
-import { O as A, m as D } from "./three.tsl-CgyjOhns.js";
-import { n as E } from "./transformations-Bs66Qh16.js";
-D();
+import { k as V, m as A } from "./three.tsl-BqgDcRt9.js";
+import { n as D } from "./transformations-DBjTkQ5b.js";
+A();
 const F = {
   name: "Halftone",
-  category: "Effects",
+  category: "Stylize",
+  description: "Halftone dot pattern effect for printing aesthetics",
   requiresChild: !0,
   props: {
     frequency: {
@@ -19,7 +20,7 @@ const F = {
     },
     angle: {
       default: 45,
-      transform: E,
+      transform: D,
       description: "Rotation angle of the pattern (in degrees)",
       ui: {
         type: "range",
@@ -42,14 +43,14 @@ const F = {
     }
   },
   fragmentNode: ({ uniforms: t, childNode: s }) => {
-    const { vec2: e, vec3: p, vec4: r, sin: h, cos: y, fract: b, length: v, smoothstep: x, dot: n, screenUV: q, viewportSize: a, radians: _ } = A;
+    const { vec2: e, vec3: g, vec4: r, sin: h, cos: y, fract: b, length: v, smoothstep: x, dot: n, screenUV: q, viewportSize: a, radians: _ } = V;
     if (!s) return r(0);
-    const c = q, C = t.frequency.uniform, S = t.angle.uniform, i = t.smoothness.uniform, l = _(S), U = a.x.div(a.y), m = e(c.x.mul(U), c.y), u = y(l), f = h(l), V = b(e(n(m, e(u, f.negate())), n(m, e(f, u))).mul(C)).sub(0.5), o = s, d = n(o.rgb, p(0.299, 0.587, 0.114)).mul(0.7).add(0.15), z = v(V), g = x(d.add(i), d.sub(i), z);
-    return r(o.rgb.mul(g), o.a.mul(g));
+    const i = q, S = t.frequency.uniform, z = t.angle.uniform, c = t.smoothness.uniform, l = _(z), C = a.x.div(a.y), m = e(i.x.mul(C), i.y), f = y(l), d = h(l), H = b(e(n(m, e(f, d.negate())), n(m, e(d, f))).mul(S)).sub(0.5), o = s, u = n(o.rgb, g(0.299, 0.587, 0.114)).mul(0.7).add(0.15), U = v(H), p = x(u.add(c), u.sub(c), U);
+    return r(o.rgb.mul(p), o.a.mul(p));
   }
 };
-var O = F;
+var E = F;
 export {
   F as n,
-  O as t
+  E as t
 };

package/dist/core/{HueShift-CKG9M-d2.js → HueShift-CiS4hdtk.js}

@@ -1,9 +1,10 @@
-import { O as s, m as n } from "./three.tsl-CgyjOhns.js";
+import { k as s, m as n } from "./three.tsl-BqgDcRt9.js";
 import { n as i } from "./ColorAdjustment-CKwpE_4M.js";
 n();
 const a = {
   name: "HueShift",
-  category: "Color Adjustments",
+  category: "Adjustments",
+  description: "Rotate hue around the color wheel",
   requiresChild: !0,
   props: { shift: {
     default: 0,

package/dist/core/{ImageTexture-B6zFP2fB.js → ImageTexture-B3Q29OHX.js}

@@ -1,12 +1,14 @@
-import { C as ee, I as te, O as oe, U as ae, V as S, W as ne, b as x, k as y, m as se } from "./three.tsl-CgyjOhns.js";
-se();
-te();
-const ie = {
+import { A as S, C as oe, G as ae, H as x, L as ne, W as se, b as y, k as ie, m as le } from "./three.tsl-BqgDcRt9.js";
+le();
+ne();
+const ce = {
   name: "ImageTexture",
-  category: "Sources",
+  category: "Base Layers",
+  description: "Display an image with customizable object-fit modes",
+  acceptsUVContext: !0,
   props: {
     url: {
-      default: "https://shaders.com/og.png",
+      default: "https://shaders.com/sample.jpg",
       description: "Upload an image or provide a URL",
       ui: {
         type: "image-upload",
@@ -51,12 +53,12 @@ const ie = {
       }
     }
   },
-  fragmentNode: ({ uniforms: m, onCleanup: L, onBeforeRender: W }) => {
-    const { vec2: o, vec4: D, float: t, texture: A, screenUV: N, viewportSize: c, step: a, min: u, max: O } = oe, H = new ne();
+  fragmentNode: ({ uniforms: m, onCleanup: _, onBeforeRender: D, uvContext: W }) => {
+    const { vec2: o, vec4: A, float: t, texture: H, screenUV: N, viewportSize: c, step: a, min: u, max: z } = ie, B = W ?? N, O = new ae();
     let T = "", r = !1;
-    const n = new ae();
-    n.colorSpace = S;
-    const $ = A(n), s = y(1), f = y(0), w = y(0), V = (e) => {
+    const n = new se();
+    n.colorSpace = x;
+    const $ = H(n), s = S(1), f = S(0), w = S(0), V = (e) => {
       if (!(!e || e.trim() === "" || r)) {
         r = !0;
         try {
@@ -65,12 +67,12 @@ const ie = {
             h = new URL(e, window.location.href).href;
           } catch {
           }
-          H.load(e, (d) => {
-            d.colorSpace = S;
-            const p = d.image, U = p.width || 1, b = p.height || 1, Z = U / b;
+          O.load(e, (d) => {
+            d.colorSpace = x;
+            const p = d.image, U = p.width || 1, b = p.height || 1, te = U / b;
             d.dispose(), T = e, requestAnimationFrame(() => {
               const g = n.image;
-              g && typeof g == "object" && (g.width !== U || g.height !== b) && n.dispose(), s.value = Z, f.value = U, w.value = b, n.image = p, n.colorSpace = S, n.needsUpdate = !0;
+              g && typeof g == "object" && (g.width !== U || g.height !== b) && n.dispose(), s.value = te, f.value = U, w.value = b, n.image = p, n.colorSpace = x, n.needsUpdate = !0;
             }), r = !1;
           }, void 0, (d) => {
             const p = !e.startsWith("http://") && !e.startsWith("https://") && !e.startsWith("data:");
@@ -88,18 +90,18 @@ const ie = {
     setTimeout(() => {
       const e = m?.url?.uniform?.value ?? "";
       e && e.trim() !== "" && V(e);
-    }, 0), W(() => {
+    }, 0), D(() => {
       const e = m?.url?.uniform?.value ?? "";
       e !== T && !r && V(e);
-    }), L(() => {
+    }), _(() => {
       n.dispose();
     });
-    const q = N, l = c.x.div(c.y), i = m.objectFit.uniform, F = O(l.div(s), t(1)), z = o(s.div(l).mul(F), F), I = u(l.div(s), t(1)), B = o(s.div(l).mul(I), I), E = o(1, 1), R = u(u(l.div(s), t(1)), u(c.x.div(f), c.y.div(w))), k = o(s.div(l).mul(R), R), C = u(c.x.div(f), c.y.div(w)), G = o(s.div(l).mul(C), C), M = a(i, t(0.5)), P = a(t(0.5), i).mul(a(i, t(1.5))), J = a(t(1.5), i).mul(a(i, t(2.5))), K = a(t(2.5), i).mul(a(i, t(3.5))), Q = a(t(3.5), i), X = o(0).add(z.mul(M)).add(B.mul(P)).add(E.mul(J)).add(k.mul(K)).add(G.mul(Q)), _ = q.sub(o(0.5)).div(X).add(o(0.5)), v = o(_.x, t(1).sub(_.y)), j = $.sample(v), Y = x(x(v.x.lessThan(0), v.x.greaterThan(1)), x(v.y.lessThan(0), v.y.greaterThan(1)));
-    return D(j.rgb, ee(Y, t(0), j.a));
+    const q = B, l = c.x.div(c.y), i = m.objectFit.uniform, j = z(l.div(s), t(1)), E = o(s.div(l).mul(j), j), C = u(l.div(s), t(1)), G = o(s.div(l).mul(C), C), k = o(1, 1), F = u(u(l.div(s), t(1)), u(c.x.div(f), c.y.div(w))), M = o(s.div(l).mul(F), F), L = u(c.x.div(f), c.y.div(w)), P = o(s.div(l).mul(L), L), J = a(i, t(0.5)), K = a(t(0.5), i).mul(a(i, t(1.5))), Q = a(t(1.5), i).mul(a(i, t(2.5))), X = a(t(2.5), i).mul(a(i, t(3.5))), Y = a(t(3.5), i), Z = o(0).add(E.mul(J)).add(G.mul(K)).add(k.mul(Q)).add(M.mul(X)).add(P.mul(Y)), R = q.sub(o(0.5)).div(Z).add(o(0.5)), v = o(R.x, t(1).sub(R.y)), I = $.sample(v), ee = y(y(v.x.lessThan(0), v.x.greaterThan(1)), y(v.y.lessThan(0), v.y.greaterThan(1)));
+    return A(I.rgb, oe(ee, t(0), I.a));
   }
 };
-var ce = ie;
+var de = ce;
 export {
-  ie as n,
-  ce as t
+  ce as n,
+  de as t
 };

package/dist/core/Invert-Cyc4JHWc.js

@@ -0,0 +1,21 @@
+import { k as a, m as i } from "./three.tsl-BqgDcRt9.js";
+i();
+const c = {
+  name: "Invert",
+  category: "Adjustments",
+  description: "Invert RGB colors while preserving alpha",
+  requiresChild: !0,
+  props: {},
+  fragmentNode: ({ childNode: r }) => {
+    const { vec4: t, vec3: n } = a;
+    if (!r)
+      return console.error("You must pass a child component into the Invert shader."), t(0);
+    const o = r || t(0, 0, 0, 0), e = o.a, s = e.greaterThan(0).select(o.rgb.div(e), n(0, 0, 0));
+    return t(n(1, 1, 1).sub(s).mul(e), e);
+  }
+};
+var p = c;
+export {
+  c as n,
+  p as t
+};

package/dist/core/{LinearBlur-JFLMQBY4.js → LinearBlur-BTC54qzk.js}

@@ -1,9 +1,10 @@
-import { O as q, m as w } from "./three.tsl-CgyjOhns.js";
-import { n as A } from "./transformations-Bs66Qh16.js";
+import { k as q, m as w } from "./three.tsl-BqgDcRt9.js";
+import { n as A } from "./transformations-DBjTkQ5b.js";
 w();
 const I = {
   name: "LinearBlur",
   category: "Blurs",
+  description: "Directional motion blur in a specific angle",
   requiresRTT: !0,
   requiresChild: !0,
   props: {
@@ -31,26 +32,26 @@ const I = {
       }
     }
   },
-  fragmentNode: ({ uniforms: o, childNode: a, onCleanup: d }) => {
-    const { vec2: l, vec4: u, float: e, screenUV: p, viewportSize: f, sin: g, cos: v, radians: x, Fn: b, convertToTexture: h } = q;
+  fragmentNode: ({ uniforms: s, childNode: a, onCleanup: d }) => {
+    const { vec2: l, vec4: u, float: e, screenUV: p, viewportSize: f, sin: g, cos: v, radians: b, Fn: x, convertToTexture: h } = q;
     if (!a) return u(0, 0, 0, 0);
     const t = h(a);
     d(() => {
       t?.renderTarget?.dispose && t.renderTarget.dispose();
     });
-    const c = x(o.angle.uniform), y = l(v(c), g(c));
-    return b(() => {
-      const T = p, _ = l(1).div(f), V = y.mul(o.intensity.uniform).mul(_).mul(2), n = u(0).toVar(), r = e(0).toVar();
+    const c = b(s.angle.uniform), y = l(v(c), g(c));
+    return x(() => {
+      const T = p, _ = l(1).div(f), D = y.mul(s.intensity.uniform).mul(_).mul(2), n = u(0).toVar(), r = e(0).toVar();
       for (let i = 0; i < 32; i++) {
-        const s = e(i).div(e(31)).sub(0.5).mul(2), m = e(1).div(e(2.506628)).mul(e(-0.5).mul(s).mul(s).div(e(0.64)).exp()), B = T.add(V.mul(s.mul(0.5))), D = t.sample(B).mul(m);
-        n.assign(n.add(D)), r.assign(r.add(m));
+        const o = e(i).div(e(31)).sub(0.5).mul(2), m = e(1).div(e(2.506628)).mul(e(-0.5).mul(o).mul(o).div(e(0.64)).exp()), V = T.add(D.mul(o.mul(0.5))), B = t.sample(V).mul(m);
+        n.assign(n.add(B)), r.assign(r.add(m));
       }
       return n.div(r);
     })();
   }
 };
-var z = I;
+var k = I;
 export {
   I as n,
-  z as t
+  k as t
 };