shaders 2.2.0 → 2.2.2

package/dist/core/{LinearGradient-Ztg5Lzwj.js → LinearGradient-LEMeW0KM.js}

@@ -1,10 +1,12 @@
-import { O as N, m as R } from "./three.tsl-CgyjOhns.js";
-import { a as W, i as X, n as Y, o as h, r as b, t as j } from "./transformations-Bs66Qh16.js";
-import { t as k } from "./colorMixing-C_ESXyqX.js";
-R();
-const F = {
+import { k as R, m as W } from "./three.tsl-BqgDcRt9.js";
+import { a as X, i as Y, n as j, o as h, r as b, t as F } from "./transformations-DBjTkQ5b.js";
+import { t as I } from "./colorMixing-DPZ-Td4U.js";
+W();
+const J = {
   name: "LinearGradient",
-  category: "Gradients & Colors",
+  category: "Base Layers",
+  description: "Create smooth linear color gradients",
+  acceptsUVContext: !0,
   props: {
     colorA: {
       default: "#1aff00",
@@ -50,7 +52,7 @@ const F = {
     },
     angle: {
       default: 0,
-      transform: Y,
+      transform: j,
       description: "Additional rotation angle of the gradient (in degrees)",
       ui: {
         type: "range",
@@ -62,7 +64,7 @@ const F = {
     },
     edges: {
       default: "stretch",
-      transform: W,
+      transform: X,
       description: "How to handle areas beyond the gradient endpoints",
       ui: {
         type: "select",
@@ -89,22 +91,22 @@ const F = {
     },
     colorSpace: {
       default: "linear",
-      transform: X,
+      transform: Y,
       description: "Color space for color interpolation",
       ui: {
         type: "select",
-        options: j,
+        options: F,
         label: "Color Space"
       }
     }
   },
-  fragmentNode: ({ uniforms: t }) => {
-    const { vec2: s, vec4: T, float: e, cos: y, sin: x, dot: A, radians: C, screenUV: v, length: E, normalize: M, abs: S, mod: B, fract: q } = N, l = s(t.start.uniform[0], t.start.uniform[1].oneMinus()), c = s(t.end.uniform[0], t.end.uniform[1].oneMinus()), d = c.sub(l), w = E(d), _ = M(d), p = C(t.angle.uniform).negate(), u = y(p), m = x(p), f = l.add(c).mul(0.5), r = v.sub(f), o = A(s(r.x.mul(u).sub(r.y.mul(m)), r.x.mul(m).add(r.y.mul(u))).add(f).sub(l), _).div(w.max(1e-6)), a = t.edges.uniform, O = o.clamp(e(0), e(1)), G = o.greaterThanEqual(e(0)).select(e(1), e(0)), H = o.lessThanEqual(e(1)).select(e(1), e(0)), L = G.mul(H), i = B(S(o), e(2)), P = i.greaterThan(e(1)).select(e(2).sub(i), i), V = q(o), g = a.greaterThanEqual(e(0.5)), z = a.greaterThanEqual(e(1.5)), D = a.greaterThanEqual(e(2.5)).select(V, z.select(P, g.select(o, O))), n = k(t.colorA.uniform, t.colorB.uniform, D.clamp(e(0), e(1)), t.colorSpace.uniform), U = g.and(a.lessThan(e(1.5))).select(n.w.mul(L), n.w);
-    return T(n.x, n.y, n.z, U);
+  fragmentNode: ({ uniforms: t, uvContext: T }) => {
+    const { vec2: s, vec4: y, float: e, cos: x, sin: C, dot: v, radians: A, screenUV: E, length: B, normalize: M, abs: S, mod: q, fract: w } = R, _ = T ?? E, l = s(t.start.uniform[0], t.start.uniform[1].oneMinus()), c = s(t.end.uniform[0], t.end.uniform[1].oneMinus()), d = c.sub(l), L = B(d), V = M(d), p = A(t.angle.uniform).negate(), u = x(p), m = C(p), f = l.add(c).mul(0.5), r = _.sub(f), o = v(s(r.x.mul(u).sub(r.y.mul(m)), r.x.mul(m).add(r.y.mul(u))).add(f).sub(l), V).div(L.max(1e-6)), a = t.edges.uniform, H = o.clamp(e(0), e(1)), O = o.greaterThanEqual(e(0)).select(e(1), e(0)), P = o.lessThanEqual(e(1)).select(e(1), e(0)), U = O.mul(P), i = q(S(o), e(2)), z = i.greaterThan(e(1)).select(e(2).sub(i), i), D = w(o), g = a.greaterThanEqual(e(0.5)), G = a.greaterThanEqual(e(1.5)), k = a.greaterThanEqual(e(2.5)).select(D, G.select(z, g.select(o, H))), n = I(t.colorA.uniform, t.colorB.uniform, k.clamp(e(0), e(1)), t.colorSpace.uniform), N = g.and(a.lessThan(e(1.5))).select(n.w.mul(U), n.w);
+    return y(n.x, n.y, n.z, N);
   }
 };
-var Q = F;
+var $ = J;
 export {
-  F as n,
-  Q as t
+  J as n,
+  $ as t
 };

package/dist/core/Liquify-D2nzMDzq.js

@@ -0,0 +1,140 @@
+import { O as Z, k as A, m as $ } from "./three.tsl-BqgDcRt9.js";
+import { t as B } from "./edges-B-tVdqcI.js";
+import { a as J } from "./transformations-DBjTkQ5b.js";
+import { DataTexture as K, FloatType as Q, LinearFilter as C, RGFormat as ee } from "three";
+$();
+var r = 32, w = /* @__PURE__ */ new WeakMap(), G = (e) => {
+  let i = w.get(e);
+  if (!i) {
+    const l = new Float32Array(r * r * 2), t = new K(l, r, r, ee, Q);
+    t.magFilter = C, t.minFilter = C, t.needsUpdate = !0, i = {
+      texture: t,
+      data: l,
+      tslNode: Z(t),
+      initialized: !1
+    }, w.set(e, i);
+  }
+  return i;
+};
+const te = {
+  name: "Liquify",
+  category: "Interactive",
+  description: "Liquid-like interactive deformation effect",
+  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 (0-1)",
+      ui: {
+        type: "range",
+        min: 0,
+        max: 1,
+        step: 0.01,
+        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"
+      }
+    },
+    edges: {
+      default: "stretch",
+      description: "How to handle edges when distortion pushes content out of bounds",
+      transform: J,
+      ui: {
+        type: "select",
+        options: [
+          {
+            label: "Stretch",
+            value: "stretch"
+          },
+          {
+            label: "Transparent",
+            value: "transparent"
+          },
+          {
+            label: "Mirror",
+            value: "mirror"
+          },
+          {
+            label: "Wrap",
+            value: "wrap"
+          }
+        ],
+        label: "Edges"
+      }
+    }
+  },
+  uvTransformNode: ({ uv: e, uniforms: i }) => {
+    const { vec2: l, float: t } = A, d = G(i).tslNode.sample(e).xy, o = t(0.2), m = d.clamp(l(o.negate(), o.negate()), l(o, o));
+    return e.sub(m);
+  },
+  fragmentNode: ({ uniforms: e, onBeforeRender: i, childNode: l, onCleanup: t }) => {
+    const { vec2: d, vec4: o, float: m, uniform: D, screenUV: F, convertToTexture: H } = A, { texture: q, data: a, tslNode: O } = G(e), v = D(0), x = D(0);
+    let R = 0.5, S = 0.5, _ = Date.now();
+    if (i(({ pointer: c }) => {
+      const N = Date.now(), s = Math.min((N - _) / 1e3, 0.016);
+      _ = N;
+      const U = s > 0 ? (c.x - R) / s : 0, V = s > 0 ? (c.y - S) / s : 0;
+      v.value = v.value * 0.85 + U * 0.15, x.value = x.value * 0.85 + V * 0.15;
+      const X = e.decay.uniform.value, Y = e.intensity.uniform.value, y = e.radius.uniform.value * 0.05, g = e.swirl.uniform.value;
+      for (let p = 0; p < r; p++) for (let f = 0; f < r; f++) {
+        const n = (p * r + f) * 2;
+        a[n] *= 1 - X * s, a[n + 1] *= 1 - X * s;
+        const z = (f + 0.5) / r, P = (p + 0.5) / r, M = z - c.x, b = P - c.y, T = Math.sqrt(M * M + b * b);
+        if (T < y * 2 && Math.abs(U) + Math.abs(V) > 0.01) {
+          const h = Math.exp(-T * T / (y * y));
+          if (a[n] += v.value * h * Y * s * 0.5, a[n + 1] += x.value * h * Y * s * 0.5, g > 0) {
+            const k = Math.atan2(b, M) + Math.PI * 0.5;
+            a[n] += Math.cos(k) * g * h * s * 2, a[n + 1] += Math.sin(k) * g * h * s * 2;
+          }
+        }
+        a[n] = Math.max(-1, Math.min(1, a[n])), a[n + 1] = Math.max(-1, Math.min(1, a[n + 1]));
+      }
+      q.needsUpdate = !0, R = c.x, S = c.y;
+    }), t(() => {
+      q.dispose(), w.delete(e);
+    }), !l) return o(0, 0, 0, 0);
+    const u = H(l);
+    t(() => {
+      u?.renderTarget?.dispose && u.renderTarget.dispose();
+    });
+    const W = O.sample(F).xy, I = m(0.2), E = m(-0.2), j = W.clamp(d(E, E), d(I, I)), L = F.sub(j);
+    return B(L, u.sample(L), u, e.edges.uniform);
+  }
+};
+var ie = te;
+export {
+  te as n,
+  ie as t
+};

package/dist/core/Pixelate-irPzmtQm.js

@@ -0,0 +1,39 @@
+import { k as l, m as p } from "./three.tsl-BqgDcRt9.js";
+p();
+const m = {
+  name: "Pixelate",
+  category: "Stylize",
+  description: "Pixelation effect with adjustable cell size",
+  requiresRTT: !0,
+  requiresChild: !0,
+  props: { scale: {
+    default: 50,
+    description: "Pixel size - higher values create larger, more visible pixels",
+    ui: {
+      type: "range",
+      min: 1,
+      max: 200,
+      step: 1,
+      label: "Scale"
+    }
+  } },
+  uvTransformNode: ({ uv: t, uniforms: e }) => {
+    const { floor: i } = l, r = e.scale.uniform;
+    return i(t.mul(r)).div(r);
+  },
+  fragmentNode: ({ uniforms: t, childNode: e, onCleanup: i }) => {
+    const { vec4: r, floor: a, screenUV: n, convertToTexture: c } = l;
+    if (!e) return r(0, 0, 0, 0);
+    const s = c(e);
+    i(() => {
+      s?.renderTarget?.dispose && s.renderTarget.dispose();
+    });
+    const o = t.scale.uniform, u = a(n.mul(o)).div(o);
+    return s.sample(u);
+  }
+};
+var f = m;
+export {
+  m as n,
+  f as t
+};

package/dist/core/{PolarCoordinates-qzU8gNXR.js → PolarCoordinates-Ck5ZWrQO.js}

@@ -1,10 +1,11 @@
-import { O as v, m as w } from "./three.tsl-CgyjOhns.js";
-import { t as T } from "./edges-Cj8yVYgz.js";
-import { a as C, o as P } from "./transformations-Bs66Qh16.js";
-w();
-const _ = {
+import { k as y, m as T } from "./three.tsl-BqgDcRt9.js";
+import { t as w } from "./edges-B-tVdqcI.js";
+import { a as C, o as P } from "./transformations-DBjTkQ5b.js";
+T();
+const U = {
   name: "PolarCoordinates",
   category: "Distortions",
+  description: "Convert rectangular coordinates to polar space",
   requiresRTT: !0,
   requiresChild: !0,
   props: {
@@ -81,19 +82,23 @@ const _ = {
       }
     }
   },
-  fragmentNode: ({ uniforms: e, childNode: a, onCleanup: p }) => {
-    const { vec2: r, vec4: u, length: c, atan: m, screenUV: n, viewportSize: s, convertToTexture: f, PI: i, mix: g } = v;
-    if (!a) return u(0, 0, 0, 0);
-    const t = f(a);
-    p(() => {
-      t?.renderTarget?.dispose && t.renderTarget.dispose();
+  uvTransformNode: ({ uv: e, uniforms: t, viewportSize: i }) => {
+    const { vec2: r, length: u, atan: p, PI: l, mix: o } = y, a = i.x.div(i.y), m = r(e.x.mul(a), e.y), c = r(t.center.uniform.x.mul(a), t.center.uniform.y.oneMinus()), s = m.sub(c), n = p(s.y, s.x).add(l).div(l.mul(2)), d = u(s);
+    return o(e, r(n.mul(t.wrap.uniform), d.mul(t.radius.uniform)), t.intensity.uniform);
+  },
+  fragmentNode: ({ uniforms: e, childNode: t, onCleanup: i }) => {
+    const { vec2: r, vec4: u, length: p, atan: l, screenUV: o, viewportSize: a, convertToTexture: m, PI: c, mix: s } = y;
+    if (!t) return u(0, 0, 0, 0);
+    const n = m(t);
+    i(() => {
+      n?.renderTarget?.dispose && n.renderTarget.dispose();
     });
-    const l = s.x.div(s.y), h = r(n.x.mul(l), n.y), y = r(e.center.uniform.x.mul(l), e.center.uniform.y.oneMinus()), o = h.sub(y), b = m(o.y, o.x).add(i).div(i.mul(2)), x = c(o), d = g(n, r(b.mul(e.wrap.uniform), x.mul(e.radius.uniform)), e.intensity.uniform);
-    return T(d, t.sample(d), t, e.edges.uniform);
+    const d = a.x.div(a.y), h = r(o.x.mul(d), o.y), x = r(e.center.uniform.x.mul(d), e.center.uniform.y.oneMinus()), f = h.sub(x), b = l(f.y, f.x).add(c).div(c.mul(2)), v = p(f), g = s(o, r(b.mul(e.wrap.uniform), v.mul(e.radius.uniform)), e.intensity.uniform);
+    return w(g, n.sample(g), n, e.edges.uniform);
   }
 };
-var q = _;
+var I = U;
 export {
-  _ as n,
-  q as t
+  U as n,
+  I as t
 };

package/dist/core/{Posterize-BkBU8tnN.js → Posterize-DICq_t96.js}

@@ -1,4 +1,4 @@
-import { O as r, m as i } from "./three.tsl-CgyjOhns.js";
+import { k as r, m as i } from "./three.tsl-BqgDcRt9.js";
 import { c as n, o as a } from "./TSLBase-BFMvTOak.js";
 var p = class extends n {
   static get type() {
@@ -18,11 +18,12 @@ var p = class extends n {
     return t.mul(e).floor().div(e);
   }
 };
-const u = /* @__PURE__ */ a(p).setParameterLength(2);
+const c = /* @__PURE__ */ a(p).setParameterLength(2);
 i();
-const c = {
+const d = {
   name: "Posterize",
-  category: "Color Adjustments",
+  category: "Adjustments",
+  description: "Reduce color depth to create a poster effect",
   requiresChild: !0,
   props: { intensity: {
     default: 5,
@@ -37,11 +38,11 @@ const c = {
   } },
   fragmentNode: ({ uniforms: t, childNode: e }) => {
     const { vec4: o, int: s } = r;
-    return e ? u(e || o(0, 0, 0, 0), s(t.intensity.uniform)) : (console.error("You must pass a child component into the Posterize shader."), o(0));
+    return e ? c(e || o(0, 0, 0, 0), s(t.intensity.uniform)) : (console.error("You must pass a child component into the Posterize shader."), o(0));
   }
 };
-var l = c;
+var f = d;
 export {
-  c as n,
-  l as t
+  d as n,
+  f as t
 };

package/dist/core/{ProgressiveBlur-HAQf188T.js → ProgressiveBlur-BuORe3VH.js}

@@ -1,9 +1,10 @@
-import { O as M, m as U } from "./three.tsl-CgyjOhns.js";
-import { n as O, o as j } from "./transformations-Bs66Qh16.js";
+import { k as M, m as U } from "./three.tsl-BqgDcRt9.js";
+import { n as k, o as j } from "./transformations-DBjTkQ5b.js";
 U();
-const k = {
+const E = {
   name: "ProgressiveBlur",
   category: "Blurs",
+  description: "Blur that increases progressively in one direction",
   requiresRTT: !0,
   requiresChild: !0,
   props: {
@@ -20,7 +21,7 @@ const k = {
     },
     angle: {
       default: 0,
-      transform: O,
+      transform: k,
       description: "Direction of the blur gradient (in degrees)",
       ui: {
         type: "range",
@@ -54,14 +55,14 @@ const k = {
       }
     }
   },
-  fragmentNode: ({ uniforms: o, childNode: g, onCleanup: h }) => {
-    const { vec2: s, vec4: r, float: e, screenUV: i, viewportSize: x, sin: C, cos: D, radians: P, max: b, smoothstep: S, Fn: v, convertToTexture: y } = M;
-    if (!g) return r(0, 0, 0, 0);
-    const a = y(g);
+  fragmentNode: ({ uniforms: r, childNode: g, onCleanup: h }) => {
+    const { vec2: s, vec4: o, float: e, screenUV: i, viewportSize: x, sin: B, cos: C, radians: D, max: v, smoothstep: P, Fn: y, convertToTexture: b } = M;
+    if (!g) return o(0, 0, 0, 0);
+    const a = b(g);
     h(() => {
       a?.renderTarget?.dispose && a.renderTarget.dispose();
     });
-    const T = P(o.angle.uniform), V = s(D(T), C(T)), A = s(o.center.uniform[0], o.center.uniform[1].oneMinus()), B = i.sub(A), R = b(e(0), B.dot(V)), q = b(e(1e-3), o.falloff.uniform), F = S(e(0), q, R), I = o.intensity.uniform.mul(0.06), w = F.mul(I), _ = [
+    const T = D(r.angle.uniform), S = s(C(T), B(T)), V = s(r.center.uniform[0], r.center.uniform[1].oneMinus()), A = i.sub(V), R = v(e(0), A.dot(S)), q = v(e(1e-3), r.falloff.uniform), F = P(e(0), q, R), I = r.intensity.uniform.mul(0.06), w = F.mul(I), _ = [
       0.056,
       0.135,
       0.278,
@@ -75,8 +76,8 @@ const k = {
       0.278,
       0.135,
       0.056
-    ], z = 6.214, l = y(v(() => {
-      const c = i, u = s(1).div(x), n = r(0).toVar();
+    ], z = 6.214, l = b(y(() => {
+      const c = i, u = s(1).div(x), n = o(0).toVar();
       for (let t = -6; t <= 6; t++) {
         const d = e(_[t + 6] / z), f = s(e(t), e(0)).mul(w).mul(u), m = c.add(f), p = a.sample(m).mul(d);
         n.assign(n.add(p));
@@ -85,8 +86,8 @@ const k = {
     })());
     return h(() => {
       l?.renderTarget?.dispose && l.renderTarget.dispose();
-    }), v(() => {
-      const c = i, u = s(1).div(x), n = r(0).toVar();
+    }), y(() => {
+      const c = i, u = s(1).div(x), n = o(0).toVar();
       for (let t = -6; t <= 6; t++) {
         const d = e(_[t + 6] / z), f = s(e(0), e(t)).mul(w).mul(u), m = c.add(f), p = l.sample(m).mul(d);
         n.assign(n.add(p));
@@ -95,8 +96,8 @@ const k = {
     })();
   }
 };
-var H = k;
+var J = E;
 export {
-  k as n,
-  H as t
+  E as n,
+  J as t
 };

package/dist/core/{RadialGradient-DISqJuTZ.js → RadialGradient-D0cN67jm.js}

@@ -1,10 +1,12 @@
-import { O as c, m as p } from "./three.tsl-CgyjOhns.js";
-import { i as d, o as f, r as n, t as m } from "./transformations-Bs66Qh16.js";
-import { t as u } from "./colorMixing-C_ESXyqX.js";
-p();
-const h = {
+import { k as d, m as f } from "./three.tsl-BqgDcRt9.js";
+import { i as m, o as u, r as n, t as g } from "./transformations-DBjTkQ5b.js";
+import { t as h } from "./colorMixing-DPZ-Td4U.js";
+f();
+const y = {
   name: "RadialGradient",
-  category: "Gradients & Colors",
+  category: "Base Layers",
+  description: "Radial gradient radiating from a center point",
+  acceptsUVContext: !0,
   props: {
     colorA: {
       default: "#ff0000",
@@ -29,7 +31,7 @@ const h = {
         x: 0.5,
         y: 0.5
       },
-      transform: f,
+      transform: u,
       description: "The center point of the radial gradient",
       ui: {
         type: "position",
@@ -49,22 +51,22 @@ const h = {
     },
     colorSpace: {
       default: "linear",
-      transform: d,
+      transform: m,
       description: "Color space for color interpolation",
       ui: {
         type: "select",
-        options: m,
+        options: g,
         label: "Color Space"
       }
     }
   },
-  fragmentNode: ({ uniforms: o }) => {
-    const { vec2: e, float: r, distance: l, screenUV: t, viewportSize: a } = c, i = a.x.div(a.y), s = l(e(t.x.mul(i), t.y), e(o.center.uniform.x.mul(i), o.center.uniform.y.oneMinus())).div(o.radius.uniform).clamp(r(0), r(1));
-    return u(o.colorA.uniform, o.colorB.uniform, s, o.colorSpace.uniform);
+  fragmentNode: ({ uniforms: e, uvContext: l }) => {
+    const { vec2: o, float: t, distance: s, screenUV: c, viewportSize: r } = d, a = l ?? c, i = r.x.div(r.y), p = s(o(a.x.mul(i), a.y), o(e.center.uniform.x.mul(i), e.center.uniform.y.oneMinus())).div(e.radius.uniform).clamp(t(0), t(1));
+    return h(e.colorA.uniform, e.colorB.uniform, p, e.colorSpace.uniform);
   }
 };
-var x = h;
+var S = y;
 export {
-  h as n,
-  x as t
+  y as n,
+  S as t
 };

package/dist/core/RectangularCoordinates-1LIDaeHR.js

@@ -0,0 +1,93 @@
+import { k as x, m as T } from "./three.tsl-BqgDcRt9.js";
+import { t as C } from "./edges-B-tVdqcI.js";
+import { a as P, o as _ } from "./transformations-DBjTkQ5b.js";
+T();
+const w = {
+  name: "RectangularCoordinates",
+  category: "Distortions",
+  description: "Convert polar coordinates back to rectangular space",
+  requiresRTT: !0,
+  requiresChild: !0,
+  props: {
+    center: {
+      default: {
+        x: 0.5,
+        y: 0.5
+      },
+      transform: _,
+      description: "The center point for rectangular coordinate conversion",
+      ui: {
+        type: "position",
+        label: "Center"
+      }
+    },
+    scale: {
+      default: 1,
+      description: "Scale factor for the rectangular output",
+      ui: {
+        type: "range",
+        min: 0.1,
+        max: 3,
+        step: 0.01,
+        label: "Scale"
+      }
+    },
+    intensity: {
+      default: 1,
+      description: "Blends between original UVs (0) and rectangular coordinates (1)",
+      ui: {
+        type: "range",
+        min: 0,
+        max: 1,
+        step: 0.01,
+        label: "Intensity"
+      }
+    },
+    edges: {
+      default: "transparent",
+      description: "How to handle edges when distortion pushes content out of bounds",
+      transform: P,
+      ui: {
+        type: "select",
+        options: [
+          {
+            label: "Stretch",
+            value: "stretch"
+          },
+          {
+            label: "Transparent",
+            value: "transparent"
+          },
+          {
+            label: "Mirror",
+            value: "mirror"
+          },
+          {
+            label: "Wrap",
+            value: "wrap"
+          }
+        ],
+        label: "Edges"
+      }
+    }
+  },
+  uvTransformNode: ({ uv: e, uniforms: t, viewportSize: i }) => {
+    const { vec2: n, cos: d, sin: p, PI: c, mix: o } = x, a = e.x.mul(c.mul(2)).sub(c), l = e.y.mul(t.scale.uniform), u = l.mul(d(a)), m = l.mul(p(a)), r = i.x.div(i.y), s = n(t.center.uniform.x, t.center.uniform.y.oneMinus());
+    return o(e, n(u.div(r).add(s.x), m.add(s.y)), t.intensity.uniform);
+  },
+  fragmentNode: ({ uniforms: e, childNode: t, onCleanup: i }) => {
+    const { vec2: n, vec4: d, cos: p, sin: c, screenUV: o, viewportSize: a, convertToTexture: l, PI: u, mix: m } = x;
+    if (!t) return d(0, 0, 0, 0);
+    const r = l(t);
+    i(() => {
+      r?.renderTarget?.dispose && r.renderTarget.dispose();
+    });
+    const s = o.x.mul(u.mul(2)).sub(u), f = o.y.mul(e.scale.uniform), b = f.mul(p(s)), v = f.mul(c(s)), h = a.x.div(a.y), g = n(e.center.uniform.x, e.center.uniform.y.oneMinus()), y = m(o, n(b.div(h).add(g.x), v.add(g.y)), e.intensity.uniform);
+    return C(y, r.sample(y), r, e.edges.uniform);
+  }
+};
+var R = w;
+export {
+  w as n,
+  R as t
+};

package/dist/core/{Ripples-CX8Qgnog.js → Ripples-DH71sFJc.js}

@@ -1,17 +1,19 @@
-import { O as w, m as A } from "./three.tsl-CgyjOhns.js";
-import { t as B } from "./time-myrFQH-u.js";
-import { o as C, r as l } from "./transformations-Bs66Qh16.js";
+import { k as w, m as A } from "./three.tsl-BqgDcRt9.js";
+import { t as S } from "./time-5uQ65blS.js";
+import { o as _, r as l } from "./transformations-DBjTkQ5b.js";
 A();
-const S = {
+const q = {
   name: "Ripples",
-  category: "Effects",
+  category: "Base Layers",
+  description: "Concentric animated ripples emanating from a point",
+  acceptsUVContext: !0,
   props: {
     center: {
       default: {
         x: 0.5,
         y: 0.5
       },
-      transform: C,
+      transform: _,
       description: "The center point where ripples emanate from",
       ui: {
         type: "position",
@@ -92,13 +94,13 @@ const S = {
       }
     }
   },
-  fragmentNode: (o) => {
-    const { uniforms: e } = o, { vec2: t, float: s, screenUV: n, sin: f, distance: m, viewportSize: r, mix: u, smoothstep: d } = w, i = e.center.uniform, h = e.colorA.uniform, y = e.colorB.uniform, b = e.frequency.uniform, a = e.softness.uniform, x = e.thickness.uniform, g = e.phase.uniform, p = r.x.div(r.y), k = m(t(n.x.mul(p), n.y), t(i.x.mul(p), i.y.oneMinus())), v = B(o, e.speed), T = f(k.mul(b).sub(v).add(g)), c = x.mul(s(2)).sub(s(1));
-    return u(y, h, d(c.add(a), c.sub(a), T));
+  fragmentNode: (t) => {
+    const { uniforms: e, uvContext: f } = t, { vec2: o, float: s, screenUV: m, sin: u, distance: d, viewportSize: n, mix: h, smoothstep: y } = w, r = f ?? m, i = e.center.uniform, b = e.colorA.uniform, x = e.colorB.uniform, g = e.frequency.uniform, a = e.softness.uniform, k = e.thickness.uniform, v = e.phase.uniform, p = n.x.div(n.y), C = d(o(r.x.mul(p), r.y), o(i.x.mul(p), i.y.oneMinus())), B = S(t, e.speed), T = u(C.mul(g).sub(B).add(v)), c = k.mul(s(2)).sub(s(1));
+    return h(x, b, y(c.add(a), c.sub(a), T));
   }
 };
-var N = S;
+var U = q;
 export {
-  S as n,
-  N as t
+  q as n,
+  U as t
 };

package/dist/core/{Saturation-DMxPYmIU.js → Saturation-DbSXtSeK.js}

@@ -1,9 +1,10 @@
-import { O as o, m as a } from "./three.tsl-CgyjOhns.js";
-import { r as i } from "./ColorAdjustment-CKwpE_4M.js";
-a();
-const s = {
+import { k as o, m as i } from "./three.tsl-BqgDcRt9.js";
+import { r as s } from "./ColorAdjustment-CKwpE_4M.js";
+i();
+const a = {
   name: "Saturation",
-  category: "Color Adjustments",
+  category: "Adjustments",
+  description: "Adjust color saturation intensity",
   requiresChild: !0,
   props: { intensity: {
     default: 1,
@@ -21,11 +22,11 @@ const s = {
     if (!e)
       return console.error("You must pass a child component into the Saturation shader."), t(0);
     const n = e || t(0, 0, 0, 0);
-    return t(i(n.rgb, r.intensity.uniform).rgb, n.a);
+    return t(s(n.rgb, r.intensity.uniform).rgb, n.a);
   }
 };
-var c = s;
+var m = a;
 export {
-  s as n,
-  c as t
+  a as n,
+  m as t
 };