shaders 2.2.0 → 2.2.1

package/dist/core/FloatingParticles-CxcXDtZg.js

@@ -0,0 +1,160 @@
+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]) => {
+  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]) => {
+  const u = te(n, ae(n, l));
+  return j(e.sub(u));
+});
+const ne = {
+  name: "FloatingParticles",
+  category: "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 = B(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, _);
+      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);
+      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));
+      }
+      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);
+  }
+};
+var le = ne;
+export {
+  ne as n,
+  le as t
+};

package/dist/core/GlassTiles-CxUl9MxF.js

@@ -0,0 +1,52 @@
+import { k as b, m as V } from "./three.tsl-BqgDcRt9.js";
+V();
+const G = {
+  name: "GlassTiles",
+  category: "Distortions",
+  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: n, viewportSize: i }) => {
+    const { vec2: r, floor: l, select: a } = b, p = n.intensity.uniform, t = n.tileCount.uniform, e = i.x.div(i.y), s = r(a(e.greaterThanEqual(1), t.mul(e), t), a(e.lessThan(1), t.div(e), t)), c = l(o.mul(s)).div(s), d = o.sub(c), T = r(0.5, 0.5), h = p.mul(0.025), u = d.div(r(1, 1).div(s)).sub(T).mul(h);
+    return d.add(u).add(c);
+  },
+  fragmentNode: ({ uniforms: o, childNode: n, dimensions: i, onCleanup: r }) => {
+    const { vec2: l, vec4: a, floor: p, mul: t, div: e, sub: s, add: c, screenUV: d, uniform: T, convertToTexture: h } = b;
+    if (!n)
+      return console.error("You must pass a child component into the Glass Tiles shader."), a(0);
+    const u = h(n);
+    r(() => {
+      u?.renderTarget?.dispose && u.renderTarget.dispose();
+    });
+    const m = T(i.width / i.height), v = d, x = o.intensity.uniform, f = o.tileCount.uniform, C = l(m.greaterThanEqual(1).select(t(f, m), f), m.lessThan(1).select(e(f, m), f)), y = e(p(t(v, C)), C), g = s(v, y), U = l(0.5, 0.5), _ = t(x, 0.025), q = c(c(g, t(s(e(g, e(l(1), C)), U), _)), y);
+    return a(u.sample(q));
+  }
+};
+var R = G;
+export {
+  G as n,
+  R as t
+};

package/dist/core/{Glow-BD0t9E1L.js → Glow-Cz3ImaBH.js}

@@ -1,5 +1,5 @@
-import { O as U, m as k } from "./three.tsl-CgyjOhns.js";
-k();
+import { k as R, m as U } from "./three.tsl-BqgDcRt9.js";
+U();
 const B = {
   name: "Glow",
   category: "Effects",
@@ -41,7 +41,7 @@ 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 } = U;
+    const { vec2: c, vec3: h, vec4: r, float: t, max: d, dot: w, screenUV: f, convertToTexture: b, viewportSize: x, Fn: y } = R;
     if (!a) return r(0, 0, 0, 0);
     const o = b(a);
     g(() => {
@@ -50,8 +50,8 @@ const B = {
     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;
       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), q = w(p.rgb, h(0.299, 0.587, 0.114)), E = d(t(0), q.sub(G)), R = p.mul(E);
-        n.assign(n.add(R));
+        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 _ = t((e * 2 + 1) * (e * 2 + 1));
       return n.div(_);

package/dist/core/{Godrays-CPIAbymT.js → Godrays-BHfh6URI.js}

@@ -1,17 +1,18 @@
-import { O as U, m as q, t as A } from "./three.tsl-CgyjOhns.js";
-import { o as L, r as _ } from "./transformations-Bs66Qh16.js";
-q();
-const M = {
+import { k as A, m as L, t as M } from "./three.tsl-BqgDcRt9.js";
+import { o as j, r as _ } from "./transformations-DBjTkQ5b.js";
+L();
+const z = {
   name: "Godrays",
   category: "Effects",
   requiresRTT: !1,
+  acceptsUVContext: !0,
   props: {
     center: {
       default: {
         x: 0,
         y: 0
       },
-      transform: L,
+      transform: j,
       description: "The center point of the god rays",
       ui: {
         type: "position",
@@ -81,24 +82,24 @@ const M = {
       }
     }
   },
-  fragmentNode: ({ uniforms: s }) => {
-    const { vec2: c, vec4: R, float: a, sin: T, atan2: v, length: D, pow: h, smoothstep: P, mix: m, clamp: x, screenUV: S, time: w, PI: B, Fn: b } = U, E = c(s.center.uniform.x, s.center.uniform.y.oneMinus()), d = S.sub(E), C = b(([n]) => {
+  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 = v(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, P(-0.15, 0.15, n.x));
+      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 = D(d), e = a(6.5).mul(A(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();
+      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 I = t.mul(1.4).sub(n.mul(2.5)), N = t.mul(0.7).mul(a(1).add(e)).sub(n.mul(1.8)), V = l.mul(4.5), g = f(d, I, V, o).toVar();
-      return g.assign(g.mul(f(d, N, V.mul(3.5), o))), r.assign(r.add(g.mul(0.7))), x(r, 0, 1);
-    })(), F = s.rayColor.uniform.rgb, G = s.backgroundColor.uniform.rgb;
-    return R(m(G, F, k), s.backgroundColor.uniform.a.add(k.mul(s.rayColor.uniform.a)));
+      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)));
   }
 };
-var z = M;
+var K = z;
 export {
-  M as n,
-  z as t
+  z as n,
+  K as t
 };

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

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

package/dist/core/{Grid-Ro0Yi5WY.js → Grid-BvM0M3Hl.js}

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

package/dist/core/GridDistortion-yjmNv0Q3.js

@@ -0,0 +1,147 @@
+import { O as $, k as B, m as J } from "./three.tsl-BqgDcRt9.js";
+import { t as K } from "./edges-B-tVdqcI.js";
+import { a as Q } from "./transformations-DBjTkQ5b.js";
+import { DataTexture as ee, FloatType as te, LinearFilter as C, RGFormat as ae } from "three";
+J();
+var ie = 20, f = /* @__PURE__ */ new WeakMap(), re = (e) => {
+  let t = f.get(e);
+  const s = e?.gridSize?.uniform?.value ? Math.max(8, Math.min(128, Math.floor(e.gridSize.uniform.value))) : ie;
+  if (t && t.gridSize !== s && (t.texture.dispose(), t = void 0, f.delete(e)), !t) {
+    const l = new Float32Array(s * s * 2), n = new ee(l, s, s, ae, te);
+    n.magFilter = C, n.minFilter = C, n.needsUpdate = !0, t = {
+      texture: n,
+      data: l,
+      tslNode: $(n),
+      gridSize: s
+    }, f.set(e, t);
+  }
+  return t;
+};
+const se = {
+  name: "GridDistortion",
+  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",
+      ui: {
+        type: "range",
+        min: 0,
+        max: 2,
+        step: 0.1,
+        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"
+      }
+    },
+    gridSize: {
+      default: 20,
+      description: "Resolution of the distortion grid (higher = more detailed)",
+      ui: {
+        type: "range",
+        min: 8,
+        max: 128,
+        step: 1,
+        label: "Grid Size"
+      }
+    },
+    edges: {
+      default: "stretch",
+      description: "How to handle edges when distortion pushes content out of bounds",
+      transform: Q,
+      ui: {
+        type: "select",
+        options: [
+          {
+            label: "Stretch",
+            value: "stretch"
+          },
+          {
+            label: "Transparent",
+            value: "transparent"
+          },
+          {
+            label: "Mirror",
+            value: "mirror"
+          },
+          {
+            label: "Wrap",
+            value: "wrap"
+          }
+        ],
+        label: "Edges"
+      }
+    }
+  },
+  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();
+    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;
+      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));
+          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;
+            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;
+    }), l(() => {
+      z.dispose(), f.delete(e);
+    }), !s) return k(0, 0, 0, 0);
+    const c = H(s);
+    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);
+    return K(E, c.sample(E), c, e.edges.uniform);
+  }
+};
+var ce = se;
+export {
+  se as n,
+  ce as t
+};

package/dist/core/{Group-DTXP-whY.js → Group-jZZimqG1.js}

@@ -1,4 +1,4 @@
-import { O as r, m as o } from "./three.tsl-CgyjOhns.js";
+import { k as r, m as o } from "./three.tsl-BqgDcRt9.js";
 o();
 const n = {
   name: "Group",

package/dist/core/{Halftone-B_MuXCD8.js → Halftone-DWIVrS2s.js}

@@ -1,5 +1,5 @@
-import { O as A, m as D } from "./three.tsl-CgyjOhns.js";
-import { n as E } from "./transformations-Bs66Qh16.js";
+import { k as A, m as D } from "./three.tsl-BqgDcRt9.js";
+import { n as E } from "./transformations-DBjTkQ5b.js";
 D();
 const F = {
   name: "Halftone",
@@ -48,8 +48,8 @@ const F = {
     return r(o.rgb.mul(g), o.a.mul(g));
   }
 };
-var O = F;
+var w = F;
 export {
   F as n,
-  O as t
+  w as t
 };

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

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

package/dist/core/{ImageTexture-B6zFP2fB.js → ImageTexture-GrTz4Fx7.js}

@@ -1,9 +1,10 @@
-import { C as ee, I as te, O as oe, U as ae, V as S, W as ne, b as x, k as y, m as se } from "./three.tsl-CgyjOhns.js";
-se();
-te();
-const ie = {
+import { A as S, C as oe, G as ae, H as x, L as ne, W as se, b as y, k as ie, m as ce } from "./three.tsl-BqgDcRt9.js";
+ce();
+ne();
+const le = {
   name: "ImageTexture",
   category: "Sources",
+  acceptsUVContext: !0,
   props: {
     url: {
       default: "https://shaders.com/og.png",
@@ -51,12 +52,12 @@ const ie = {
       }
     }
   },
-  fragmentNode: ({ uniforms: m, onCleanup: L, onBeforeRender: W }) => {
-    const { vec2: o, vec4: D, float: t, texture: A, screenUV: N, viewportSize: c, step: a, min: u, max: O } = oe, H = new ne();
+  fragmentNode: ({ uniforms: m, onCleanup: j, onBeforeRender: W, uvContext: A }) => {
+    const { vec2: o, vec4: D, float: t, texture: H, screenUV: N, viewportSize: l, step: a, min: u, max: O } = ie, $ = A ?? N, q = new ae();
     let T = "", r = !1;
-    const n = new ae();
-    n.colorSpace = S;
-    const $ = A(n), s = y(1), f = y(0), w = y(0), V = (e) => {
+    const n = new se();
+    n.colorSpace = x;
+    const z = H(n), s = S(1), f = S(0), w = S(0), V = (e) => {
       if (!(!e || e.trim() === "" || r)) {
         r = !0;
         try {
@@ -65,12 +66,12 @@ const ie = {
             h = new URL(e, window.location.href).href;
           } catch {
           }
-          H.load(e, (d) => {
-            d.colorSpace = S;
-            const p = d.image, U = p.width || 1, b = p.height || 1, Z = U / b;
+          q.load(e, (d) => {
+            d.colorSpace = x;
+            const p = d.image, U = p.width || 1, b = p.height || 1, te = U / b;
             d.dispose(), T = e, requestAnimationFrame(() => {
               const g = n.image;
-              g && typeof g == "object" && (g.width !== U || g.height !== b) && n.dispose(), s.value = Z, f.value = U, w.value = b, n.image = p, n.colorSpace = S, n.needsUpdate = !0;
+              g && typeof g == "object" && (g.width !== U || g.height !== b) && n.dispose(), s.value = te, f.value = U, w.value = b, n.image = p, n.colorSpace = x, n.needsUpdate = !0;
             }), r = !1;
           }, void 0, (d) => {
             const p = !e.startsWith("http://") && !e.startsWith("https://") && !e.startsWith("data:");
@@ -91,15 +92,15 @@ const ie = {
     }, 0), W(() => {
       const e = m?.url?.uniform?.value ?? "";
       e !== T && !r && V(e);
-    }), L(() => {
+    }), j(() => {
       n.dispose();
     });
-    const q = N, l = c.x.div(c.y), i = m.objectFit.uniform, F = O(l.div(s), t(1)), z = o(s.div(l).mul(F), F), I = u(l.div(s), t(1)), B = o(s.div(l).mul(I), I), E = o(1, 1), R = u(u(l.div(s), t(1)), u(c.x.div(f), c.y.div(w))), k = o(s.div(l).mul(R), R), C = u(c.x.div(f), c.y.div(w)), G = o(s.div(l).mul(C), C), M = a(i, t(0.5)), P = a(t(0.5), i).mul(a(i, t(1.5))), J = a(t(1.5), i).mul(a(i, t(2.5))), K = a(t(2.5), i).mul(a(i, t(3.5))), Q = a(t(3.5), i), X = o(0).add(z.mul(M)).add(B.mul(P)).add(E.mul(J)).add(k.mul(K)).add(G.mul(Q)), _ = q.sub(o(0.5)).div(X).add(o(0.5)), v = o(_.x, t(1).sub(_.y)), j = $.sample(v), Y = x(x(v.x.lessThan(0), v.x.greaterThan(1)), x(v.y.lessThan(0), v.y.greaterThan(1)));
-    return D(j.rgb, ee(Y, t(0), j.a));
+    const B = $, c = l.x.div(l.y), i = m.objectFit.uniform, C = O(c.div(s), t(1)), E = o(s.div(c).mul(C), C), F = u(c.div(s), t(1)), G = o(s.div(c).mul(F), F), k = o(1, 1), R = u(u(c.div(s), t(1)), u(l.x.div(f), l.y.div(w))), M = o(s.div(c).mul(R), R), I = u(l.x.div(f), l.y.div(w)), P = o(s.div(c).mul(I), I), J = a(i, t(0.5)), K = a(t(0.5), i).mul(a(i, t(1.5))), Q = a(t(1.5), i).mul(a(i, t(2.5))), X = a(t(2.5), i).mul(a(i, t(3.5))), Y = a(t(3.5), i), Z = o(0).add(E.mul(J)).add(G.mul(K)).add(k.mul(Q)).add(M.mul(X)).add(P.mul(Y)), L = B.sub(o(0.5)).div(Z).add(o(0.5)), v = o(L.x, t(1).sub(L.y)), _ = z.sample(v), ee = y(y(v.x.lessThan(0), v.x.greaterThan(1)), y(v.y.lessThan(0), v.y.greaterThan(1)));
+    return D(_.rgb, oe(ee, t(0), _.a));
   }
 };
-var ce = ie;
+var de = le;
 export {
-  ie as n,
-  ce as t
+  le as n,
+  de as t
 };

package/dist/core/{Invert-Cd7GK1vs.js → Invert-CCQ1H_Qr.js}

@@ -1,4 +1,4 @@
-import { O as a, m as c } from "./three.tsl-CgyjOhns.js";
+import { k as a, m as c } from "./three.tsl-BqgDcRt9.js";
 c();
 const i = {
   name: "Invert",

package/dist/core/{LinearBlur-JFLMQBY4.js → LinearBlur-DHBRP6Yh.js}

@@ -1,5 +1,5 @@
-import { O as q, m as w } from "./three.tsl-CgyjOhns.js";
-import { n as A } from "./transformations-Bs66Qh16.js";
+import { k as q, m as w } from "./three.tsl-BqgDcRt9.js";
+import { n as A } from "./transformations-DBjTkQ5b.js";
 w();
 const I = {
   name: "LinearBlur",
@@ -49,8 +49,8 @@ const I = {
     })();
   }
 };
-var z = I;
+var k = I;
 export {
   I as n,
-  z as t
+  k as t
 };