shaders 2.2.0 → 2.2.1

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

@@ -1,10 +1,11 @@
-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",
+  acceptsUVContext: !0,
   props: {
     colorA: {
       default: "#1aff00",
@@ -50,7 +51,7 @@ const F = {
     },
     angle: {
       default: 0,
-      transform: Y,
+      transform: j,
       description: "Additional rotation angle of the gradient (in degrees)",
       ui: {
         type: "range",
@@ -62,7 +63,7 @@ const F = {
     },
     edges: {
       default: "stretch",
-      transform: W,
+      transform: X,
       description: "How to handle areas beyond the gradient endpoints",
       ui: {
         type: "select",
@@ -89,22 +90,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: M, normalize: S, abs: B, 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), V = M(d), G = S(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), G).div(V.max(1e-6)), a = t.edges.uniform, H = o.clamp(e(0), e(1)), L = o.greaterThanEqual(e(0)).select(e(1), e(0)), O = o.lessThanEqual(e(1)).select(e(1), e(0)), P = L.mul(O), i = q(B(o), e(2)), U = i.greaterThan(e(1)).select(e(2).sub(i), i), z = w(o), g = a.greaterThanEqual(e(0.5)), D = a.greaterThanEqual(e(1.5)), k = a.greaterThanEqual(e(2.5)).select(z, D.select(U, 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(P), 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-DNHtcXxv.js

@@ -0,0 +1,139 @@
+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",
+  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: R, data: a, tslNode: O } = G(e), v = D(0), x = D(0);
+    let S = 0.5, _ = 0.5, q = Date.now();
+    if (i(({ pointer: c }) => {
+      const U = Date.now(), s = Math.min((U - q) / 1e3, 0.016);
+      q = U;
+      const V = s > 0 ? (c.x - S) / s : 0, X = s > 0 ? (c.y - _) / s : 0;
+      v.value = v.value * 0.85 + V * 0.15, x.value = x.value * 0.85 + X * 0.15;
+      const Y = e.decay.uniform.value, L = 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 - Y * s, a[n + 1] *= 1 - Y * 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(V) + Math.abs(X) > 0.01) {
+          const h = Math.exp(-T * T / (y * y));
+          if (a[n] += v.value * h * L * s * 0.5, a[n + 1] += x.value * h * L * 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]));
+      }
+      R.needsUpdate = !0, S = c.x, _ = c.y;
+    }), t(() => {
+      R.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)), N = F.sub(j);
+    return B(N, u.sample(N), u, e.edges.uniform);
+  }
+};
+var ie = te;
+export {
+  te as n,
+  ie as t
+};

package/dist/core/Pixelate-BKooNVcb.js

@@ -0,0 +1,38 @@
+import { k as n, m as p } from "./three.tsl-BqgDcRt9.js";
+p();
+const m = {
+  name: "Pixelate",
+  category: "Effects",
+  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 } = n, r = e.scale.uniform;
+    return i(t.mul(r)).div(r);
+  },
+  fragmentNode: ({ uniforms: t, childNode: e, onCleanup: i }) => {
+    const { vec4: r, floor: a, screenUV: l, convertToTexture: c } = n;
+    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(l.mul(o)).div(o);
+    return s.sample(u);
+  }
+};
+var d = m;
+export {
+  m as n,
+  d as t
+};

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

@@ -1,8 +1,8 @@
-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",
   requiresRTT: !0,
@@ -81,19 +81,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), d = r(t.center.uniform.x.mul(a), t.center.uniform.y.oneMinus()), s = m.sub(d), n = p(s.y, s.x).add(l).div(l.mul(2)), c = u(s);
+    return o(e, r(n.mul(t.wrap.uniform), c.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: d, 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 c = a.x.div(a.y), h = r(o.x.mul(c), o.y), x = r(e.center.uniform.x.mul(c), e.center.uniform.y.oneMinus()), f = h.sub(x), b = l(f.y, f.x).add(d).div(d.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-D81ZG2A9.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() {

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

@@ -1,7 +1,7 @@
-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",
   requiresRTT: !0,
@@ -20,7 +20,7 @@ const k = {
     },
     angle: {
       default: 0,
-      transform: O,
+      transform: k,
       description: "Direction of the blur gradient (in degrees)",
       ui: {
         type: "range",
@@ -95,8 +95,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-XmwfZ91d.js}

@@ -1,10 +1,11 @@
-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 h } from "./transformations-DBjTkQ5b.js";
+import { t as g } from "./colorMixing-DPZ-Td4U.js";
+f();
+const y = {
   name: "RadialGradient",
   category: "Gradients & Colors",
+  acceptsUVContext: !0,
   props: {
     colorA: {
       default: "#ff0000",
@@ -29,7 +30,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 +50,22 @@ const h = {
     },
     colorSpace: {
       default: "linear",
-      transform: d,
+      transform: m,
       description: "Color space for color interpolation",
       ui: {
         type: "select",
-        options: m,
+        options: h,
         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: o, uvContext: l }) => {
+    const { vec2: e, float: t, distance: s, screenUV: c, viewportSize: r } = d, a = l ?? c, i = r.x.div(r.y), p = s(e(a.x.mul(i), a.y), e(o.center.uniform.x.mul(i), o.center.uniform.y.oneMinus())).div(o.radius.uniform).clamp(t(0), t(1));
+    return g(o.colorA.uniform, o.colorB.uniform, p, o.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-DWY7ptY1.js

@@ -0,0 +1,92 @@
+import { k as x, m as T } from "./three.tsl-BqgDcRt9.js";
+import { t as P } from "./edges-B-tVdqcI.js";
+import { a as _, o as w } from "./transformations-DBjTkQ5b.js";
+T();
+const C = {
+  name: "RectangularCoordinates",
+  category: "Distortions",
+  requiresRTT: !0,
+  requiresChild: !0,
+  props: {
+    center: {
+      default: {
+        x: 0.5,
+        y: 0.5
+      },
+      transform: w,
+      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: _,
+      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: r, cos: d, sin: m, PI: c, mix: o } = x, s = e.x.mul(c.mul(2)).sub(c), l = e.y.mul(t.scale.uniform), u = l.mul(d(s)), p = l.mul(m(s)), n = i.x.div(i.y), a = r(t.center.uniform.x, t.center.uniform.y.oneMinus());
+    return o(e, r(u.div(n).add(a.x), p.add(a.y)), t.intensity.uniform);
+  },
+  fragmentNode: ({ uniforms: e, childNode: t, onCleanup: i }) => {
+    const { vec2: r, vec4: d, cos: m, sin: c, screenUV: o, viewportSize: s, convertToTexture: l, PI: u, mix: p } = x;
+    if (!t) return d(0, 0, 0, 0);
+    const n = l(t);
+    i(() => {
+      n?.renderTarget?.dispose && n.renderTarget.dispose();
+    });
+    const a = o.x.mul(u.mul(2)).sub(u), f = o.y.mul(e.scale.uniform), b = f.mul(m(a)), v = f.mul(c(a)), h = s.x.div(s.y), g = r(e.center.uniform.x, e.center.uniform.y.oneMinus()), y = p(o, r(b.div(h).add(g.x), v.add(g.y)), e.intensity.uniform);
+    return P(y, n.sample(y), n, e.edges.uniform);
+  }
+};
+var R = C;
+export {
+  C as n,
+  R as t
+};

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

@@ -1,17 +1,18 @@
-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";
-A();
-const S = {
+import { k as A, m as B } from "./three.tsl-BqgDcRt9.js";
+import { t as S } from "./time-5uQ65blS.js";
+import { o as _, r as l } from "./transformations-DBjTkQ5b.js";
+B();
+const q = {
   name: "Ripples",
   category: "Effects",
+  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 +93,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 } = A, 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())), T = S(t, e.speed), w = u(C.mul(g).sub(T).add(v)), c = k.mul(s(2)).sub(s(1));
+    return h(x, b, y(c.add(a), c.sub(a), w));
   }
 };
-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-C6u9sNkr.js}

@@ -1,4 +1,4 @@
-import { O as o, m as a } from "./three.tsl-CgyjOhns.js";
+import { k as o, m as a } from "./three.tsl-BqgDcRt9.js";
 import { r as i } from "./ColorAdjustment-CKwpE_4M.js";
 a();
 const s = {

package/dist/core/{SimplexNoise-B5ygfckG.js → SimplexNoise-BH0ZZzP4.js}

@@ -1,10 +1,11 @@
-import { A as d, N as a, S as r, _ as f, a as u, j as x, m as y, u as g, y as b } from "./three.tsl-CgyjOhns.js";
-import { t as v } from "./time-myrFQH-u.js";
-import { r as n } from "./transformations-Bs66Qh16.js";
-y();
-const S = {
+import { M as u, P as r, S as f, _ as x, a as y, j as g, m as b, u as v, y as S } from "./three.tsl-BqgDcRt9.js";
+import { t as C } from "./time-5uQ65blS.js";
+import { r as n } from "./transformations-DBjTkQ5b.js";
+b();
+const h = {
   name: "SimplexNoise",
   category: "Noise",
+  acceptsUVContext: !0,
   props: {
     colorA: {
       default: "#ffffff",
@@ -80,13 +81,13 @@ const S = {
       }
     }
   },
-  fragmentNode: (o) => {
-    const { uniforms: e } = o, i = a.x.div(a.y), s = d(r.x.mul(i), r.y), l = v(o, e.speed), t = s.mul(g(e.scale.uniform)).add(e.seed.uniform), c = b(x(t.x, t.y, l.mul(0.5))), m = e.contrast.uniform.add(1), p = u(0, 1, c.mul(m).add(e.balance.uniform).mul(0.5).add(0.5));
-    return f(e.colorB.uniform, e.colorA.uniform, p);
+  fragmentNode: (t) => {
+    const { uniforms: e, uvContext: s } = t, o = s ?? f, i = r.x.div(r.y), l = g(o.x.mul(i), o.y), c = C(t, e.speed), a = l.mul(v(e.scale.uniform)).add(e.seed.uniform), m = S(u(a.x, a.y, c.mul(0.5))), p = e.contrast.uniform.add(1), d = y(0, 1, m.mul(p).add(e.balance.uniform).mul(0.5).add(0.5));
+    return x(e.colorB.uniform, e.colorA.uniform, d);
   }
 };
-var _ = S;
+var N = h;
 export {
-  S as n,
-  _ as t
+  h as n,
+  N as t
 };

package/dist/core/{SineWave-KPFlP3Wk.js → SineWave-DBH8MraQ.js}

@@ -1,9 +1,10 @@
-import { O as q, m as P } from "./three.tsl-CgyjOhns.js";
-import { n as W, o as C, r as M } from "./transformations-Bs66Qh16.js";
-P();
-const U = {
+import { k as P, m as U } from "./three.tsl-BqgDcRt9.js";
+import { n as V, o as W, r as M } from "./transformations-DBjTkQ5b.js";
+U();
+const F = {
   name: "SineWave",
   category: "Shapes & Masks",
+  acceptsUVContext: !0,
   props: {
     color: {
       default: "#ffffff",
@@ -49,7 +50,7 @@ const U = {
     },
     angle: {
       default: 0,
-      transform: W,
+      transform: V,
       description: "The rotation angle of the wave (in degrees)",
       ui: {
         type: "range",
@@ -64,7 +65,7 @@ const U = {
         x: 0.5,
         y: 0.5
       },
-      transform: C,
+      transform: W,
       description: "The center position of the wave",
       ui: {
         type: "position",
@@ -94,13 +95,13 @@ const U = {
       }
     }
   },
-  fragmentNode: ({ uniforms: e }) => {
-    const { vec2: n, vec4: u, sin: o, cos: f, abs: d, smoothstep: h, screenUV: s, viewportSize: a, time: g, radians: y, PI: v } = q, i = a.x.div(a.y), b = n(s.x.mul(i), s.y), x = n(e.position.uniform.x.mul(i), e.position.uniform.y.oneMinus()), t = b.sub(x), r = y(e.angle.uniform), l = f(r), c = o(r), w = t.x.mul(l).sub(t.y.mul(c)), T = t.x.mul(c).add(t.y.mul(l)), k = g.mul(e.speed.uniform), S = o(w.mul(e.frequency.uniform).mul(v.mul(2)).add(k)).mul(e.amplitude.uniform), A = d(T.sub(S)), m = e.thickness.uniform.mul(0.5), p = e.softness.uniform.mul(0.5), _ = h(m.add(p), m.sub(p), A);
-    return u(e.color.uniform.rgb, e.color.uniform.a.mul(_));
+  fragmentNode: ({ uniforms: e, uvContext: p }) => {
+    const { vec2: n, vec4: f, sin: o, cos: d, abs: h, smoothstep: g, screenUV: y, viewportSize: s, time: v, radians: b, PI: x } = P, a = p ?? y, i = s.x.div(s.y), w = n(a.x.mul(i), a.y), T = n(e.position.uniform.x.mul(i), e.position.uniform.y.oneMinus()), t = w.sub(T), r = b(e.angle.uniform), l = d(r), c = o(r), k = t.x.mul(l).sub(t.y.mul(c)), S = t.x.mul(c).add(t.y.mul(l)), A = v.mul(e.speed.uniform), _ = o(k.mul(e.frequency.uniform).mul(x.mul(2)).add(A)).mul(e.amplitude.uniform), q = h(S.sub(_)), m = e.thickness.uniform.mul(0.5), u = e.softness.uniform.mul(0.5), C = g(m.add(u), m.sub(u), q);
+    return f(e.color.uniform.rgb, e.color.uniform.a.mul(C));
   }
 };
-var z = U;
+var E = F;
 export {
-  U as n,
-  z as t
+  F as n,
+  E as t
 };

package/dist/core/{SolidColor-B8oxlGge.js → SolidColor-DR665qss.js}

@@ -1,7 +1,8 @@
-import { r } from "./transformations-Bs66Qh16.js";
-const l = {
+import { r } from "./transformations-DBjTkQ5b.js";
+const t = {
   name: "SolidColor",
   category: "Gradients & Colors",
+  acceptsUVContext: !0,
   props: { color: {
     default: "#5b18ca",
     transform: r,
@@ -13,8 +14,8 @@ const l = {
   } },
   fragmentNode: ({ uniforms: o }) => o.color.uniform
 };
-var a = l;
+var l = t;
 export {
-  l as n,
-  a as t
+  t as n,
+  l as t
 };