shaders 2.2.23 → 2.2.25

package/dist/core/DiffuseBlur-C_n01ABk.js

@@ -1,69 +0,0 @@
-import { O as v } from "./three.tsl-Btj1hLsf.js";
-import { t as w } from "./edges-CDzKsauJ.js";
-import { a as S } from "./transformations-CsrIJXh-.js";
-const z = {
-  name: "DiffuseBlur",
-  category: "Blurs",
-  description: "Grain-like pixel displacement at random",
-  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"
-      }
-    },
-    edges: {
-      default: "stretch",
-      description: "How to handle edges when distortion pushes content out of bounds",
-      transform: S,
-      ui: {
-        type: "select",
-        options: [
-          {
-            label: "Stretch",
-            value: "stretch"
-          },
-          {
-            label: "Transparent",
-            value: "transparent"
-          },
-          {
-            label: "Mirror",
-            value: "mirror"
-          },
-          {
-            label: "Wrap",
-            value: "wrap"
-          }
-        ],
-        label: "Edges"
-      }
-    }
-  },
-  uvTransformNode: ({ uv: r, uniforms: s, viewportSize: u }) => {
-    const { vec2: e, fract: l, sin: d, dot: c } = v, n = (i) => l(d(c(i, e(12.9898, 78.233).mul(2))).mul(43758.5453)), m = e(1).div(u), o = r.mul(1e3), f = n(o), t = n(o.add(e(73.2, 41.9))), a = e(f.mul(2).sub(1), t.mul(2).sub(1)).mul(s.intensity.uniform).mul(m);
-    return r.add(a);
-  },
-  fragmentNode: ({ uniforms: r, childNode: s, onCleanup: u }) => {
-    const { vec2: e, vec4: l, screenUV: d, convertToTexture: c, viewportSize: n, fract: m, sin: o, dot: f } = v;
-    if (!s) return l(0, 0, 0, 0);
-    const t = c(s);
-    u(() => {
-      t?.renderTarget?.dispose && t.renderTarget.dispose();
-    });
-    const a = (x) => m(o(f(x, e(12.9898, 78.233).mul(2))).mul(43758.5453)), i = d, b = e(1).div(n), p = i.mul(1e3), g = a(p), y = a(p.add(e(73.2, 41.9))), T = e(g.mul(2).sub(1), y.mul(2).sub(1)).mul(r.intensity.uniform).mul(b), h = i.add(T);
-    return w(h, t.sample(h), t, r.edges.uniform);
-  }
-};
-var _ = z;
-export {
-  z as n,
-  _ as t
-};

package/dist/core/Dither-4s-c4zh4.js

@@ -1,61 +0,0 @@
-import { O as z } from "./three.tsl-Btj1hLsf.js";
-import { r as n } from "./transformations-CsrIJXh-.js";
-const S = {
-  name: "Dither",
-  category: "Stylize",
-  description: "Bayer matrix dithering to reduce colors",
-  requiresChild: !0,
-  props: {
-    pixelSize: {
-      default: 4,
-      description: "Size of dithering pixels",
-      ui: {
-        type: "range",
-        min: 1,
-        max: 20,
-        step: 1,
-        label: "Pixel Size"
-      }
-    },
-    threshold: {
-      default: 0.5,
-      description: "Luminance threshold for dithering",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 1,
-        step: 0.01,
-        label: "Threshold"
-      }
-    },
-    colorA: {
-      default: "transparent",
-      transform: n,
-      description: "Dark color for dithering",
-      ui: {
-        type: "color",
-        label: "Dark Color"
-      }
-    },
-    colorB: {
-      default: "#ffffff",
-      transform: n,
-      description: "Light color for dithering",
-      ui: {
-        type: "color",
-        label: "Light Color"
-      }
-    }
-  },
-  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 D = S;
-export {
-  S as n,
-  D as t
-};

package/dist/core/DotGrid-BYl8XdMi.js

@@ -1,61 +0,0 @@
-import { O as G, f as _ } from "./three.tsl-Btj1hLsf.js";
-import { r as I } from "./transformations-CsrIJXh-.js";
-const M = {
-  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: I,
-      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, x = t.color.uniform, k = 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(_(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), T = b(i(1), V, k), U = S.mul(T);
-    return u(x.rgb, U);
-  }
-};
-var B = M;
-export {
-  M as n,
-  B as t
-};

package/dist/core/Duotone-DbewOoB4.js

@@ -1,66 +0,0 @@
-import { O as m } from "./three.tsl-Btj1hLsf.js";
-import { i as b, r as a, t as C } from "./transformations-CsrIJXh-.js";
-import { t as g } from "./colorMixing--dhzx0ch.js";
-const T = {
-  name: "Duotone",
-  category: "Adjustments",
-  description: "Map colors to two tones based on luminance",
-  requiresRTT: !0,
-  requiresChild: !0,
-  props: {
-    colorA: {
-      default: "#ff0000",
-      transform: a,
-      description: "First color (used for darker areas)",
-      ui: {
-        type: "color",
-        label: "Color A"
-      }
-    },
-    colorB: {
-      default: "#023af4",
-      transform: a,
-      description: "Second color (used for brighter areas)",
-      ui: {
-        type: "color",
-        label: "Color B"
-      }
-    },
-    blend: {
-      default: 0.5,
-      description: "Blend point between the two colors",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 1,
-        step: 0.01,
-        label: "Blend"
-      }
-    },
-    colorSpace: {
-      default: "linear",
-      transform: b,
-      description: "Color space for color interpolation",
-      ui: {
-        type: "select",
-        options: C,
-        label: "Color Space"
-      }
-    }
-  },
-  fragmentNode: ({ uniforms: o, childNode: r, onCleanup: s }) => {
-    const { vec3: l, vec4: t, dot: i, smoothstep: c, screenUV: p, convertToTexture: d } = m;
-    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(g(o.colorA.uniform, o.colorB.uniform, f, o.colorSpace.uniform).rgb, n.a);
-  }
-};
-var y = T;
-export {
-  T as n,
-  y as t
-};

package/dist/core/FilmGrain-zA_-knOw.js

@@ -1,28 +0,0 @@
-import { O as f } from "./three.tsl-Btj1hLsf.js";
-const p = {
-  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: o, uvContext: i }) => {
-    const { vec2: s, vec4: e, float: t, screenUV: a, sin: l, dot: m, fract: c } = f, u = r.strength.uniform, n = o || e(0, 0, 0, 0), g = c(l(m(i ?? 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 h = p;
-export {
-  p as n,
-  h as t
-};

package/dist/core/FloatingParticles-BhVnqMsE.js

@@ -1,160 +0,0 @@
-import { O as Q } from "./three.tsl-Btj1hLsf.js";
-import { r as W } from "./transformations-CsrIJXh-.js";
-var { vec2: a, vec3: q, vec4: E, float: c, sin: g, cos: _, smoothstep: X, mix: H, min: w, floor: Y, fract: I, length: O, dot: B, screenUV: Z, viewportSize: N, time: k, Fn: m } = Q, $ = m(([e]) => I(g(B(e, a(127.1, 311.7))).mul(43758.5453123))), j = m(([e]) => I(g(a(B(e, a(127.1, 311.7)), B(e, a(269.5, 183.3)))).mul(43758.5453))), ee = m(([e, n]) => {
-  const l = j(e).sub(0.5), u = g(n), x = _(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);
-}), te = m(([e, n]) => k.mul(n).mul($(e).sub(0.5)).mul(2)), v = m(([e, n, l]) => {
-  const u = ee(n, te(n, l));
-  return O(e.sub(u));
-});
-const ae = {
-  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: W,
-      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 ?? Z, x = m(([s]) => {
-      const r = Y(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(w(t, v(s, r.add(a(-1, 0)), e.randomness.uniform)), t), t = f.select(w(t, v(s, r.add(a(1, 0)), e.randomness.uniform)), t), t = C.select(w(t, v(s, r.add(a(0, -1)), e.randomness.uniform)), t), t = b.select(w(t, v(s, r.add(a(0, 1)), e.randomness.uniform)), t);
-      const M = X(o, d.mul(0.6), t), A = e.twinkle.uniform, P = r.x.mul(12.9898).add(r.y.mul(78.233)).sin().mul(43758.5453).fract(), F = g(k.mul(2).add(P.mul(6.28318))).mul(0.5).add(0.5), U = H(c(1), F, A);
-      return M.mul(U).mul(e.particleColor.uniform.rgb);
-    }), G = 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(_(h), g(h)), R = k.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 = j(a(o, c(f).mul(7.919))), M = c(1).add(b.x.sub(0.5).mul(z)), A = b.y.sub(0.5).mul(D).mul(2), P = h.add(A), F = a(_(P), g(P)), U = R.mul(M).add(F.sub(V).mul(k).mul(e.speed.uniform)), K = x(s.mul(d).add(U).add(i)).mul(o);
-        y.assign(y.add(C.select(K, 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), J = N.x.div(N.y), T = G(a(L.x.mul(J), L.y).mul(e.particleDensity.uniform)), S = O(T);
-    return n ? E(H(n.xyz, T, S.greaterThan(0.01).select(S, 0)), n.w) : E(T, S);
-  }
-};
-var re = ae;
-export {
-  ae as n,
-  re as t
-};

package/dist/core/GlassTiles-CFI57glh.js

@@ -1,52 +0,0 @@
-import { O as b } from "./three.tsl-Btj1hLsf.js";
-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: n, 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), o = r(l(e.greaterThanEqual(1), t.mul(e), t), l(e.lessThan(1), t.div(e), t)), c = a(n.mul(o)).div(o), d = n.sub(c), T = r(0.5, 0.5), h = p.mul(0.025), u = d.div(r(1, 1).div(o)).sub(T).mul(h);
-    return d.add(u).add(c);
-  },
-  fragmentNode: ({ uniforms: n, childNode: s, dimensions: i, onCleanup: r }) => {
-    const { vec2: a, vec4: l, floor: p, mul: t, div: e, sub: o, 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 = n.intensity.uniform, f = n.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 = o(g, v), U = a(0.5, 0.5), q = t(x, 0.025), R = c(c(y, t(o(e(y, e(a(1), C)), U), q)), v);
-    return l(u.sample(R));
-  }
-};
-var N = V;
-export {
-  V as n,
-  N as t
-};

package/dist/core/Glow-CQgl3IoS.js

@@ -1,66 +0,0 @@
-import { O as j } from "./three.tsl-Btj1hLsf.js";
-const k = {
-  name: "Glow",
-  category: "Stylize",
-  description: "Soft glow effect with adjustable intensity",
-  requiresRTT: !0,
-  requiresChild: !0,
-  props: {
-    intensity: {
-      default: 1,
-      description: "Glow intensity (brightness of the glow effect)",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 10,
-        step: 0.01,
-        label: "Intensity"
-      }
-    },
-    threshold: {
-      default: 0.5,
-      description: "Brightness threshold for glow extraction (lower = more glow)",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 1,
-        step: 0.01,
-        label: "Threshold"
-      }
-    },
-    size: {
-      default: 10,
-      description: "Size/spread of the glow effect",
-      ui: {
-        type: "range",
-        min: 1,
-        max: 20,
-        step: 0.01,
-        label: "Glow Size"
-      }
-    }
-  },
-  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: y, Fn: x } = j;
-    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 = 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 V = c(t(i), t(l)).mul(G).mul(z), _ = f.add(V), m = o.sample(_), q = w(m.rgb, h(0.299, 0.587, 0.114)), R = d(t(0), q.sub(S)), U = m.mul(R);
-        n.assign(n.add(U));
-      }
-      const C = t((e * 2 + 1) * (e * 2 + 1));
-      return n.div(C);
-    })(), T = s.intensity.uniform, p = v.mul(T);
-    return r(u.rgb.add(p.rgb), d(u.a, p.a));
-  }
-};
-var D = k;
-export {
-  k as n,
-  D as t
-};

package/dist/core/Godrays-BHMix_Bh.js

@@ -1,105 +0,0 @@
-import { O as J, t as K } from "./three.tsl-Btj1hLsf.js";
-import { o as Q, r as v } from "./transformations-CsrIJXh-.js";
-const W = {
-  name: "Godrays",
-  category: "Base Layers",
-  description: "Volumetric light rays emanating from a point",
-  requiresRTT: !1,
-  acceptsUVContext: !0,
-  props: {
-    center: {
-      default: {
-        x: 0,
-        y: 0
-      },
-      transform: Q,
-      description: "The center point of the god rays",
-      ui: {
-        type: "position",
-        label: "Center"
-      }
-    },
-    density: {
-      default: 0.3,
-      description: "Frequency of ray sectors",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 1,
-        step: 0.01,
-        label: "Density"
-      }
-    },
-    intensity: {
-      default: 0.8,
-      description: "Ray visibility within sectors",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 1,
-        step: 0.01,
-        label: "Intensity"
-      }
-    },
-    spotty: {
-      default: 1,
-      description: "Density of spots on rays (higher = more spots)",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 1,
-        step: 0.01,
-        label: "Spotty"
-      }
-    },
-    speed: {
-      default: 0.5,
-      description: "Animation speed of the rays",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 2,
-        step: 0.01,
-        label: "Speed"
-      }
-    },
-    rayColor: {
-      default: "#4283fb",
-      transform: v,
-      description: "Color of the light rays",
-      ui: {
-        type: "color",
-        label: "Ray Color"
-      }
-    },
-    backgroundColor: {
-      default: "transparent",
-      transform: v,
-      description: "Background color",
-      ui: {
-        type: "color",
-        label: "Background Color"
-      }
-    }
-  },
-  fragmentNode: ({ uniforms: s, uvContext: B }) => {
-    const { vec2: c, vec4: G, float: r, sin: T, atan: D, length: P, pow: x, smoothstep: S, mix: p, clamp: g, screenUV: U, time: _, PI: w, Fn: h } = J, F = B ?? U, I = c(s.center.uniform.x, s.center.uniform.y.oneMinus()), m = F.sub(I), V = h(([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), a = o(t.add(c(1, 0))), d = o(t.add(c(0, 1))), y = o(t.add(c(1, 1))), i = e.mul(e).mul(e.mul(-2).add(3));
-      return p(p(l, a, i.x), p(d, y, i.x), i.y);
-    }), f = h(([n, t, e, o]) => {
-      const l = D(n.y, n.x), a = c(l.mul(e), t), d = c(l.mod(w.mul(2)).mul(e), t), y = x(V(a), o);
-      return p(x(V(d), o), y, S(-0.15, 0.15, n.x));
-    }), L = h(() => {
-      const n = _.mul(s.speed.uniform).mul(0.2), t = P(m), e = r(6.5).mul(K(s.spotty.uniform)), o = r(4).sub(r(3).mul(g(s.intensity.uniform, 0, 1))), l = r(6).mul(s.density.uniform), a = r(0).toVar(), d = t.mul(1).sub(n.mul(3)), y = t.mul(0.5).mul(r(1).add(e)).sub(n.mul(2)), i = l.mul(5), u = f(m, d, i, o).toVar();
-      u.assign(u.mul(f(m, y, i.mul(4), o))), a.assign(a.add(u));
-      const z = t.mul(1.4).sub(n.mul(2.5)), H = t.mul(0.7).mul(r(1).add(e)).sub(n.mul(1.8)), k = l.mul(4.5), C = f(m, z, k, o).toVar();
-      return C.assign(C.mul(f(m, H, k.mul(3.5), o))), a.assign(a.add(C.mul(0.7))), g(a, 0, 1);
-    })(), N = s.rayColor.uniform.rgb, q = s.rayColor.uniform.a, E = s.backgroundColor.uniform.rgb, A = s.backgroundColor.uniform.a, b = L.mul(q), R = b.add(A.mul(r(1).sub(b))), M = g(R, 1e-3, 1), O = N.mul(b), j = E.mul(A).mul(r(1).sub(b));
-    return G(O.add(j).div(M), R);
-  }
-};
-var Z = W;
-export {
-  W as n,
-  Z as t
-};

package/dist/core/Grayscale-CAEFLteL.js

@@ -1,21 +0,0 @@
-import { O as t } from "./three.tsl-Btj1hLsf.js";
-import { t as s } from "./ColorAdjustment-CKwpE_4M.js";
-const a = {
-  name: "Grayscale",
-  category: "Adjustments",
-  description: "Convert colors to black and white",
-  requiresChild: !0,
-  props: {},
-  fragmentNode: ({ childNode: e }) => {
-    const { vec4: r } = t;
-    if (!e)
-      return console.error("You must pass a child component into the Grayscale shader."), r(0);
-    const o = e || r(0, 0, 0, 0);
-    return r(s(o.rgb).rgb, o.a);
-  }
-};
-var i = a;
-export {
-  a as n,
-  i as t
-};