shaders 2.2.1 → 2.2.2

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

@@ -1,11 +1,12 @@
 import { j as p, k as at, m as et } from "./three.tsl-BqgDcRt9.js";
-import { i as ot, r as _, t as lt } from "./transformations-DBjTkQ5b.js";
-import { t as rt } from "./colorMixing-DPZ-Td4U.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,37 +65,37 @@ const ct = {
       description: "Color space for color interpolation",
       ui: {
         type: "select",
-        options: lt,
+        options: rt,
         label: "Color Space"
       }
     }
   },
-  fragmentNode: ({ uniforms: r, onBeforeRender: U, onCleanup: j }) => {
+  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 = 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, N = r.shrink.uniform.value, F = l.x - y, w = l.y - M, z = Math.sqrt(F * F + w * w), O = 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] *= 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;
+      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)))), k = i.sample(n.add(p(t(0), c))), v = 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(S.x.mul(t(0.125))).add(k.x.mul(t(0.125))).add(v.x.mul(t(0.125))).add(A.x.mul(t(0.125))), J = C.z.mul(t(0.5)).add(S.z.mul(t(0.125))).add(k.z.mul(t(0.125))).add(v.z.mul(t(0.125))).add(A.z.mul(t(0.125))), L = G(t(0.01), H), X = r.colorA.uniform, Y = r.colorB.uniform, D = rt(X, Y, J, r.colorSpace.uniform);
+    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));
   }
 };

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-MK-9r3tw.js → Dither-CpN3vGSh.js}

@@ -1,9 +1,10 @@
-import { k as v, m as z } from "./three.tsl-BqgDcRt9.js";
+import { k as z, m as S } from "./three.tsl-BqgDcRt9.js";
 import { r as n } from "./transformations-DBjTkQ5b.js";
-z();
-const S = {
+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-DP__DqQj.js → DotGrid-BFUzeSQw.js}

@@ -1,15 +1,16 @@
-import { f as U, k as M, m as G } from "./three.tsl-BqgDcRt9.js";
-import { r as I } from "./transformations-DBjTkQ5b.js";
-G();
+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: "Shapes & Masks",
+  category: "Base Layers",
+  description: "Grid of dots with optional twinkling animation",
   acceptsUVContext: !0,
   props: {
     color: {
       default: "#ffffff",
       description: "The color of the dot",
-      transform: I,
+      transform: M,
       ui: {
         type: "color",
         label: "Color"
@@ -50,12 +51,12 @@ const P = {
     }
   },
   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 } = M, 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), c = p(s.x.mul(v), s.y.oneMinus()), e = c.mul(l), z = o(e.sub(n(e)).sub(0.5)), S = o(U(c.mul(l))), D = i(1).sub(h(r.mul(0.5), r.mul(0.5).add(S.mul(0.5)), z)), d = n(e), C = d.x.mul(12.9898).add(d.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 = D.mul(_);
+    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 j = P;
+var L = P;
 export {
   P as n,
-  j as t
+  L as t
 };

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

@@ -1,10 +1,11 @@
-import { k as m, m as b } from "./three.tsl-BqgDcRt9.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-CxcXDtZg.js → FloatingParticles-Fv8JIzKk.js}

@@ -1,16 +1,17 @@
 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: L, vec4: N, float: c, sin: g, cos: U, smoothstep: Y, mix: q, min: k, floor: Z, fract: B, length: j, dot: I, screenUV: $, viewportSize: H, time: T, Fn: m } = Q, ee = m(([e]) => B(g(I(e, a(127.1, 311.7))).mul(43758.5453123))), G = m(([e]) => B(g(a(I(e, a(127.1, 311.7)), I(e, a(269.5, 183.3)))).mul(43758.5453))), te = m(([e, n]) => {
+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]) => T.mul(n).mul(ee(e).sub(0.5)).mul(2)), v = m(([e, n, l]) => {
+}), 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: "Effects",
+  category: "Base Layers",
+  description: "Animated floating particles with twinkle effects",
   requiresRTT: !1,
   acceptsUVContext: !0,
   props: {
@@ -136,21 +137,21 @@ const ne = {
   },
   fragmentNode: ({ uniforms: e, childNode: n, uvContext: l }) => {
     const u = l ?? $, x = m(([s]) => {
-      const r = Z(s), p = B(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(T.mul(2).add(P.mul(6.28318))).mul(0.5).add(0.5), F = q(c(1), A, _);
+      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 = L(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 = T.mul(V).mul(e.speed.uniform), z = e.speedVariance.uniform, D = e.angleVariance.uniform.mul(3.14159).div(180);
+      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(T).mul(e.speed.uniform)), O = x(s.mul(d).add(F).add(i)).mul(o);
-        y.assign(y.add(C.select(O, L(0)))), i.assign(i.add(b.mul(10))), o.assign(o.mul(p)), d.assign(d.mul(r));
+        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;
-    }), E = u.mul(2).sub(1), K = H.x.div(H.y), S = J(a(E.x.mul(K), E.y).mul(e.particleDensity.uniform)), w = j(S);
-    return n ? N(q(n.xyz, S, w.greaterThan(0.01).select(w, 0)), 1) : N(S, w);
+    }), 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;

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-Cz3ImaBH.js → Glow-DvJj7BB7.js}

@@ -1,8 +1,9 @@
-import { k as R, m as U } from "./three.tsl-BqgDcRt9.js";
-U();
+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 } = R;
+    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), k = w(p.rgb, h(0.299, 0.587, 0.114)), q = d(t(0), k.sub(G)), E = p.mul(q);
-        n.assign(n.add(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-BHfh6URI.js → Godrays-cUzAKVXn.js}

@@ -1,9 +1,10 @@
-import { k as A, m as L, t as M } from "./three.tsl-BqgDcRt9.js";
+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";
-L();
+E();
 const z = {
   name: "Godrays",
-  category: "Effects",
+  category: "Base Layers",
+  description: "Volumetric light rays emanating from a point",
   requiresRTT: !1,
   acceptsUVContext: !0,
   props: {
@@ -82,20 +83,20 @@ const z = {
       }
     }
   },
-  fragmentNode: ({ uniforms: s, uvContext: v }) => {
-    const { vec2: c, vec4: R, float: a, sin: T, atan2: D, length: P, pow: h, smoothstep: S, mix: m, clamp: x, screenUV: U, time: w, PI: B, Fn: b } = A, E = v ?? U, F = c(s.center.uniform.x, s.center.uniform.y.oneMinus()), d = E.sub(F), 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 = D(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);
-      return m(h(C(y), o), p, S(-0.15, 0.15, n.x));
-    }), k = b(() => {
-      const n = w.mul(s.speed.uniform).mul(0.2), t = P(d), e = a(6.5).mul(M(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 N = t.mul(1.4).sub(n.mul(2.5)), q = t.mul(0.7).mul(a(1).add(e)).sub(n.mul(1.8)), V = l.mul(4.5), g = f(d, N, V, o).toVar();
-      return g.assign(g.mul(f(d, q, V.mul(3.5), o))), r.assign(r.add(g.mul(0.7))), x(r, 0, 1);
-    })(), G = s.rayColor.uniform.rgb, I = s.backgroundColor.uniform.rgb;
-    return R(m(I, G, k), s.backgroundColor.uniform.a.add(k.mul(s.rayColor.uniform.a)));
+  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 = 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 K = z;

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

@@ -3,7 +3,8 @@ 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-BvM0M3Hl.js → Grid-Bov7AA9m.js}

@@ -1,14 +1,15 @@
-import { k as b, m as M } from "./three.tsl-BqgDcRt9.js";
-import { r as T } from "./transformations-DBjTkQ5b.js";
-M();
-const _ = {
+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: "Shapes & Masks",
+  category: "Base Layers",
+  description: "Simple grid lines pattern with adjustable thickness",
   acceptsUVContext: !0,
   props: {
     color: {
       default: "#ffffff",
-      transform: T,
+      transform: _,
       description: "The color of the grid lines",
       ui: {
         type: "color",
@@ -39,12 +40,12 @@ const _ = {
     }
   },
   fragmentNode: ({ uniforms: e, uvContext: l }) => {
-    const { vec2: a, vec4: d, fract: m, max: f, screenUV: p, viewportSize: s, fwidth: u, smoothstep: n } = b, r = l ?? p, h = s.x.div(s.y), g = a(r.x.mul(h), r.y.oneMinus()), x = e.cells.uniform, i = g.mul(x), t = m(i), o = e.thickness.uniform.mul(0.01), y = t.x.min(t.x.oneMinus()), k = t.y.min(t.y.oneMinus()), c = u(i), v = f(n(o.add(c.x), o, y), n(o.add(c.y), o, k));
+    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 = _;
+var V = C;
 export {
-  _ as n,
+  C as n,
   V as t
 };

package/dist/core/{GridDistortion-yjmNv0Q3.js → GridDistortion-CWYom5Dw.js}

@@ -20,6 +20,7 @@ var ie = 20, f = /* @__PURE__ */ new WeakMap(), re = (e) => {
 const se = {
   name: "GridDistortion",
   category: "Interactive",
+  description: "Interactive grid distortion controlled by mouse position",
   requiresRTT: !0,
   requiresChild: !0,
   props: {
@@ -108,27 +109,27 @@ const se = {
   },
   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, R = 0.5, _ = Date.now();
+    let F = 0.5, I = 0.5, R = Date.now();
     if (t(({ pointer: o }) => {
-      const G = Date.now(), i = Math.min((G - _) / 1e3, 0.016);
-      _ = G;
-      const V = i > 0 ? (o.x - F) / i : 0, X = i > 0 ? (o.y - R) / i : 0;
+      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, D = P - o.y, b = Math.sqrt(S * S + D * D);
-        if (b < y * 2 && Math.abs(V) + Math.abs(X) > 0.01) {
-          const p = Math.exp(-b * b / (y * y));
+        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(D, S) + Math.PI * 0.5;
+            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, R = o.y;
+      z.needsUpdate = !0, F = o.x, I = o.y;
     }), l(() => {
       z.dispose(), f.delete(e);
     }), !s) return k(0, 0, 0, 0);
@@ -136,7 +137,7 @@ const se = {
     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, I = g(0.1), U = g(-0.1), Z = W.clamp(n(U, U), n(I, I)), E = w.sub(Z);
+    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);
   }
 };

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-DWIVrS2s.js → Halftone-F7fsdu7W.js}

@@ -1,9 +1,10 @@
-import { k as A, m as D } from "./three.tsl-BqgDcRt9.js";
-import { n as E } from "./transformations-DBjTkQ5b.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 w = F;
+var E = F;
 export {
   F as n,
-  w as t
+  E as t
 };

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

@@ -3,7 +3,8 @@ 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,