shaders 2.2.0 → 2.2.1

package/dist/vue/utils/generatePresetCode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generatePresetCode.d.ts","sourceRoot":"","sources":["../../src/utils/generatePresetCode.ts"],"names":[],"mappings":"AAAA,UAAU,eAAe;IACvB,IAAI,EAAE,MAAM,CAAA;IACZ,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAC3B,QAAQ,CAAC,EAAE,eAAe,EAAE,CAAA;CAC7B;AAED,UAAU,YAAY;IACpB,UAAU,EAAE,eAAe,EAAE,CAAA;CAC9B;AAoiBD,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAyC/D;AAGD,eAAO,MAAM,mBAAmB,UAqD/B,CAAA"}
+{"version":3,"file":"generatePresetCode.d.ts","sourceRoot":"","sources":["../../src/utils/generatePresetCode.ts"],"names":[],"mappings":"AAAA,UAAU,eAAe;IACvB,IAAI,EAAE,MAAM,CAAA;IACZ,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAC3B,QAAQ,CAAC,EAAE,eAAe,EAAE,CAAA;CAC7B;AAED,UAAU,YAAY;IACpB,UAAU,EAAE,eAAe,EAAE,CAAA;CAC9B;AA+iBD,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAyC/D;AAGD,eAAO,MAAM,mBAAmB,UAsD/B,CAAA"}

package/dist/vue/utils/generatePresetCode.js

@@ -1,4 +1,4 @@
-import { n as a, t as o } from "../generatePresetCode-B6Ks_W3s.js";
+import { n as a, t as o } from "../generatePresetCode-T78GxN5X.js";
 export {
   o as availableComponents,
   a as generatePresetCode

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shaders",
-  "version": "2.2.0",
+  "version": "2.2.1",
   "description": "Declarative shader components for Vue, React, and Svelte",
   "author": "Simon Le Marchant<https://github.com/marchantweb>",
   "homepage": "https://shaders.com/",
@@ -314,6 +314,11 @@
       "types": "./dist/core/shaders/ZoomBlur/index.d.ts",
       "import": "./dist/core/shaders/ZoomBlur/index.js",
       "require": "./dist/core/shaders/ZoomBlur/index.js"
+    },
+    "./core/RectangularCoordinates": {
+      "types": "./dist/core/shaders/RectangularCoordinates/index.d.ts",
+      "import": "./dist/core/shaders/RectangularCoordinates/index.js",
+      "require": "./dist/core/shaders/RectangularCoordinates/index.js"
     }
   },
   "files": [

package/dist/core/Bulge-Ceythf-i.js

@@ -1,99 +0,0 @@
-import { O as U, d as t, h as V, m as E } from "./three.tsl-CgyjOhns.js";
-import { t as M } from "./edges-Cj8yVYgz.js";
-import { a as R, o as z } from "./transformations-Bs66Qh16.js";
-E();
-const A = {
-  name: "Bulge",
-  category: "Distortions",
-  requiresRTT: !0,
-  requiresChild: !0,
-  props: {
-    center: {
-      default: {
-        x: 0.5,
-        y: 0.5
-      },
-      transform: z,
-      description: "The center point of the bulge effect",
-      ui: {
-        type: "position",
-        label: "Center"
-      }
-    },
-    strength: {
-      default: 1,
-      description: "The intensity of the bulge effect (positive = bulge out, negative = pinch in)",
-      ui: {
-        type: "range",
-        min: -1,
-        max: 1,
-        step: 0.01,
-        label: "Strength"
-      }
-    },
-    radius: {
-      default: 1,
-      description: "The radius of the bulge effect area",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 5,
-        step: 0.01,
-        label: "Radius"
-      }
-    },
-    falloff: {
-      default: 0.5,
-      description: "Controls the smoothness of the transition (0 = hard edge, 1 = very smooth)",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 1,
-        step: 0.01,
-        label: "Falloff"
-      }
-    },
-    edges: {
-      default: "stretch",
-      description: "How to handle edges when distortion pushes content out of bounds",
-      transform: R,
-      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, childNode: a, onCleanup: g }) => {
-    const { vec2: s, vec4: h, length: b, screenUV: i, viewportSize: l, convertToTexture: v, smoothstep: x } = U;
-    if (!a) return h(0, 0, 0, 0);
-    const o = v(a);
-    g(() => {
-      o?.renderTarget?.dispose && o.renderTarget.dispose();
-    });
-    const n = l.x.div(l.y), y = s(i.x.mul(n), i.y), u = s(e.center.uniform.x.mul(n), e.center.uniform.y.oneMinus()), c = y.sub(u), f = b(c), r = e.radius.uniform.mul(0.5), T = e.falloff.uniform, _ = x(r.mul(t(1).sub(T).sub(t(1e-3)).max(t(0))), r, f).oneMinus(), d = f.div(r), q = d.mul(d), w = V(t(0), t(1).sub(q)), C = _.mul(w), D = e.strength.uniform.negate().mul(C), F = t(1).add(D), S = c.mul(F), m = u.add(S), p = s(m.x.div(n), m.y);
-    return M(p, o.sample(p), o, e.edges.uniform);
-  }
-};
-var O = A;
-export {
-  A as n,
-  O as t
-};

package/dist/core/FilmGrain-BAZORehh.js

@@ -1,27 +0,0 @@
-import { O as f, m as g } from "./three.tsl-CgyjOhns.js";
-g();
-const p = {
-  name: "FilmGrain",
-  category: "Effects",
-  requiresChild: !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: s }) => {
-    const { vec2: i, vec4: e, float: t, screenUV: o, sin: a, dot: l, fract: m } = f, c = r.strength.uniform, n = s || e(0, 0, 0, 0), u = m(a(l(o, i(t(12.9898), t(78.233)).mul(t(2)))).mul(t(43758.5453))).mul(t(2)).sub(t(1)).mul(c.mul(t(0.1)));
-    return e(n.rgb.add(u), n.a);
-  }
-};
-var h = p;
-export {
-  p as n,
-  h as t
-};

package/dist/core/FloatingParticles-7wvOBUbD.js

@@ -1,158 +0,0 @@
-import { O as Z, m as $ } from "./three.tsl-CgyjOhns.js";
-import { r as ee } from "./transformations-Bs66Qh16.js";
-$();
-const te = {
-  name: "FloatingParticles",
-  category: "Effects",
-  requiresRTT: !1,
-  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: ee,
-      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: l, childNode: F }) => {
-    const { vec2: n, vec3: I, vec4: U, float: o, sin: u, cos: P, smoothstep: H, mix: B, min: h, floor: O, fract: V, length: E, dot: T, screenUV: j, viewportSize: L, time: b, Fn: d } = Z, G = d(([e]) => V(u(T(e, n(127.1, 311.7))).mul(43758.5453123))), N = d(([e]) => V(u(n(T(e, n(127.1, 311.7)), T(e, n(269.5, 183.3)))).mul(43758.5453))), J = d(([e, a]) => {
-      const s = N(e).sub(0.5), t = u(a), r = P(a);
-      return n(r.mul(s.x).sub(t.mul(s.y)).mul(0.66), t.mul(s.x).add(r.mul(s.y)).mul(0.66)).add(e).add(0.5);
-    }), K = d(([e]) => b.mul(l.randomness.uniform).mul(G(e).sub(0.5)).mul(2)), f = d(([e, a]) => {
-      const s = J(a, K(a));
-      return E(e.sub(s));
-    }), Q = d(([e]) => {
-      const a = O(e), s = V(e);
-      let t = f(e, a);
-      const r = l.particleSoftness.uniform, m = l.particleSize.uniform.mul(0.01), i = m.mul(0.6).add(r.mul(m.mul(2.4))), c = i.greaterThan(0.35), g = s.x.lessThan(0.4), x = s.x.greaterThan(0.6), w = s.y.lessThan(0.4), R = s.y.greaterThan(0.6), z = c.and(g), p = c.and(x), D = c.and(w), y = c.and(R);
-      t = z.select(h(t, f(e, a.add(n(-1, 0)))), t), t = p.select(h(t, f(e, a.add(n(1, 0)))), t), t = D.select(h(t, f(e, a.add(n(0, -1)))), t), t = y.select(h(t, f(e, a.add(n(0, 1)))), t);
-      const M = H(i, m.mul(0.6), t), _ = l.twinkle.uniform, v = a.x.mul(12.9898).add(a.y.mul(78.233)).sin().mul(43758.5453).fract(), C = u(b.mul(2).add(v.mul(6.28318))).mul(0.5).add(0.5), A = B(o(1), C, _);
-      return M.mul(A).mul(l.particleColor.uniform.rgb);
-    }), W = d(([e]) => {
-      const a = o(1.05), s = o(0.9), t = l.count.uniform, r = I(0).toVar(), m = o(1).toVar(), i = o(1).toVar(), c = n(0).toVar(), g = l.angle.uniform.mul(3.14159).div(180), x = n(P(g), u(g)), w = b.mul(x).mul(l.speed.uniform), R = l.speedVariance.uniform, z = l.angleVariance.uniform.mul(3.14159).div(180);
-      for (let p = 0; p < 4; p++) {
-        const D = o(p).lessThan(t).and(i.greaterThan(0.02)), y = N(n(i, o(p).mul(7.919))), M = o(1).add(y.x.sub(0.5).mul(R)), _ = y.y.sub(0.5).mul(z).mul(2), v = g.add(_), C = n(P(v), u(v)), A = w.mul(M).add(C.sub(x).mul(b).mul(l.speed.uniform)), Y = Q(e.mul(m).add(A).add(c)).mul(i);
-        r.assign(r.add(D.select(Y, I(0)))), c.assign(c.add(y.mul(10))), i.assign(i.mul(s)), m.assign(m.mul(a));
-      }
-      return r;
-    }), q = j.mul(2).sub(1), X = L.x.div(L.y), k = W(n(q.x.mul(X), q.y).mul(l.particleDensity.uniform)), S = E(k);
-    return F ? U(B(F.xyz, k, S.greaterThan(0.01).select(S, 0)), 1) : U(k, S);
-  }
-};
-var se = te;
-export {
-  te as n,
-  se as t
-};

package/dist/core/GlassTiles-C0y_PWTa.js

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

package/dist/core/GridDistortion-CuxRQdzs.js

@@ -1,137 +0,0 @@
-import { O as N, m as Q } from "./three.tsl-CgyjOhns.js";
-import { t as $ } from "./edges-Cj8yVYgz.js";
-import { a as ee } from "./transformations-Bs66Qh16.js";
-import { DataTexture as te, FloatType as ae, LinearFilter as q, RGFormat as ie } from "three";
-Q();
-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: ee,
-      ui: {
-        type: "select",
-        options: [
-          {
-            label: "Stretch",
-            value: "stretch"
-          },
-          {
-            label: "Transparent",
-            value: "transparent"
-          },
-          {
-            label: "Mirror",
-            value: "mirror"
-          },
-          {
-            label: "Wrap",
-            value: "wrap"
-          }
-        ],
-        label: "Edges"
-      }
-    }
-  },
-  fragmentNode: ({ uniforms: n, onBeforeRender: A, childNode: b, onCleanup: T }) => {
-    const { vec2: w, vec4: H, float: m, uniform: o, screenUV: D, texture: j, convertToTexture: C } = N;
-    if (!b) return H(0, 0, 0, 0);
-    const l = C(b);
-    T(() => {
-      l?.renderTarget?.dispose && l.renderTarget.dispose();
-    });
-    const i = Math.max(8, Math.min(128, Math.floor(n.gridSize.uniform.value))), e = new Float32Array(i * i * 2), r = new te(e, i, i, ie, ae);
-    r.magFilter = q, r.minFilter = q, r.needsUpdate = !0;
-    const L = j(r), O = o(0.5), P = o(0.5), p = o(0), f = o(0);
-    let S = 0.5, F = 0.5, R = Date.now();
-    A(({ pointer: s }) => {
-      const G = Date.now(), t = Math.min((G - R) / 1e3, 0.016);
-      R = G;
-      const I = t > 0 ? (s.x - S) / t : 0, V = t > 0 ? (s.y - F) / t : 0;
-      p.value = p.value * 0.85 + I * 0.15, f.value = f.value * 0.85 + V * 0.15, O.value = s.x, P.value = s.y;
-      const X = n.decay.uniform.value, Y = n.intensity.uniform.value, g = n.radius.uniform.value * 0.05, v = n.swirl.uniform.value;
-      for (let c = 0; c < i; c++) for (let d = 0; d < i; d++) {
-        const a = (c * i + d) * 2;
-        e[a] *= 1 - X * t, e[a + 1] *= 1 - X * t;
-        const J = (d + 0.5) / i, K = (c + 0.5) / i, x = J - s.x, y = K - s.y, M = Math.sqrt(x * x + y * y);
-        if (M < g * 2 && Math.abs(I) + Math.abs(V) > 0.01) {
-          const u = Math.exp(-M * M / (g * g));
-          if (e[a] += p.value * u * Y * t * 0.5, e[a + 1] += f.value * u * Y * t * 0.5, v > 0) {
-            const E = Math.atan2(y, x) + Math.PI * 0.5;
-            e[a] += Math.cos(E) * v * u * t * 2, e[a + 1] += Math.sin(E) * v * u * t * 2;
-          }
-        }
-        e[a] = Math.max(-1, Math.min(1, e[a])), e[a + 1] = Math.max(-1, Math.min(1, e[a + 1]));
-      }
-      r.needsUpdate = !0, S = s.x, F = s.y;
-    }), T(() => {
-      r.dispose();
-    });
-    const W = n.gridSize.uniform, h = m(1).div(W), Z = D.div(h).floor().mul(h).add(h.mul(0.5)), k = L.sample(Z).xy, U = m(0.1), _ = m(-0.1), B = k.clamp(w(_, _), w(U, U)), z = D.sub(B);
-    return $(z, l.sample(z), l, n.edges.uniform);
-  }
-};
-var ce = se;
-export {
-  se as n,
-  ce as t
-};

package/dist/core/Liquify-rmJGJAdt.js

@@ -1,126 +0,0 @@
-import { O as C, m as J } from "./three.tsl-CgyjOhns.js";
-import { t as K } from "./edges-Cj8yVYgz.js";
-import { a as N } from "./transformations-Bs66Qh16.js";
-import { DataTexture as Q, FloatType as $, LinearFilter as L, RGFormat as ee } from "three";
-J();
-const te = {
-  name: "Liquify",
-  category: "Interactive",
-  requiresRTT: !0,
-  requiresChild: !0,
-  props: {
-    intensity: {
-      default: 1,
-      description: "Strength of the distortion effect",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 5,
-        step: 0.1,
-        label: "Intensity"
-      }
-    },
-    swirl: {
-      default: 0,
-      description: "Amount of swirl motion (0-1)",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 1,
-        step: 0.01,
-        label: "Swirl"
-      }
-    },
-    decay: {
-      default: 3,
-      description: "Rate of distortion decay (higher = faster)",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 10,
-        step: 0.1,
-        label: "Decay"
-      }
-    },
-    radius: {
-      default: 1,
-      description: "Radius of the distortion effect",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 3,
-        step: 0.01,
-        label: "Radius"
-      }
-    },
-    edges: {
-      default: "stretch",
-      description: "How to handle edges when distortion pushes content out of bounds",
-      transform: N,
-      ui: {
-        type: "select",
-        options: [
-          {
-            label: "Stretch",
-            value: "stretch"
-          },
-          {
-            label: "Transparent",
-            value: "transparent"
-          },
-          {
-            label: "Mirror",
-            value: "mirror"
-          },
-          {
-            label: "Wrap",
-            value: "wrap"
-          }
-        ],
-        label: "Edges"
-      }
-    }
-  },
-  fragmentNode: ({ uniforms: i, onBeforeRender: A, childNode: g, onCleanup: M }) => {
-    const { vec2: b, vec4: G, float: T, uniform: o, screenUV: w, texture: H, convertToTexture: j } = C;
-    if (!g) return G(0, 0, 0, 0);
-    const l = j(g);
-    M(() => {
-      l?.renderTarget?.dispose && l.renderTarget.dispose();
-    });
-    const s = 32, e = new Float32Array(s * s * 2), r = new Q(e, s, s, ee, $);
-    r.magFilter = L, r.minFilter = L, r.needsUpdate = !0;
-    const O = H(r), P = o(0.5), W = o(0.5), m = o(0), p = o(0);
-    let D = 0.5, F = 0.5, R = Date.now();
-    A(({ pointer: n }) => {
-      const X = Date.now(), t = Math.min((X - R) / 1e3, 0.016);
-      R = X;
-      const Y = t > 0 ? (n.x - D) / t : 0, E = t > 0 ? (n.y - F) / t : 0;
-      m.value = m.value * 0.85 + Y * 0.15, p.value = p.value * 0.85 + E * 0.15, P.value = n.x, W.value = n.y;
-      const S = i.decay.uniform.value, U = i.intensity.uniform.value, f = i.radius.uniform.value * 0.05, h = i.swirl.uniform.value;
-      for (let c = 0; c < s; c++) for (let u = 0; u < s; u++) {
-        const a = (c * s + u) * 2;
-        e[a] *= 1 - S * t, e[a + 1] *= 1 - S * t;
-        const z = (u + 0.5) / s, B = (c + 0.5) / s, y = z - n.x, v = B - n.y, x = Math.sqrt(y * y + v * v);
-        if (x < f * 2 && Math.abs(Y) + Math.abs(E) > 0.01) {
-          const d = Math.exp(-x * x / (f * f));
-          if (e[a] += m.value * d * U * t * 0.5, e[a + 1] += p.value * d * U * t * 0.5, h > 0) {
-            const V = Math.atan2(v, y) + Math.PI * 0.5;
-            e[a] += Math.cos(V) * h * d * t * 2, e[a + 1] += Math.sin(V) * h * d * t * 2;
-          }
-        }
-        e[a] = Math.max(-1, Math.min(1, e[a])), e[a + 1] = Math.max(-1, Math.min(1, e[a + 1]));
-      }
-      r.needsUpdate = !0, D = n.x, F = n.y;
-    }), M(() => {
-      r.dispose();
-    });
-    const Z = O.sample(w).xy, _ = T(0.2), q = T(-0.2), k = Z.clamp(b(q, q), b(_, _)), I = w.sub(k);
-    return K(I, l.sample(I), l, i.edges.uniform);
-  }
-};
-var ie = te;
-export {
-  te as n,
-  ie as t
-};

package/dist/core/Pixelate-BIANS3t9.js

@@ -1,34 +0,0 @@
-import { O as p, m as u } from "./three.tsl-CgyjOhns.js";
-u();
-const m = {
-  name: "Pixelate",
-  category: "Effects",
-  requiresRTT: !0,
-  requiresChild: !0,
-  props: { scale: {
-    default: 50,
-    description: "Pixel size - higher values create larger, more visible pixels",
-    ui: {
-      type: "range",
-      min: 1,
-      max: 200,
-      step: 1,
-      label: "Scale"
-    }
-  } },
-  fragmentNode: ({ uniforms: i, childNode: r, onCleanup: s }) => {
-    const { vec4: a, floor: n, screenUV: o, convertToTexture: l } = p;
-    if (!r) return a(0, 0, 0, 0);
-    const e = l(r);
-    s(() => {
-      e?.renderTarget?.dispose && e.renderTarget.dispose();
-    });
-    const t = i.scale.uniform, c = n(o.mul(t)).div(t);
-    return e.sample(c);
-  }
-};
-var x = m;
-export {
-  m as n,
-  x as t
-};

package/dist/core/edges-Cj8yVYgz.js

@@ -1,10 +0,0 @@
-import { O as f, m as g } from "./three.tsl-CgyjOhns.js";
-g();
-var { vec2: p, vec4: h, step: s, abs: u, mod: x, fract: y, float: n, select: o } = f;
-const C = (r, a, m, c) => {
-  const b = s(n(0), r.x).mul(s(r.x, n(1))), _ = s(n(0), r.y).mul(s(r.y, n(1))), v = b.mul(_), B = h(a.rgb, a.a.mul(v)), t = x(u(r.x), n(2)), l = x(u(r.y), n(2)), w = p(o(s(n(1), t), n(2).sub(t), t), o(s(n(1), l), n(2).sub(l), l)), X = m.sample(w), Y = p(y(r.x), y(r.y)), e = m.sample(Y);
-  return o(s(n(0.5), c), o(s(n(1.5), c), o(s(n(2.5), c), e, X), B), a);
-};
-export {
-  C as t
-};