shaders 2.2.0 → 2.2.2

package/dist/core/{ChromaFlow-DOVrymVB.js → ChromaFlow-AHO3C4o3.js}

@@ -1,10 +1,11 @@
-import { O as Vt, m as Wt } from "./three.tsl-CgyjOhns.js";
-import { r as X } from "./transformations-Bs66Qh16.js";
-import { DataTexture as at, FloatType as nt, LinearFilter as I, RGFormat as lt } from "three";
+import { k as Vt, m as Wt } from "./three.tsl-BqgDcRt9.js";
+import { r as X } from "./transformations-DBjTkQ5b.js";
+import { DataTexture as at, FloatType as lt, LinearFilter as _, RGFormat as nt } from "three";
 Wt();
 const jt = {
   name: "ChromaFlow",
   category: "Interactive",
+  description: "Interactive liquid flow effect that follows your cursor",
   props: {
     baseColor: {
       default: "#0066ff",
@@ -86,10 +87,10 @@ const jt = {
     }
   },
   fragmentNode: ({ uniforms: u, onBeforeRender: st, onCleanup: rt }) => {
-    const { vec2: n, vec4: it, float: t, uniform: Y, screenUV: l, texture: W, smoothstep: v, mix: dt } = Vt, o = 128, f = new Float32Array(o * o * 2), r = new Float32Array(o * o * 2), w = new at(f, o, o, lt, nt);
-    w.magFilter = I, w.minFilter = I, w.needsUpdate = !0;
-    const C = new at(r, o, o, lt, nt);
-    C.magFilter = I, C.minFilter = I, C.needsUpdate = !0;
+    const { vec2: l, vec4: it, float: t, uniform: Y, screenUV: n, texture: W, smoothstep: v, mix: dt } = Vt, o = 128, f = new Float32Array(o * o * 2), r = new Float32Array(o * o * 2), w = new at(f, o, o, nt, lt);
+    w.magFilter = _, w.minFilter = _, w.needsUpdate = !0;
+    const C = new at(r, o, o, nt, lt);
+    C.magFilter = _, C.minFilter = _, C.needsUpdate = !0;
     const F = W(w), b = W(C), ct = Y(0.5), mt = Y(0.5), q = Y(0), D = Y(0);
     let j = 0.5, B = 0.5, G = Date.now();
     st(({ pointer: p }) => {
@@ -97,20 +98,20 @@ const jt = {
       G = tt;
       const ot = s > 0 ? (p.x - j) / s : 0, et = s > 0 ? (p.y - B) / s : 0;
       q.value = q.value * 0.85 + ot * 0.15, D.value = D.value * 0.85 + et * 0.15, ct.value = p.x, mt.value = p.y;
-      const V = u.intensity.uniform.value, Yt = u.radius.uniform.value * 0.05, zt = u.momentum.uniform.value, x = new Float32Array(f), i = new Float32Array(r), Tt = 1 - s / Math.max(0.1, 1);
-      for (let a = 0; a < o * o * 2; a++) x[a] = f[a] * Tt;
+      const V = u.intensity.uniform.value, Yt = u.radius.uniform.value * 0.05, zt = u.momentum.uniform.value, x = new Float32Array(f), i = new Float32Array(r), It = 1 - s / Math.max(0.1, 1);
+      for (let a = 0; a < o * o * 2; a++) x[a] = f[a] * It;
       for (let a = 0; a < o; a++) for (let d = 0; d < o; d++) {
         const e = (a * o + d) * 2, S = 1 - s / Math.max(0.4, 1);
         if (i[e] = r[e] * S, i[e + 1] = r[e + 1] * S, Math.abs(f[e]) > 1e-3 || Math.abs(f[e + 1]) > 1e-3) {
-          const U = zt * 50 * s, A = d - f[e] * U, R = a - f[e + 1] * U, c = Math.floor(A), m = Math.floor(R), h = c + 1, y = m + 1;
+          const T = zt * 50 * s, A = d - f[e] * T, R = a - f[e + 1] * T, c = Math.floor(A), m = Math.floor(R), h = c + 1, y = m + 1;
           if (c >= 0 && m >= 0 && h < o && y < o) {
-            const M = A - c, _ = R - m, Ut = (m * o + c) * 2, _t = (m * o + h) * 2, It = (y * o + c) * 2, Lt = (y * o + h) * 2;
-            i[e] = (r[Ut] * (1 - M) * (1 - _) + r[_t] * M * (1 - _) + r[It] * (1 - M) * _ + r[Lt] * M * _) * S;
+            const M = A - c, U = R - m, Tt = (m * o + c) * 2, Ut = (m * o + h) * 2, _t = (y * o + c) * 2, Lt = (y * o + h) * 2;
+            i[e] = (r[Tt] * (1 - M) * (1 - U) + r[Ut] * M * (1 - U) + r[_t] * (1 - M) * U + r[Lt] * M * U) * S;
           }
         }
       }
       for (let a = 0; a < o; a++) for (let d = 0; d < o; d++) {
-        const e = (a * o + d) * 2, S = (d + 0.5) / o, U = (a + 0.5) / o, A = S - p.x, R = U - p.y, c = Math.sqrt(A * A + R * R), m = Math.sqrt(q.value * q.value + D.value * D.value), h = Yt * Math.min(m * m * 20, 1);
+        const e = (a * o + d) * 2, S = (d + 0.5) / o, T = (a + 0.5) / o, A = S - p.x, R = T - p.y, c = Math.sqrt(A * A + R * R), m = Math.sqrt(q.value * q.value + D.value * D.value), h = Yt * Math.min(m * m * 20, 1);
         if (c < h * 2 && Math.abs(ot) + Math.abs(et) > 0.01) {
           const y = Math.exp(-c * c / (h * h));
           x[e] += q.value * y * (V * 100) * s * 0.01, x[e + 1] += D.value * y * (V * 100) * s * 0.01;
@@ -123,12 +124,12 @@ const jt = {
     }), rt(() => {
       w.dispose(), C.dispose();
     });
-    const ut = b.sample(l).x, z = n(t(1 / 128), t(1 / 128)), ft = b.sample(l.add(n(z.x, t(0)))).x, pt = b.sample(l.add(n(t(0), z.y))).x, xt = b.sample(l.add(n(z.x.negate(), t(0)))).x, ht = b.sample(l.add(n(t(0), z.y.negate()))).x, yt = ut.add(ft).add(pt).add(xt).add(ht).mul(t(0.2)), E = v(t(0), t(0.1), yt), T = n(t(1 / 128), t(1 / 128)), vt = F.sample(l).xy, wt = F.sample(l.add(n(T.x, t(0)))).xy, Ct = F.sample(l.add(n(t(0), T.y))).xy, gt = F.sample(l.add(n(T.x.negate(), t(0)))).xy, Mt = F.sample(l.add(n(t(0), T.y.negate()))).xy, g = vt.add(wt).add(Ct).add(gt).add(Mt).mul(t(0.2)), Ft = u.baseColor.uniform, bt = u.upColor.uniform, qt = u.downColor.uniform, Dt = u.leftColor.uniform, St = u.rightColor.uniform, L = g.x.mul(g.x).add(g.y.mul(g.y)).sqrt(), At = v(t(0.01), t(0.1), L), H = g.x.div(L.add(t(1e-3))), N = g.y.div(L.add(t(1e-3))), O = v(t(0), t(0.7), H.max(t(0))), P = v(t(0), t(0.7), H.negate().max(t(0))), Z = v(t(0), t(0.7), N.max(t(0))), k = v(t(0), t(0.7), N.negate().max(t(0))), Rt = Dt.mul(P).add(St.mul(O)), Xt = qt.mul(k).add(bt.mul(Z)), J = P.add(O), K = Z.add(k), Q = J.add(K).add(t(1e-3)), $ = dt(Ft, Rt.mul(J.div(Q)).add(Xt.mul(K.div(Q))), At);
-    return it($.rgb.mul(E), $.a.mul(E));
+    const ut = b.sample(n).x, z = l(t(1 / 128), t(1 / 128)), ft = b.sample(n.add(l(z.x, t(0)))).x, pt = b.sample(n.add(l(t(0), z.y))).x, xt = b.sample(n.add(l(z.x.negate(), t(0)))).x, ht = b.sample(n.add(l(t(0), z.y.negate()))).x, yt = ut.add(ft).add(pt).add(xt).add(ht).mul(t(0.2)), k = v(t(0), t(0.1), yt), I = l(t(1 / 128), t(1 / 128)), vt = F.sample(n).xy, wt = F.sample(n.add(l(I.x, t(0)))).xy, Ct = F.sample(n.add(l(t(0), I.y))).xy, gt = F.sample(n.add(l(I.x.negate(), t(0)))).xy, Mt = F.sample(n.add(l(t(0), I.y.negate()))).xy, g = vt.add(wt).add(Ct).add(gt).add(Mt).mul(t(0.2)), Ft = u.baseColor.uniform, bt = u.upColor.uniform, qt = u.downColor.uniform, Dt = u.leftColor.uniform, St = u.rightColor.uniform, L = g.x.mul(g.x).add(g.y.mul(g.y)).sqrt(), At = v(t(0.01), t(0.1), L), E = g.x.div(L.add(t(1e-3))), H = g.y.div(L.add(t(1e-3))), N = v(t(0), t(0.7), E.max(t(0))), P = v(t(0), t(0.7), E.negate().max(t(0))), Z = v(t(0), t(0.7), H.max(t(0))), J = v(t(0), t(0.7), H.negate().max(t(0))), Rt = Dt.mul(P).add(St.mul(N)), Xt = qt.mul(J).add(bt.mul(Z)), K = P.add(N), O = Z.add(J), Q = K.add(O).add(t(1e-3)), $ = dt(Ft, Rt.mul(K.div(Q)).add(Xt.mul(O.div(Q))), At);
+    return it($.rgb.mul(k), $.a.mul(k));
   }
 };
-var Ht = jt;
+var Et = jt;
 export {
   jt as n,
-  Ht as t
+  Et as t
 };

package/dist/core/{ChromaticAberration-CyTSXY7j.js → ChromaticAberration-nVg3r1FK.js}

@@ -1,9 +1,10 @@
-import { O as y, m as C } from "./three.tsl-CgyjOhns.js";
-import { n as v } from "./transformations-Bs66Qh16.js";
+import { k as T, m as C } from "./three.tsl-BqgDcRt9.js";
+import { n as v } from "./transformations-DBjTkQ5b.js";
 C();
-const _ = {
+const R = {
   name: "ChromaticAberration",
-  category: "Effects",
+  category: "Stylize",
+  description: "Separate RGB channels for a prismatic distortion effect",
   requiresRTT: !0,
   requiresChild: !0,
   props: {
@@ -65,18 +66,18 @@ const _ = {
     }
   },
   fragmentNode: ({ uniforms: t, childNode: s, onCleanup: o }) => {
-    const { vec2: f, vec4: l, cos: c, sin: m, radians: u, screenUV: n, convertToTexture: d } = y;
-    if (!s) return l(0, 0, 0, 0);
+    const { vec2: f, vec4: i, cos: c, sin: m, radians: u, screenUV: r, convertToTexture: d } = T;
+    if (!s) return i(0, 0, 0, 0);
     const e = d(s);
     o(() => {
       e?.renderTarget?.dispose && e.renderTarget.dispose();
     });
-    const i = u(t.angle.uniform), r = f(c(i), m(i)), a = t.strength.uniform.mul(0.1), p = n.add(r.mul(a).mul(t.redOffset.uniform)), g = n.add(r.mul(a).mul(t.greenOffset.uniform)), h = n.add(r.mul(a).mul(t.blueOffset.uniform)), b = e.sample(p).r, O = e.sample(g).g, x = e.sample(h).b, T = e.sample(n).a;
-    return l(b, O, x, T);
+    const l = u(t.angle.uniform), n = f(c(l), m(l)), a = t.strength.uniform.mul(0.1), p = r.add(n.mul(a).mul(t.redOffset.uniform)), g = r.add(n.mul(a).mul(t.greenOffset.uniform)), h = r.add(n.mul(a).mul(t.blueOffset.uniform)), b = e.sample(p).r, O = e.sample(g).g, x = e.sample(h).b, y = e.sample(r).a;
+    return i(b, O, x, y);
   }
 };
-var U = _;
+var S = R;
 export {
-  _ as n,
-  U as t
+  R as n,
+  S as t
 };

package/dist/core/{Circle-0WHV1HrM.js → Circle-C8ltF4BZ.js}

@@ -1,13 +1,15 @@
-import { O as d, m as h } from "./three.tsl-CgyjOhns.js";
-import { o as g, r as v } from "./transformations-Bs66Qh16.js";
-h();
-const y = {
+import { k as g, m as v } from "./three.tsl-BqgDcRt9.js";
+import { o as y, r as x } from "./transformations-DBjTkQ5b.js";
+v();
+const b = {
   name: "Circle",
-  category: "Shapes & Masks",
+  category: "Base Layers",
+  description: "Generate a circle with adjustable size and softness",
+  acceptsUVContext: !0,
   props: {
     color: {
       default: "#ffffff",
-      transform: v,
+      transform: x,
       description: "The color of the circle",
       ui: {
         type: "color",
@@ -41,7 +43,7 @@ const y = {
         x: 0.5,
         y: 0.5
       },
-      transform: g,
+      transform: y,
       description: "The center point of the circle",
       ui: {
         type: "position",
@@ -49,13 +51,13 @@ const y = {
       }
     }
   },
-  fragmentNode: ({ uniforms: e }) => {
-    const { vec2: t, vec4: i, length: c, smoothstep: a, screenUV: o, viewportSize: r } = d, s = r.x.div(r.y), l = t(o.x.mul(s), o.y), f = t(e.center.uniform.x.mul(s), e.center.uniform.y.oneMinus()), p = c(l.sub(f)), u = e.softness.uniform, n = e.radius.uniform.mul(0.5), m = a(n, n.sub(u), p);
-    return i(e.color.uniform.rgb, e.color.uniform.a.mul(m));
+  fragmentNode: ({ uniforms: e, uvContext: i }) => {
+    const { vec2: t, vec4: c, length: a, smoothstep: l, screenUV: f, viewportSize: o } = g, r = i ?? f, s = o.x.div(o.y), u = t(r.x.mul(s), r.y), p = t(e.center.uniform.x.mul(s), e.center.uniform.y.oneMinus()), d = a(u.sub(p)), m = e.softness.uniform, n = e.radius.uniform.mul(0.5), h = l(n, n.sub(m), d);
+    return c(e.color.uniform.rgb, e.color.uniform.a.mul(h));
   }
 };
-var C = y;
+var k = b;
 export {
-  y as n,
-  C as t
+  b as n,
+  k as t
 };

package/dist/core/{CursorTrail-3zQ5rtjh.js → CursorTrail-BeJGeovB.js}

@@ -1,11 +1,12 @@
-import { A as p, O as at, m as et } from "./three.tsl-CgyjOhns.js";
-import { i as ot, r as _, t as lt } from "./transformations-Bs66Qh16.js";
-import { t as rt } from "./colorMixing-C_ESXyqX.js";
+import { j as p, k as at, m as et } from "./three.tsl-BqgDcRt9.js";
+import { i as ot, r as _, t as rt } from "./transformations-DBjTkQ5b.js";
+import { t as lt } from "./colorMixing-DPZ-Td4U.js";
 import { DataTexture as st, FloatType as nt, LinearFilter as B, RGBAFormat as it } from "three";
 et();
 const ct = {
   name: "CursorTrail",
   category: "Interactive",
+  description: "Animated trail effect that tracks cursor movement",
   props: {
     colorA: {
       default: "#00aaff",
@@ -64,38 +65,38 @@ const ct = {
       description: "Color space for color interpolation",
       ui: {
         type: "select",
-        options: lt,
+        options: rt,
         label: "Color Space"
       }
     }
   },
-  fragmentNode: ({ uniforms: r, onBeforeRender: U, onCleanup: q }) => {
-    const { vec4: E, float: t, texture: G, step: H, screenUV: n } = at, a = 128, o = new Float32Array(a * a * 4), s = new st(o, a, a, it, nt);
+  fragmentNode: ({ uniforms: l, onBeforeRender: U, onCleanup: j }) => {
+    const { vec4: q, float: t, texture: E, step: G, screenUV: n } = at, a = 128, o = new Float32Array(a * a * 4), s = new st(o, a, a, it, nt);
     s.magFilter = B, s.minFilter = B, s.needsUpdate = !0;
-    const i = G(s);
+    const i = E(s);
     let y = 0.5, M = 0.5, g = Date.now();
-    U(({ pointer: l }) => {
+    U(({ pointer: r }) => {
       const T = Date.now(), f = Math.min((T - g) / 1e3, 0.016);
       g = T;
-      const h = r.radius.uniform.value * 0.1, b = r.length.uniform.value, j = r.shrink.uniform.value, F = l.x - y, w = l.y - M, z = Math.sqrt(F * F + w * w), N = 1 - f / Math.max(0.1, b), V = f / Math.max(0.1, b);
+      const h = l.radius.uniform.value * 0.1, b = l.length.uniform.value, N = l.shrink.uniform.value, F = r.x - y, w = r.y - M, z = Math.sqrt(F * F + w * w), O = 1 - f / Math.max(0.1, b), V = f / Math.max(0.1, b);
       for (let e = 0; e < a * a * 4; e += 4)
-        o[e] *= N, o[e + 1] = 1 - (1 - o[e]) * j, o[e + 2] = Math.min(1, o[e + 2] + V);
+        o[e] *= O, o[e + 1] = 1 - (1 - o[e]) * N, o[e + 2] = Math.min(1, o[e + 2] + V);
       if (z > 1e-3) {
-        const e = h * 3, Z = Math.max(0, Math.floor((l.x - e) * a)), K = Math.min(a - 1, Math.ceil((l.x + e) * a)), P = Math.max(0, Math.floor((l.y - e) * a)), Q = Math.min(a - 1, Math.ceil((l.y + e) * a));
+        const e = h * 3, Z = Math.max(0, Math.floor((r.x - e) * a)), K = Math.min(a - 1, Math.ceil((r.x + e) * a)), P = Math.max(0, Math.floor((r.y - e) * a)), Q = Math.min(a - 1, Math.ceil((r.y + e) * a));
         for (let m = P; m <= Q; m++) for (let d = Z; d <= K; d++) {
-          const u = (m * a + d) * 4, W = (d + 0.5) / a, $ = (m + 0.5) / a, I = W - l.x, R = $ - l.y, x = Math.sqrt(I * I + R * R);
+          const u = (m * a + d) * 4, W = (d + 0.5) / a, $ = (m + 0.5) / a, I = W - r.x, R = $ - r.y, x = Math.sqrt(I * I + R * R);
           if (x < e) {
             const tt = Math.exp(-x * x / (h * h)) * z * 50 * f;
             o[u] = Math.min(1, o[u] + tt), o[u + 1] = 1, o[u + 2] = 0;
           }
         }
       }
-      s.needsUpdate = !0, y = l.x, M = l.y;
-    }), q(() => {
+      s.needsUpdate = !0, y = r.x, M = r.y;
+    }), j(() => {
       s.dispose();
     });
-    const c = t(1 / a), C = i.sample(n), S = i.sample(n.add(p(c, t(0)))), v = i.sample(n.add(p(t(0), c))), A = i.sample(n.add(p(c.negate(), t(0)))), k = i.sample(n.add(p(t(0), c.negate()))), J = C.x.mul(t(0.5)).add(S.x.mul(t(0.125))).add(v.x.mul(t(0.125))).add(A.x.mul(t(0.125))).add(k.x.mul(t(0.125))), L = C.z.mul(t(0.5)).add(S.z.mul(t(0.125))).add(v.z.mul(t(0.125))).add(A.z.mul(t(0.125))).add(k.z.mul(t(0.125))), O = H(t(0.01), J), X = r.colorA.uniform, Y = r.colorB.uniform, D = rt(X, Y, L, r.colorSpace.uniform);
-    return E(D.rgb, D.a.mul(O));
+    const c = t(1 / a), C = i.sample(n), k = i.sample(n.add(p(c, t(0)))), v = i.sample(n.add(p(t(0), c))), S = i.sample(n.add(p(c.negate(), t(0)))), A = i.sample(n.add(p(t(0), c.negate()))), H = C.x.mul(t(0.5)).add(k.x.mul(t(0.125))).add(v.x.mul(t(0.125))).add(S.x.mul(t(0.125))).add(A.x.mul(t(0.125))), J = C.z.mul(t(0.5)).add(k.z.mul(t(0.125))).add(v.z.mul(t(0.125))).add(S.z.mul(t(0.125))).add(A.z.mul(t(0.125))), L = G(t(0.01), H), X = l.colorA.uniform, Y = l.colorB.uniform, D = lt(X, Y, J, l.colorSpace.uniform);
+    return q(D.rgb, D.a.mul(L));
   }
 };
 var ft = ct;

package/dist/core/DiffuseBlur-BdGvOoBw.js

@@ -0,0 +1,40 @@
+import { k as R, m as V } from "./three.tsl-BqgDcRt9.js";
+V();
+const k = {
+  name: "DiffuseBlur",
+  category: "Blurs",
+  description: "Soft focus blur using stochastic sampling",
+  requiresRTT: !0,
+  requiresChild: !0,
+  props: { intensity: {
+    default: 30,
+    description: "Intensity of the diffuse blur effect",
+    ui: {
+      type: "range",
+      min: 0,
+      max: 100,
+      step: 1,
+      label: "Intensity"
+    }
+  } },
+  fragmentNode: ({ uniforms: p, childNode: o, onCleanup: g }) => {
+    const { vec2: e, vec4: i, float: s, screenUV: v, convertToTexture: x, viewportSize: h, fract: T, sin: u, cos: y, dot: _, Fn: b } = R;
+    if (!o) return i(0, 0, 0, 0);
+    const n = x(o);
+    return g(() => {
+      n?.renderTarget?.dispose && n.renderTarget.dispose();
+    }), b(() => {
+      const a = v, S = p.intensity.uniform.mul(1), q = e(1).div(h), l = (t) => T(u(_(t, e(12.9898, 78.233).mul(2))).mul(43758.5453)), r = i(0).toVar(), c = 16;
+      for (let t = 0; t < c; t++) {
+        const d = a.mul(1e3).add(e(s(t * 11.7), s(t * 5.3))), B = l(d), C = l(d.add(e(73.2, 41.9))), f = B.mul(6.28318530718), m = C.sqrt().mul(S), D = e(y(f).mul(m), u(f).mul(m)).mul(q.x), z = a.add(D), I = n.sample(z);
+        r.assign(r.add(I));
+      }
+      return r.div(s(c));
+    })();
+  }
+};
+var F = k;
+export {
+  k as n,
+  F as t
+};

package/dist/core/{Dither-Cnbknfji.js → Dither-CpN3vGSh.js}

@@ -1,9 +1,10 @@
-import { O as v, m as z } from "./three.tsl-CgyjOhns.js";
-import { r as n } from "./transformations-Bs66Qh16.js";
-z();
-const S = {
+import { k as z, m as S } from "./three.tsl-BqgDcRt9.js";
+import { r as n } from "./transformations-DBjTkQ5b.js";
+S();
+const v = {
   name: "Dither",
-  category: "Effects",
+  category: "Stylize",
+  description: "Bayer matrix dithering to reduce colors",
   requiresChild: !0,
   props: {
     pixelSize: {
@@ -47,15 +48,15 @@ const S = {
       }
     }
   },
-  fragmentNode: ({ uniforms: t, childNode: r }) => {
-    const { vec2: u, vec3: f, vec4: o, floor: d, screenUV: p, viewportSize: m, dot: h, step: q, mix: s } = v;
-    if (!r) return o(0, 0, 0, 0);
-    const a = r, g = h(a.rgb, f(0.299, 0.587, 0.114)).mul(a.a), x = t.pixelSize.uniform, i = d(p.mul(m).div(x)).mod(u(4)), e = i.x, l = i.y, b = l.equal(0).select(e.equal(0).select(0 / 16, e.equal(1).select(8 / 16, e.equal(2).select(2 / 16, 10 / 16))), l.equal(1).select(e.equal(0).select(12 / 16, e.equal(1).select(4 / 16, e.equal(2).select(14 / 16, 6 / 16))), l.equal(2).select(e.equal(0).select(3 / 16, e.equal(1).select(11 / 16, e.equal(2).select(1 / 16, 9 / 16))), e.equal(0).select(15 / 16, e.equal(1).select(7 / 16, e.equal(2).select(13 / 16, 5 / 16)))))), y = t.threshold.uniform, c = q(b, g.add(y.sub(0.5)));
-    return o(s(t.colorA.uniform.rgb, t.colorB.uniform.rgb, c), s(t.colorA.uniform.a, t.colorB.uniform.a, c));
+  fragmentNode: ({ uniforms: t, childNode: o }) => {
+    const { vec2: u, vec3: d, vec4: l, floor: f, screenUV: p, viewportSize: m, dot: h, step: q, mix: i } = z;
+    if (!o) return l(0, 0, 0, 0);
+    const a = o, g = h(a.rgb, d(0.299, 0.587, 0.114)).mul(a.a), x = t.pixelSize.uniform, s = f(p.mul(m).div(x)).mod(u(4)), e = s.x, r = s.y, y = r.equal(0).select(e.equal(0).select(0 / 16, e.equal(1).select(8 / 16, e.equal(2).select(2 / 16, 10 / 16))), r.equal(1).select(e.equal(0).select(12 / 16, e.equal(1).select(4 / 16, e.equal(2).select(14 / 16, 6 / 16))), r.equal(2).select(e.equal(0).select(3 / 16, e.equal(1).select(11 / 16, e.equal(2).select(1 / 16, 9 / 16))), e.equal(0).select(15 / 16, e.equal(1).select(7 / 16, e.equal(2).select(13 / 16, 5 / 16)))))), b = t.threshold.uniform, c = q(y, g.add(b.sub(0.5)));
+    return l(i(t.colorA.uniform.rgb, t.colorB.uniform.rgb, c), i(t.colorA.uniform.a, t.colorB.uniform.a, c));
   }
 };
-var _ = S;
+var _ = v;
 export {
-  S as n,
+  v as n,
   _ as t
 };

package/dist/core/DotGrid-BFUzeSQw.js

@@ -0,0 +1,62 @@
+import { f as U, k as G, m as I } from "./three.tsl-BqgDcRt9.js";
+import { r as M } from "./transformations-DBjTkQ5b.js";
+I();
+const P = {
+  name: "DotGrid",
+  category: "Base Layers",
+  description: "Grid of dots with optional twinkling animation",
+  acceptsUVContext: !0,
+  props: {
+    color: {
+      default: "#ffffff",
+      description: "The color of the dot",
+      transform: M,
+      ui: {
+        type: "color",
+        label: "Color"
+      }
+    },
+    density: {
+      default: 100,
+      description: "The number of dots on the longest canvas edge",
+      ui: {
+        type: "range",
+        min: 10,
+        max: 500,
+        step: 10,
+        label: "Density"
+      }
+    },
+    dotSize: {
+      default: 0.3,
+      description: "The size of each dot, zero (0) being invisible, one (1) filled the grid with no gaps",
+      ui: {
+        type: "range",
+        min: 0,
+        max: 1,
+        step: 0.01,
+        label: "Dot Size"
+      }
+    },
+    twinkle: {
+      default: 0,
+      description: "Intensity of the twinkle effect (0 = off, 1 = full twinkle)",
+      ui: {
+        type: "range",
+        min: 0,
+        max: 1,
+        step: 0.01,
+        label: "Twinkle"
+      }
+    }
+  },
+  fragmentNode: ({ uniforms: t, uvContext: f }) => {
+    const { screenUV: m, vec4: u, vec2: p, smoothstep: h, length: o, floor: n, float: i, viewportSize: g, time: y, sin: w, mix: b } = G, s = f ?? m, l = t.density.uniform, r = t.dotSize.uniform, k = t.color.uniform, x = t.twinkle.uniform, a = g, v = a.x.div(a.y), d = p(s.x.mul(v), s.y.oneMinus()), e = d.mul(l), z = o(e.sub(n(e)).sub(0.5)), D = o(U(d.mul(l))), S = i(1).sub(h(r.mul(0.5), r.mul(0.5).add(D.mul(0.5)), z)), c = n(e), C = c.x.mul(12.9898).add(c.y.mul(78.233)).sin().mul(43758.5453).fract(), V = w(y.mul(2).add(C.mul(6.28318))).mul(0.5).add(0.5), _ = b(i(1), V, x), T = S.mul(_);
+    return u(k.rgb, T);
+  }
+};
+var L = P;
+export {
+  P as n,
+  L as t
+};

package/dist/core/{Duotone-BI4tJI3k.js → Duotone-_nR_o3-g.js}

@@ -1,10 +1,11 @@
-import { O as m, m as b } from "./three.tsl-CgyjOhns.js";
-import { i as C, r as a, t as g } from "./transformations-Bs66Qh16.js";
-import { t as T } from "./colorMixing-C_ESXyqX.js";
+import { k as f, m as b } from "./three.tsl-BqgDcRt9.js";
+import { i as C, r as a, t as g } from "./transformations-DBjTkQ5b.js";
+import { t as T } from "./colorMixing-DPZ-Td4U.js";
 b();
 const h = {
   name: "Duotone",
-  category: "Effects",
+  category: "Adjustments",
+  description: "Map colors to two tones based on luminance",
   requiresRTT: !0,
   requiresChild: !0,
   props: {
@@ -49,14 +50,14 @@ const h = {
     }
   },
   fragmentNode: ({ uniforms: o, childNode: r, onCleanup: s }) => {
-    const { vec3: l, vec4: t, dot: i, smoothstep: c, screenUV: p, convertToTexture: d } = m;
+    const { vec3: l, vec4: t, dot: i, smoothstep: c, screenUV: p, convertToTexture: d } = f;
     if (!r) return t(0, 0, 0, 0);
     const e = d(r);
     s(() => {
       e?.renderTarget?.dispose && e.renderTarget.dispose();
     });
-    const n = e.sample(p), u = i(n.rgb, l(0.299, 0.587, 0.114)), f = c(o.blend.uniform.sub(0.5), o.blend.uniform.add(0.5), u);
-    return t(T(o.colorA.uniform, o.colorB.uniform, f, o.colorSpace.uniform).rgb, n.a);
+    const n = e.sample(p), u = i(n.rgb, l(0.299, 0.587, 0.114)), m = c(o.blend.uniform.sub(0.5), o.blend.uniform.add(0.5), u);
+    return t(T(o.colorA.uniform, o.colorB.uniform, m, o.colorSpace.uniform).rgb, n.a);
   }
 };
 var B = h;

package/dist/core/FilmGrain-BAKXXtLg.js

@@ -0,0 +1,29 @@
+import { k as f, m as p } from "./three.tsl-BqgDcRt9.js";
+p();
+const d = {
+  name: "FilmGrain",
+  category: "Stylize",
+  description: "Analog film grain texture overlay",
+  requiresChild: !0,
+  acceptsUVContext: !0,
+  props: { strength: {
+    default: 0.5,
+    description: "Intensity of the film grain noise",
+    ui: {
+      type: "range",
+      min: 0,
+      max: 1,
+      step: 0.01,
+      label: "Strength"
+    }
+  } },
+  fragmentNode: ({ uniforms: r, childNode: i, uvContext: o }) => {
+    const { vec2: s, vec4: e, float: t, screenUV: a, sin: l, dot: m, fract: c } = f, u = r.strength.uniform, n = i || e(0, 0, 0, 0), g = c(l(m(o ?? a, s(t(12.9898), t(78.233)).mul(t(2)))).mul(t(43758.5453))).mul(t(2)).sub(t(1)).mul(u.mul(t(0.1)));
+    return e(n.rgb.add(g), n.a);
+  }
+};
+var y = d;
+export {
+  d as n,
+  y as t
+};

package/dist/core/FloatingParticles-Fv8JIzKk.js

@@ -0,0 +1,161 @@
+import { k as Q, m as W } from "./three.tsl-BqgDcRt9.js";
+import { r as X } from "./transformations-DBjTkQ5b.js";
+W();
+var { vec2: a, vec3: q, vec4: E, float: c, sin: g, cos: U, smoothstep: Y, mix: H, min: k, floor: Z, fract: I, length: j, dot: B, screenUV: $, viewportSize: N, time: w, Fn: m } = Q, ee = m(([e]) => I(g(B(e, a(127.1, 311.7))).mul(43758.5453123))), G = m(([e]) => I(g(a(B(e, a(127.1, 311.7)), B(e, a(269.5, 183.3)))).mul(43758.5453))), te = m(([e, n]) => {
+  const l = G(e).sub(0.5), u = g(n), x = U(n);
+  return a(x.mul(l.x).sub(u.mul(l.y)).mul(0.66), u.mul(l.x).add(x.mul(l.y)).mul(0.66)).add(e).add(0.5);
+}), ae = m(([e, n]) => w.mul(n).mul(ee(e).sub(0.5)).mul(2)), v = m(([e, n, l]) => {
+  const u = te(n, ae(n, l));
+  return j(e.sub(u));
+});
+const ne = {
+  name: "FloatingParticles",
+  category: "Base Layers",
+  description: "Animated floating particles with twinkle effects",
+  requiresRTT: !1,
+  acceptsUVContext: !0,
+  props: {
+    randomness: {
+      default: 0.25,
+      description: "Randomness of particle animation",
+      ui: {
+        type: "range",
+        min: 0,
+        max: 1,
+        step: 0.01,
+        label: "Randomness"
+      }
+    },
+    speed: {
+      default: 0.25,
+      description: "Speed of particle movement",
+      ui: {
+        type: "range",
+        min: 0,
+        max: 1,
+        step: 0.01,
+        label: "Speed"
+      }
+    },
+    angle: {
+      default: 90,
+      description: "Movement angle in degrees (0=right, 90=down, 180=left, 270=up)",
+      ui: {
+        type: "range",
+        min: 0,
+        max: 360,
+        step: 1,
+        label: "Angle"
+      }
+    },
+    particleSize: {
+      default: 1,
+      description: "Size of particles",
+      ui: {
+        type: "range",
+        min: 0.1,
+        max: 20,
+        step: 0.1,
+        label: "Particle Size"
+      }
+    },
+    particleSoftness: {
+      default: 0,
+      description: "Edge softness of particles (0 = sharp, 1 = very soft)",
+      ui: {
+        type: "range",
+        min: 0,
+        max: 5,
+        step: 0.01,
+        label: "Particle Softness"
+      }
+    },
+    twinkle: {
+      default: 0.5,
+      description: "Intensity of the twinkle effect (0 = off, 1 = full twinkle)",
+      ui: {
+        type: "range",
+        min: 0,
+        max: 1,
+        step: 0.01,
+        label: "Twinkle"
+      }
+    },
+    count: {
+      default: 5,
+      description: "Number of particle layers",
+      ui: {
+        type: "range",
+        min: 1,
+        max: 5,
+        step: 1,
+        label: "Count"
+      }
+    },
+    particleColor: {
+      default: "#ffffff",
+      transform: X,
+      description: "Color of the particles",
+      ui: {
+        type: "color",
+        label: "Particle Color"
+      }
+    },
+    speedVariance: {
+      default: 0.3,
+      description: "Per-layer speed variance (0 = all layers same speed, 1 = high variance)",
+      ui: {
+        type: "range",
+        min: 0,
+        max: 1,
+        step: 0.01,
+        label: "Speed Variance"
+      }
+    },
+    angleVariance: {
+      default: 30,
+      description: "Per-layer angle variance in degrees (0 = all layers same angle, 180 = full variance)",
+      ui: {
+        type: "range",
+        min: 0,
+        max: 180,
+        step: 1,
+        label: "Angle Variance"
+      }
+    },
+    particleDensity: {
+      default: 3,
+      description: "Particle density (lower = more spread out, higher = more dense)",
+      ui: {
+        type: "range",
+        min: 0.5,
+        max: 3,
+        step: 0.1,
+        label: "Particle Density"
+      }
+    }
+  },
+  fragmentNode: ({ uniforms: e, childNode: n, uvContext: l }) => {
+    const u = l ?? $, x = m(([s]) => {
+      const r = Z(s), p = I(s);
+      let t = v(s, r, e.randomness.uniform);
+      const y = e.particleSoftness.uniform, d = e.particleSize.uniform.mul(0.01), o = d.mul(0.6).add(y.mul(d.mul(2.4))), i = o.greaterThan(0.35), h = p.x.lessThan(0.4), V = p.x.greaterThan(0.6), R = p.y.lessThan(0.4), z = p.y.greaterThan(0.6), D = i.and(h), f = i.and(V), C = i.and(R), b = i.and(z);
+      t = D.select(k(t, v(s, r.add(a(-1, 0)), e.randomness.uniform)), t), t = f.select(k(t, v(s, r.add(a(1, 0)), e.randomness.uniform)), t), t = C.select(k(t, v(s, r.add(a(0, -1)), e.randomness.uniform)), t), t = b.select(k(t, v(s, r.add(a(0, 1)), e.randomness.uniform)), t);
+      const M = Y(o, d.mul(0.6), t), _ = e.twinkle.uniform, P = r.x.mul(12.9898).add(r.y.mul(78.233)).sin().mul(43758.5453).fract(), A = g(w.mul(2).add(P.mul(6.28318))).mul(0.5).add(0.5), F = H(c(1), A, _);
+      return M.mul(F).mul(e.particleColor.uniform.rgb);
+    }), J = m(([s]) => {
+      const r = c(1.05), p = c(0.9), t = e.count.uniform, y = q(0).toVar(), d = c(1).toVar(), o = c(1).toVar(), i = a(0).toVar(), h = e.angle.uniform.mul(3.14159).div(180), V = a(U(h), g(h)), R = w.mul(V).mul(e.speed.uniform), z = e.speedVariance.uniform, D = e.angleVariance.uniform.mul(3.14159).div(180);
+      for (let f = 0; f < 4; f++) {
+        const C = c(f).lessThan(t).and(o.greaterThan(0.02)), b = G(a(o, c(f).mul(7.919))), M = c(1).add(b.x.sub(0.5).mul(z)), _ = b.y.sub(0.5).mul(D).mul(2), P = h.add(_), A = a(U(P), g(P)), F = R.mul(M).add(A.sub(V).mul(w).mul(e.speed.uniform)), O = x(s.mul(d).add(F).add(i)).mul(o);
+        y.assign(y.add(C.select(O, q(0)))), i.assign(i.add(b.mul(10))), o.assign(o.mul(p)), d.assign(d.mul(r));
+      }
+      return y;
+    }), L = u.mul(2).sub(1), K = N.x.div(N.y), T = J(a(L.x.mul(K), L.y).mul(e.particleDensity.uniform)), S = j(T);
+    return n ? E(H(n.xyz, T, S.greaterThan(0.01).select(S, 0)), n.w) : E(T, S);
+  }
+};
+var le = ne;
+export {
+  ne as n,
+  le as t
+};