shaders 2.2.23 → 2.2.25

package/dist/core/Liquify-Bi02_ugh.js

@@ -1,139 +0,0 @@
-import { D as Z, O as A } from "./three.tsl-Btj1hLsf.js";
-import { t as $ } from "./edges-CDzKsauJ.js";
-import { a as B } from "./transformations-CsrIJXh-.js";
-import { DataTexture as J, FloatType as K, LinearFilter as C, RGFormat as Q } from "three";
-var r = 32, T = /* @__PURE__ */ new WeakMap(), G = (e) => {
-  let i = T.get(e);
-  if (!i) {
-    const l = new Float32Array(r * r * 2), t = new J(l, r, r, Q, K);
-    t.magFilter = C, t.minFilter = C, t.needsUpdate = !0, i = {
-      texture: t,
-      data: l,
-      tslNode: Z(t),
-      initialized: !1
-    }, T.set(e, i);
-  }
-  return i;
-};
-const ee = {
-  name: "Liquify",
-  category: "Interactive",
-  description: "Liquid-like interactive deformation effect",
-  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: B,
-      ui: {
-        type: "select",
-        options: [
-          {
-            label: "Stretch",
-            value: "stretch"
-          },
-          {
-            label: "Transparent",
-            value: "transparent"
-          },
-          {
-            label: "Mirror",
-            value: "mirror"
-          },
-          {
-            label: "Wrap",
-            value: "wrap"
-          }
-        ],
-        label: "Edges"
-      }
-    }
-  },
-  uvTransformNode: ({ uv: e, uniforms: i }) => {
-    const { vec2: l, float: t } = A, d = G(i).tslNode.sample(e).xy, o = t(0.2), u = d.clamp(l(o.negate(), o.negate()), l(o, o));
-    return e.sub(u);
-  },
-  fragmentNode: ({ uniforms: e, onBeforeRender: i, childNode: l, onCleanup: t }) => {
-    const { vec2: d, vec4: o, float: u, uniform: w, screenUV: F, convertToTexture: H } = A, { texture: q, data: a, tslNode: O } = G(e), h = w(0), x = w(0);
-    let R = 0.5, S = 0.5, I = Date.now();
-    if (i(({ pointer: c }) => {
-      const U = Date.now(), s = Math.min((U - I) / 1e3, 0.016);
-      I = U;
-      const V = s > 0 ? (c.x - R) / s : 0, X = s > 0 ? (c.y - S) / s : 0;
-      h.value = h.value * 0.85 + V * 0.15, x.value = x.value * 0.85 + X * 0.15;
-      const Y = e.decay.uniform.value, _ = e.intensity.uniform.value, y = e.radius.uniform.value * 0.05, g = e.swirl.uniform.value;
-      for (let p = 0; p < r; p++) for (let f = 0; f < r; f++) {
-        const n = (p * r + f) * 2;
-        a[n] *= 1 - Y * s, a[n + 1] *= 1 - Y * s;
-        const z = (f + 0.5) / r, P = (p + 0.5) / r, M = z - c.x, b = P - c.y, D = Math.sqrt(M * M + b * b);
-        if (D < y * 2 && Math.abs(V) + Math.abs(X) > 0.01) {
-          const v = Math.exp(-D * D / (y * y));
-          if (a[n] += h.value * v * _ * s * 0.5, a[n + 1] += x.value * v * _ * s * 0.5, g > 0) {
-            const k = Math.atan2(b, M) + Math.PI * 0.5;
-            a[n] += Math.cos(k) * g * v * s * 2, a[n + 1] += Math.sin(k) * g * v * s * 2;
-          }
-        }
-        a[n] = Math.max(-1, Math.min(1, a[n])), a[n + 1] = Math.max(-1, Math.min(1, a[n + 1]));
-      }
-      q.needsUpdate = !0, R = c.x, S = c.y;
-    }), t(() => {
-      q.dispose(), T.delete(e);
-    }), !l) return o(0, 0, 0, 0);
-    const m = H(l);
-    t(() => {
-      m?.renderTarget?.dispose && m.renderTarget.dispose();
-    });
-    const W = O.sample(F).xy, E = u(0.2), L = u(-0.2), j = W.clamp(d(L, L), d(E, E)), N = F.sub(j);
-    return $(N, m.sample(N), m, e.edges.uniform);
-  }
-};
-var re = ee;
-export {
-  ee as n,
-  re as t
-};

package/dist/core/Pixelate-CSsdT1rr.js

@@ -1,38 +0,0 @@
-import { O as l } from "./three.tsl-Btj1hLsf.js";
-const p = {
-  name: "Pixelate",
-  category: "Stylize",
-  description: "Pixelation effect with adjustable cell size",
-  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"
-    }
-  } },
-  uvTransformNode: ({ uv: t, uniforms: e }) => {
-    const { floor: i } = l, r = e.scale.uniform;
-    return i(t.mul(r)).div(r);
-  },
-  fragmentNode: ({ uniforms: t, childNode: e, onCleanup: i }) => {
-    const { vec4: r, floor: a, screenUV: n, convertToTexture: c } = l;
-    if (!e) return r(0, 0, 0, 0);
-    const s = c(e);
-    i(() => {
-      s?.renderTarget?.dispose && s.renderTarget.dispose();
-    });
-    const o = t.scale.uniform, u = a(n.mul(o)).div(o);
-    return s.sample(u);
-  }
-};
-var f = p;
-export {
-  p as n,
-  f as t
-};

package/dist/core/PolarCoordinates-D626ml58.js

@@ -1,103 +0,0 @@
-import { O as y } from "./three.tsl-Btj1hLsf.js";
-import { t as T } from "./edges-CDzKsauJ.js";
-import { a as w, o as C } from "./transformations-CsrIJXh-.js";
-const P = {
-  name: "PolarCoordinates",
-  category: "Distortions",
-  description: "Convert rectangular coordinates to polar space",
-  requiresRTT: !0,
-  requiresChild: !0,
-  props: {
-    center: {
-      default: {
-        x: 0.5,
-        y: 0.5
-      },
-      transform: C,
-      description: "The center point for polar coordinate conversion",
-      ui: {
-        type: "position",
-        label: "Center"
-      }
-    },
-    wrap: {
-      default: 1,
-      description: "Controls how much of the angular range to use (1 = full 360°, 0.5 = 180°)",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 2,
-        step: 0.01,
-        label: "Wrap"
-      }
-    },
-    radius: {
-      default: 1,
-      description: "Controls how much of the radius range to use (affects the radial mapping)",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 2,
-        step: 0.01,
-        label: "Radius"
-      }
-    },
-    intensity: {
-      default: 1,
-      description: "Blends between original UVs (0) and polar coordinates (1)",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 1,
-        step: 0.01,
-        label: "Intensity"
-      }
-    },
-    edges: {
-      default: "transparent",
-      description: "How to handle edges when distortion pushes content out of bounds",
-      transform: w,
-      ui: {
-        type: "select",
-        options: [
-          {
-            label: "Stretch",
-            value: "stretch"
-          },
-          {
-            label: "Transparent",
-            value: "transparent"
-          },
-          {
-            label: "Mirror",
-            value: "mirror"
-          },
-          {
-            label: "Wrap",
-            value: "wrap"
-          }
-        ],
-        label: "Edges"
-      }
-    }
-  },
-  uvTransformNode: ({ uv: e, uniforms: t, viewportSize: i }) => {
-    const { vec2: r, length: u, atan: p, PI: l, mix: o } = y, a = i.x.div(i.y), m = r(e.x.mul(a), e.y), c = r(t.center.uniform.x.mul(a), t.center.uniform.y.oneMinus()), s = m.sub(c), n = p(s.y, s.x).add(l).div(l.mul(2)), d = u(s);
-    return o(e, r(n.mul(t.wrap.uniform), d.mul(t.radius.uniform)), t.intensity.uniform);
-  },
-  fragmentNode: ({ uniforms: e, childNode: t, onCleanup: i }) => {
-    const { vec2: r, vec4: u, length: p, atan: l, screenUV: o, viewportSize: a, convertToTexture: m, PI: c, mix: s } = y;
-    if (!t) return u(0, 0, 0, 0);
-    const n = m(t);
-    i(() => {
-      n?.renderTarget?.dispose && n.renderTarget.dispose();
-    });
-    const d = a.x.div(a.y), x = r(o.x.mul(d), o.y), h = r(e.center.uniform.x.mul(d), e.center.uniform.y.oneMinus()), f = x.sub(h), b = l(f.y, f.x).add(c).div(c.mul(2)), v = p(f), g = s(o, r(b.mul(e.wrap.uniform), v.mul(e.radius.uniform)), e.intensity.uniform);
-    return T(g, n.sample(g), n, e.edges.uniform);
-  }
-};
-var I = P;
-export {
-  P as n,
-  I as t
-};

package/dist/core/Posterize-DhZkMaC7.js

@@ -1,46 +0,0 @@
-import { O as r } from "./three.tsl-Btj1hLsf.js";
-import { c as i, o as n } from "./TSLBase-BFMvTOak.js";
-var a = class extends i {
-  static get type() {
-    return "PosterizeNode";
-  }
-  /**
-  * Constructs a new posterize node.
-  *
-  * @param {Node} sourceNode - The input color.
-  * @param {Node} stepsNode - Controls the intensity of the posterization effect. A lower number results in a more blocky appearance.
-  */
-  constructor(t, e) {
-    super(), this.sourceNode = t, this.stepsNode = e;
-  }
-  setup() {
-    const { sourceNode: t, stepsNode: e } = this;
-    return t.mul(e).floor().div(e);
-  }
-};
-const p = /* @__PURE__ */ n(a).setParameterLength(2), c = {
-  name: "Posterize",
-  category: "Adjustments",
-  description: "Reduce color depth to create a poster effect",
-  requiresChild: !0,
-  props: { intensity: {
-    default: 5,
-    description: "The intensity of the posterization effect (lower is more posterized)",
-    ui: {
-      type: "range",
-      min: 2,
-      max: 20,
-      step: 1,
-      label: "Intensity"
-    }
-  } },
-  fragmentNode: ({ uniforms: t, childNode: e }) => {
-    const { vec4: o, int: s } = r;
-    return e ? p(e || o(0, 0, 0, 0), s(t.intensity.uniform)) : (console.error("You must pass a child component into the Posterize shader."), o(0));
-  }
-};
-var m = c;
-export {
-  c as n,
-  m as t
-};

package/dist/core/ProgressiveBlur-CGtCfLF8.js

@@ -1,102 +0,0 @@
-import { O as M } from "./three.tsl-Btj1hLsf.js";
-import { n as U, o as O } from "./transformations-CsrIJXh-.js";
-const j = {
-  name: "ProgressiveBlur",
-  category: "Blurs",
-  description: "Blur that increases progressively in one direction",
-  requiresRTT: !0,
-  requiresChild: !0,
-  props: {
-    intensity: {
-      default: 50,
-      description: "Maximum intensity of the blur effect",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 100,
-        step: 1,
-        label: "Intensity"
-      }
-    },
-    angle: {
-      default: 0,
-      transform: U,
-      description: "Direction of the blur gradient (in degrees)",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 360,
-        step: 1,
-        label: "Angle"
-      }
-    },
-    center: {
-      default: {
-        x: 0,
-        y: 0.5
-      },
-      transform: O,
-      description: "Center point where blur begins",
-      ui: {
-        type: "position",
-        label: "Center"
-      }
-    },
-    falloff: {
-      default: 1,
-      description: "Distance over which blur transitions to full strength",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 1,
-        step: 0.01,
-        label: "Falloff"
-      }
-    }
-  },
-  fragmentNode: ({ uniforms: r, childNode: g, onCleanup: h }) => {
-    const { vec2: o, vec4: s, float: e, screenUV: i, viewportSize: x, sin: C, cos: D, radians: P, max: v, smoothstep: S, Fn: y, convertToTexture: b } = M;
-    if (!g) return s(0, 0, 0, 0);
-    const a = b(g);
-    h(() => {
-      a?.renderTarget?.dispose && a.renderTarget.dispose();
-    });
-    const T = P(r.angle.uniform), V = o(D(T), C(T)), A = o(r.center.uniform[0], r.center.uniform[1].oneMinus()), R = i.sub(A), _ = v(e(0), R.dot(V)), q = v(e(1e-3), r.falloff.uniform), F = S(e(0), q, _), I = r.intensity.uniform.mul(0.06), w = F.mul(I), z = [
-      0.056,
-      0.135,
-      0.278,
-      0.487,
-      0.726,
-      0.923,
-      1,
-      0.923,
-      0.726,
-      0.487,
-      0.278,
-      0.135,
-      0.056
-    ], B = 6.214, l = b(y(() => {
-      const c = i, u = o(1).div(x), n = s(0).toVar();
-      for (let t = -6; t <= 6; t++) {
-        const d = e(z[t + 6] / B), f = o(e(t), e(0)).mul(w).mul(u), m = c.add(f), p = a.sample(m).mul(d);
-        n.assign(n.add(p));
-      }
-      return n;
-    })());
-    return h(() => {
-      l?.renderTarget?.dispose && l.renderTarget.dispose();
-    }), y(() => {
-      const c = i, u = o(1).div(x), n = s(0).toVar();
-      for (let t = -6; t <= 6; t++) {
-        const d = e(z[t + 6] / B), f = o(e(0), e(t)).mul(w).mul(u), m = c.add(f), p = l.sample(m).mul(d);
-        n.assign(n.add(p));
-      }
-      return n;
-    })();
-  }
-};
-var G = j;
-export {
-  j as n,
-  G as t
-};

package/dist/core/RadialGradient-C0_WzmbH.js

@@ -1,71 +0,0 @@
-import { O as d } from "./three.tsl-Btj1hLsf.js";
-import { i as f, o as m, r as n, t as u } from "./transformations-CsrIJXh-.js";
-import { t as g } from "./colorMixing--dhzx0ch.js";
-const h = {
-  name: "RadialGradient",
-  category: "Base Layers",
-  description: "Radial gradient radiating from a center point",
-  acceptsUVContext: !0,
-  props: {
-    colorA: {
-      default: "#ff0000",
-      transform: n,
-      description: "The starting color at the center of the gradient",
-      ui: {
-        type: "color",
-        label: "Color A"
-      }
-    },
-    colorB: {
-      default: "#0000ff",
-      transform: n,
-      description: "The ending color at the edge of the gradient",
-      ui: {
-        type: "color",
-        label: "Color B"
-      }
-    },
-    center: {
-      default: {
-        x: 0.5,
-        y: 0.5
-      },
-      transform: m,
-      description: "The center point of the radial gradient",
-      ui: {
-        type: "position",
-        label: "Center"
-      }
-    },
-    radius: {
-      default: 1,
-      description: "The radius of the gradient (normalized, 0.0-1.0)",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 2,
-        step: 0.01,
-        label: "Radius"
-      }
-    },
-    colorSpace: {
-      default: "linear",
-      transform: f,
-      description: "Color space for color interpolation",
-      ui: {
-        type: "select",
-        options: u,
-        label: "Color Space"
-      }
-    }
-  },
-  fragmentNode: ({ uniforms: o, uvContext: l }) => {
-    const { vec2: e, float: t, distance: c, screenUV: s, viewportSize: r } = d, a = l ?? s, i = r.x.div(r.y), p = c(e(a.x.mul(i), a.y), e(o.center.uniform.x.mul(i), o.center.uniform.y.oneMinus())).div(o.radius.uniform).clamp(t(0), t(1));
-    return g(o.colorA.uniform, o.colorB.uniform, p, o.colorSpace.uniform);
-  }
-};
-var v = h;
-export {
-  h as n,
-  v as t
-};

package/dist/core/RectangularCoordinates-DfXw7fhI.js

@@ -1,92 +0,0 @@
-import { O as x } from "./three.tsl-Btj1hLsf.js";
-import { t as T } from "./edges-CDzKsauJ.js";
-import { a as C, o as P } from "./transformations-CsrIJXh-.js";
-const w = {
-  name: "RectangularCoordinates",
-  category: "Distortions",
-  description: "Convert polar coordinates back to rectangular space",
-  requiresRTT: !0,
-  requiresChild: !0,
-  props: {
-    center: {
-      default: {
-        x: 0.5,
-        y: 0.5
-      },
-      transform: P,
-      description: "The center point for rectangular coordinate conversion",
-      ui: {
-        type: "position",
-        label: "Center"
-      }
-    },
-    scale: {
-      default: 1,
-      description: "Scale factor for the rectangular output",
-      ui: {
-        type: "range",
-        min: 0.1,
-        max: 3,
-        step: 0.01,
-        label: "Scale"
-      }
-    },
-    intensity: {
-      default: 1,
-      description: "Blends between original UVs (0) and rectangular coordinates (1)",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 1,
-        step: 0.01,
-        label: "Intensity"
-      }
-    },
-    edges: {
-      default: "transparent",
-      description: "How to handle edges when distortion pushes content out of bounds",
-      transform: C,
-      ui: {
-        type: "select",
-        options: [
-          {
-            label: "Stretch",
-            value: "stretch"
-          },
-          {
-            label: "Transparent",
-            value: "transparent"
-          },
-          {
-            label: "Mirror",
-            value: "mirror"
-          },
-          {
-            label: "Wrap",
-            value: "wrap"
-          }
-        ],
-        label: "Edges"
-      }
-    }
-  },
-  uvTransformNode: ({ uv: e, uniforms: t, viewportSize: i }) => {
-    const { vec2: n, cos: d, sin: p, PI: c, mix: o } = x, a = e.x.mul(c.mul(2)).sub(c), l = e.y.mul(t.scale.uniform), u = l.mul(d(a)), m = l.mul(p(a)), r = i.x.div(i.y), s = n(t.center.uniform.x, t.center.uniform.y.oneMinus());
-    return o(e, n(u.div(r).add(s.x), m.add(s.y)), t.intensity.uniform);
-  },
-  fragmentNode: ({ uniforms: e, childNode: t, onCleanup: i }) => {
-    const { vec2: n, vec4: d, cos: p, sin: c, screenUV: o, viewportSize: a, convertToTexture: l, PI: u, mix: m } = x;
-    if (!t) return d(0, 0, 0, 0);
-    const r = l(t);
-    i(() => {
-      r?.renderTarget?.dispose && r.renderTarget.dispose();
-    });
-    const s = o.x.mul(u.mul(2)).sub(u), f = o.y.mul(e.scale.uniform), b = f.mul(p(s)), v = f.mul(c(s)), h = a.x.div(a.y), g = n(e.center.uniform.x, e.center.uniform.y.oneMinus()), y = m(o, n(b.div(h).add(g.x), v.add(g.y)), e.intensity.uniform);
-    return T(y, r.sample(y), r, e.edges.uniform);
-  }
-};
-var R = w;
-export {
-  w as n,
-  R as t
-};

package/dist/core/Ripples-DkemN3eh.js

@@ -1,106 +0,0 @@
-import { O as T, d as w } from "./three.tsl-Btj1hLsf.js";
-import { t as A } from "./time-DbRMw6Jm.js";
-import { o as S, r as l } from "./transformations-CsrIJXh-.js";
-import { t as q } from "./colorMixing--dhzx0ch.js";
-const P = {
-  name: "Ripples",
-  category: "Base Layers",
-  description: "Concentric animated ripples emanating from a point",
-  acceptsUVContext: !0,
-  props: {
-    center: {
-      default: {
-        x: 0.5,
-        y: 0.5
-      },
-      transform: S,
-      description: "The center point where ripples emanate from",
-      ui: {
-        type: "position",
-        label: "Center"
-      }
-    },
-    colorA: {
-      default: "#ffffff",
-      transform: l,
-      description: "Color of the ripple waves",
-      ui: {
-        type: "color",
-        label: "Color A"
-      }
-    },
-    colorB: {
-      default: "#000000",
-      transform: l,
-      description: "Background color between ripples",
-      ui: {
-        type: "color",
-        label: "Color B"
-      }
-    },
-    speed: {
-      default: 1,
-      description: "Speed of ripple animation",
-      ui: {
-        type: "range",
-        min: -5,
-        max: 5,
-        step: 0.1,
-        label: "Speed"
-      }
-    },
-    frequency: {
-      default: 20,
-      description: "Number of ripples/spacing between them",
-      ui: {
-        type: "range",
-        min: 1,
-        max: 80,
-        step: 0.1,
-        label: "Frequency"
-      }
-    },
-    softness: {
-      default: 0,
-      description: "Softness of ripple edges",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 3,
-        step: 0.01,
-        label: "Softness"
-      }
-    },
-    thickness: {
-      default: 0.5,
-      description: "Thickness of each ripple band",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 1,
-        step: 0.01,
-        label: "Thickness"
-      }
-    },
-    phase: {
-      default: 0,
-      description: "Phase offset for ripple animation",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 6.28,
-        step: 0.01,
-        label: "Phase"
-      }
-    }
-  },
-  fragmentNode: (o) => {
-    const { uniforms: e, uvContext: f } = o, { vec2: t, float: s, screenUV: m, sin: u, distance: d, viewportSize: n, smoothstep: h } = T, r = f ?? m, i = e.center.uniform, y = e.colorA.uniform, b = e.colorB.uniform, x = e.frequency.uniform, a = e.softness.uniform, g = e.thickness.uniform, C = e.phase.uniform, p = n.x.div(n.y), v = d(t(r.x.mul(p), r.y), t(i.x.mul(p), i.y.oneMinus())), k = A(o, e.speed), B = u(v.mul(x).sub(k).add(C)), c = g.mul(s(2)).sub(s(1));
-    return q(b, y, h(c.add(a), c.sub(a), B), w(0));
-  }
-};
-var V = P;
-export {
-  P as n,
-  V as t
-};