shaders 2.2.23 → 2.2.25

package/dist/core/Grid-DlM-rVbZ.js

@@ -1,50 +0,0 @@
-import { O as k } from "./three.tsl-Btj1hLsf.js";
-import { r as T } from "./transformations-CsrIJXh-.js";
-const C = {
-  name: "Grid",
-  category: "Base Layers",
-  description: "Simple grid lines pattern with adjustable thickness",
-  acceptsUVContext: !0,
-  props: {
-    color: {
-      default: "#ffffff",
-      transform: T,
-      description: "The color of the grid lines",
-      ui: {
-        type: "color",
-        label: "Color"
-      }
-    },
-    cells: {
-      default: 10,
-      description: "Number of cells along the shortest canvas edge (creates square cells)",
-      ui: {
-        type: "range",
-        min: 1,
-        max: 50,
-        step: 1,
-        label: "Cells"
-      }
-    },
-    thickness: {
-      default: 1,
-      description: "Thickness of grid lines (normalized, 0.0-1.0)",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 5,
-        step: 0.1,
-        label: "Thickness"
-      }
-    }
-  },
-  fragmentNode: ({ uniforms: e, uvContext: l }) => {
-    const { vec2: a, vec4: d, fract: m, max: p, screenUV: f, viewportSize: o, fwidth: u, smoothstep: n } = k, 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()), v = t.y.min(t.y.oneMinus()), c = u(r), b = p(n(s.add(c.x), s, y), n(s.add(c.y), s, v));
-    return d(e.color.uniform.rgb, e.color.uniform.a.mul(b));
-  }
-};
-var V = C;
-export {
-  C as n,
-  V as t
-};

package/dist/core/GridDistortion-ZOZphSAT.js

@@ -1,147 +0,0 @@
-import { D as $, O as B } from "./three.tsl-Btj1hLsf.js";
-import { t as J } from "./edges-CDzKsauJ.js";
-import { a as K } from "./transformations-CsrIJXh-.js";
-import { DataTexture as Q, FloatType as ee, LinearFilter as C, RGFormat as te } from "three";
-var ae = 20, f = /* @__PURE__ */ new WeakMap(), ie = (e) => {
-  let t = f.get(e);
-  const n = e?.gridSize?.uniform?.value ? Math.max(8, Math.min(128, Math.floor(e.gridSize.uniform.value))) : ae;
-  if (t && t.gridSize !== n && (t.texture.dispose(), t = void 0, f.delete(e)), !t) {
-    const l = new Float32Array(n * n * 2), s = new Q(l, n, n, te, ee);
-    s.magFilter = C, s.minFilter = C, s.needsUpdate = !0, t = {
-      texture: s,
-      data: l,
-      tslNode: $(s),
-      gridSize: n
-    }, f.set(e, t);
-  }
-  return t;
-};
-const re = {
-  name: "GridDistortion",
-  category: "Interactive",
-  description: "Interactive grid distortion controlled by mouse position",
-  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: K,
-      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: n, onCleanup: l }) => {
-    const { vec2: s, vec4: H, float: g, uniform: T, screenUV: w, convertToTexture: L } = B, { texture: z, data: a, tslNode: N, gridSize: d } = ie(e), h = T(0), v = T(0);
-    let F = 0.5, I = 0.5, R = Date.now();
-    if (t(({ pointer: o }) => {
-      const _ = Date.now(), i = Math.min((_ - R) / 1e3, 0.016);
-      R = _;
-      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 k = (m + 0.5) / d, P = (u + 0.5) / d, S = k - 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, I = o.y;
-    }), l(() => {
-      z.dispose(), f.delete(e);
-    }), !n) return H(0, 0, 0, 0);
-    const c = L(n);
-    l(() => {
-      c?.renderTarget?.dispose && c.renderTarget.dispose();
-    });
-    const O = e.gridSize.uniform, x = g(1).div(O), W = w.div(x).floor().mul(x).add(x.mul(0.5)), Z = N.sample(W).xy, U = g(0.1), E = g(-0.1), j = Z.clamp(s(E, E), s(U, U)), G = w.sub(j);
-    return J(G, c.sample(G), c, e.edges.uniform);
-  }
-};
-var de = re;
-export {
-  re as n,
-  de as t
-};

package/dist/core/Group-BQAs3RiH.js

@@ -1,17 +0,0 @@
-import { O as r } from "./three.tsl-Btj1hLsf.js";
-const t = {
-  name: "Group",
-  category: "Utilities",
-  description: "Container for organizing and composing child effects",
-  requiresChild: !0,
-  props: {},
-  fragmentNode: ({ childNode: e }) => {
-    const { vec4: o } = r;
-    return e || o(0);
-  }
-};
-var i = t;
-export {
-  t as n,
-  i as t
-};

package/dist/core/Halftone-ci4ga-_J.js

@@ -1,55 +0,0 @@
-import { O as V } from "./three.tsl-Btj1hLsf.js";
-import { n as A } from "./transformations-CsrIJXh-.js";
-const D = {
-  name: "Halftone",
-  category: "Stylize",
-  description: "Halftone dot pattern effect for printing aesthetics",
-  requiresChild: !0,
-  props: {
-    frequency: {
-      default: 100,
-      description: "Frequency of the halftone dots",
-      ui: {
-        type: "range",
-        min: 10,
-        max: 300,
-        step: 1,
-        label: "Frequency"
-      }
-    },
-    angle: {
-      default: 45,
-      transform: A,
-      description: "Rotation angle of the pattern (in degrees)",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 360,
-        step: 1,
-        label: "Angle"
-      }
-    },
-    smoothness: {
-      default: 0.1,
-      description: "Edge smoothness of the dots",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 0.3,
-        step: 0.01,
-        label: "Smoothness"
-      }
-    }
-  },
-  fragmentNode: ({ uniforms: t, childNode: s }) => {
-    const { vec2: e, vec3: g, vec4: r, sin: h, cos: y, fract: b, length: v, smoothstep: x, dot: n, screenUV: q, viewportSize: a, radians: S } = V;
-    if (!s) return r(0);
-    const c = q, _ = t.frequency.uniform, z = t.angle.uniform, i = t.smoothness.uniform, l = S(z), C = a.x.div(a.y), m = e(c.x.mul(C), c.y), f = y(l), d = h(l), H = b(e(n(m, e(f, d.negate())), n(m, e(d, f))).mul(_)).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(i), u.sub(i), U);
-    return r(o.rgb.mul(p), o.a.mul(p));
-  }
-};
-var E = D;
-export {
-  D as n,
-  E as t
-};

package/dist/core/HueShift-CyxzPcJV.js

@@ -1,32 +0,0 @@
-import { O as n } from "./three.tsl-Btj1hLsf.js";
-import { n as s } from "./ColorAdjustment-CKwpE_4M.js";
-const i = {
-  name: "HueShift",
-  category: "Adjustments",
-  description: "Rotate hue around the color wheel",
-  requiresChild: !0,
-  props: { shift: {
-    default: 0,
-    description: "The amount to shift the hue by",
-    ui: {
-      type: "range",
-      min: -180,
-      max: 180,
-      step: 1,
-      label: "Shift"
-    },
-    transform: (t) => t * Math.PI / 180
-  } },
-  fragmentNode: ({ uniforms: t, childNode: o }) => {
-    const { vec4: e } = n;
-    if (!o)
-      return console.error("You must pass a child component into the Hue Shift shader."), e(0);
-    const r = o || e(0, 0, 0, 0);
-    return e(s(r.rgb, t.shift.uniform).rgb, r.a);
-  }
-};
-var h = i;
-export {
-  i as n,
-  h as t
-};

package/dist/core/ImageTexture-CdAGsPuH.js

@@ -1,105 +0,0 @@
-import { B as S, H as oe, O as ae, S as ne, U as se, k as x, y } from "./three.tsl-Btj1hLsf.js";
-const ie = {
-  name: "ImageTexture",
-  category: "Base Layers",
-  description: "Display an image with customizable object-fit modes",
-  acceptsUVContext: !0,
-  props: {
-    url: {
-      default: "https://shaders.com/sample.jpg",
-      description: "Upload an image or provide a URL",
-      ui: {
-        type: "image-upload",
-        label: "Image"
-      }
-    },
-    objectFit: {
-      default: "cover",
-      description: "How the image should be sized within the viewport",
-      transform: (m) => ({
-        cover: 0,
-        contain: 1,
-        fill: 2,
-        "scale-down": 3,
-        none: 4
-      })[m] ?? 0,
-      ui: {
-        type: "select",
-        options: [
-          {
-            label: "Cover",
-            value: "cover"
-          },
-          {
-            label: "Contain",
-            value: "contain"
-          },
-          {
-            label: "Fill",
-            value: "fill"
-          },
-          {
-            label: "Scale Down",
-            value: "scale-down"
-          },
-          {
-            label: "None",
-            value: "none"
-          }
-        ],
-        label: "Object Fit"
-      }
-    }
-  },
-  fragmentNode: ({ uniforms: m, onCleanup: D, onBeforeRender: W, uvContext: A }) => {
-    const { vec2: o, vec4: B, float: t, texture: H, screenUV: N, viewportSize: l, step: a, min: u, max: O } = ae, z = A ?? N, _ = new se();
-    let T = "", r = !1;
-    const n = new oe();
-    n.colorSpace = S;
-    const $ = H(n), s = x(1), f = x(0), U = x(0), V = (e) => {
-      if (!(!e || e.trim() === "" || r)) {
-        r = !0;
-        try {
-          let h = e;
-          try {
-            h = new URL(e, window.location.href).href;
-          } catch {
-          }
-          _.load(e, (d) => {
-            d.colorSpace = S;
-            const p = d.image, w = p.width || 1, b = p.height || 1, te = w / b;
-            d.dispose(), T = e, requestAnimationFrame(() => {
-              const g = n.image;
-              g && typeof g == "object" && (g.width !== w || g.height !== b) && n.dispose(), s.value = te, f.value = w, U.value = b, n.image = p, n.colorSpace = S, n.needsUpdate = !0;
-            }), r = !1;
-          }, void 0, (d) => {
-            const p = !e.startsWith("http://") && !e.startsWith("https://") && !e.startsWith("data:");
-            console.error(`[ImageTexture] Failed to load image
-  Requested URL: ${e}
-  Resolved URL: ${h}
-  Path type: ${p ? "relative" : "absolute"}
-  Error:`, d), r = !1;
-          });
-        } catch (h) {
-          console.error("[ImageTexture] Error initiating image load:", h), r = !1;
-        }
-      }
-    };
-    setTimeout(() => {
-      const e = m?.url?.uniform?.value ?? "";
-      e && e.trim() !== "" && V(e);
-    }, 0), W(() => {
-      const e = m?.url?.uniform?.value ?? "";
-      e !== T && !r && V(e);
-    }), D(() => {
-      n.dispose();
-    });
-    const q = z, c = l.x.div(l.y), i = m.objectFit.uniform, j = O(c.div(s), t(1)), E = o(s.div(c).mul(j), j), F = u(c.div(s), t(1)), k = o(s.div(c).mul(F), F), G = o(1, 1), R = u(u(c.div(s), t(1)), u(l.x.div(f), l.y.div(U))), M = o(s.div(c).mul(R), R), C = u(l.x.div(f), l.y.div(U)), P = o(s.div(c).mul(C), C), 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(k.mul(K)).add(G.mul(Q)).add(M.mul(X)).add(P.mul(Y)), I = q.sub(o(0.5)).div(Z).add(o(0.5)), v = o(I.x, t(1).sub(I.y)), L = $.sample(v), ee = y(y(v.x.lessThan(0), v.x.greaterThan(1)), y(v.y.lessThan(0), v.y.greaterThan(1)));
-    return B(L.rgb, ne(ee, t(0), L.a));
-  }
-};
-var le = ie;
-export {
-  ie as n,
-  le as t
-};

package/dist/core/Invert-iPsiIqNZ.js

@@ -1,20 +0,0 @@
-import { O as a } from "./three.tsl-Btj1hLsf.js";
-const c = {
-  name: "Invert",
-  category: "Adjustments",
-  description: "Invert RGB colors while preserving alpha",
-  requiresChild: !0,
-  props: {},
-  fragmentNode: ({ childNode: t }) => {
-    const { vec4: r, vec3: n } = a;
-    if (!t)
-      return console.error("You must pass a child component into the Invert shader."), r(0);
-    const o = t || r(0, 0, 0, 0), e = o.a, s = e.greaterThan(0).select(o.rgb.div(e), n(0, 0, 0));
-    return r(n(1, 1, 1).sub(s).mul(e), e);
-  }
-};
-var p = c;
-export {
-  c as n,
-  p as t
-};

package/dist/core/LinearBlur-BEaaoIk-.js

@@ -1,56 +0,0 @@
-import { O as q } from "./three.tsl-Btj1hLsf.js";
-import { n as w } from "./transformations-CsrIJXh-.js";
-const A = {
-  name: "LinearBlur",
-  category: "Blurs",
-  description: "Directional motion blur in a specific angle",
-  requiresRTT: !0,
-  requiresChild: !0,
-  props: {
-    intensity: {
-      default: 30,
-      description: "Intensity of the linear blur effect",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 100,
-        step: 1,
-        label: "Intensity"
-      }
-    },
-    angle: {
-      default: 0,
-      transform: w,
-      description: "Direction of the linear blur (in degrees)",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 360,
-        step: 1,
-        label: "Angle"
-      }
-    }
-  },
-  fragmentNode: ({ uniforms: s, childNode: a, onCleanup: d }) => {
-    const { vec2: l, vec4: u, float: e, screenUV: p, viewportSize: f, sin: g, cos: v, radians: b, Fn: x, convertToTexture: y } = q;
-    if (!a) return u(0, 0, 0, 0);
-    const t = y(a);
-    d(() => {
-      t?.renderTarget?.dispose && t.renderTarget.dispose();
-    });
-    const c = b(s.angle.uniform), T = l(v(c), g(c));
-    return x(() => {
-      const h = p, D = l(1).div(f), V = T.mul(s.intensity.uniform).mul(D).mul(2), n = u(0).toVar(), r = e(0).toVar();
-      for (let i = 0; i < 32; i++) {
-        const o = e(i).div(e(31)).sub(0.5).mul(2), m = e(1).div(e(2.506628)).mul(e(-0.5).mul(o).mul(o).div(e(0.64)).exp()), B = h.add(V.mul(o.mul(0.5))), _ = t.sample(B).mul(m);
-        n.assign(n.add(_)), r.assign(r.add(m));
-      }
-      return n.div(r);
-    })();
-  }
-};
-var R = A;
-export {
-  A as n,
-  R as t
-};

package/dist/core/LinearGradient-DR_7RxLX.js

@@ -1,111 +0,0 @@
-import { O as W } from "./three.tsl-Btj1hLsf.js";
-import { a as X, i as Y, n as j, o as h, r as b, t as k } from "./transformations-CsrIJXh-.js";
-import { t as F } from "./colorMixing--dhzx0ch.js";
-const I = {
-  name: "LinearGradient",
-  category: "Base Layers",
-  description: "Create smooth linear color gradients",
-  acceptsUVContext: !0,
-  props: {
-    colorA: {
-      default: "#1aff00",
-      transform: b,
-      description: "The starting color of the gradient",
-      ui: {
-        type: "color",
-        label: "Color A"
-      }
-    },
-    colorB: {
-      default: "#0000ff",
-      transform: b,
-      description: "The ending color of the gradient",
-      ui: {
-        type: "color",
-        label: "Color B"
-      }
-    },
-    start: {
-      default: {
-        x: 0,
-        y: 0.5
-      },
-      transform: h,
-      description: "The starting point of the gradient",
-      ui: {
-        type: "position",
-        label: "Start"
-      }
-    },
-    end: {
-      default: {
-        x: 1,
-        y: 0.5
-      },
-      transform: h,
-      description: "The ending point of the gradient",
-      ui: {
-        type: "position",
-        label: "End"
-      }
-    },
-    angle: {
-      default: 0,
-      transform: j,
-      description: "Additional rotation angle of the gradient (in degrees)",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 360,
-        step: 1,
-        label: "Angle"
-      }
-    },
-    edges: {
-      default: "stretch",
-      transform: X,
-      description: "How to handle areas beyond the gradient endpoints",
-      ui: {
-        type: "select",
-        options: [
-          {
-            label: "Stretch",
-            value: "stretch"
-          },
-          {
-            label: "Transparent",
-            value: "transparent"
-          },
-          {
-            label: "Mirror",
-            value: "mirror"
-          },
-          {
-            label: "Wrap",
-            value: "wrap"
-          }
-        ],
-        label: "Edges"
-      }
-    },
-    colorSpace: {
-      default: "linear",
-      transform: Y,
-      description: "Color space for color interpolation",
-      ui: {
-        type: "select",
-        options: k,
-        label: "Color Space"
-      }
-    }
-  },
-  fragmentNode: ({ uniforms: t, uvContext: T }) => {
-    const { vec2: s, vec4: y, float: e, cos: x, sin: C, dot: v, radians: A, screenUV: E, length: B, normalize: M, abs: S, mod: q, fract: w } = W, L = T ?? E, l = s(t.start.uniform[0], t.start.uniform[1].oneMinus()), c = s(t.end.uniform[0], t.end.uniform[1].oneMinus()), d = c.sub(l), O = B(d), V = M(d), p = A(t.angle.uniform).negate(), u = x(p), m = C(p), f = l.add(c).mul(0.5), r = L.sub(f), o = v(s(r.x.mul(u).sub(r.y.mul(m)), r.x.mul(m).add(r.y.mul(u))).add(f).sub(l), V).div(O.max(1e-6)), a = t.edges.uniform, H = o.clamp(e(0), e(1)), P = o.greaterThanEqual(e(0)).select(e(1), e(0)), U = o.lessThanEqual(e(1)).select(e(1), e(0)), _ = P.mul(U), i = q(S(o), e(2)), z = i.greaterThan(e(1)).select(e(2).sub(i), i), D = w(o), g = a.greaterThanEqual(e(0.5)), G = a.greaterThanEqual(e(1.5)), N = a.greaterThanEqual(e(2.5)).select(D, G.select(z, g.select(o, H))), n = F(t.colorA.uniform, t.colorB.uniform, N.clamp(e(0), e(1)), t.colorSpace.uniform), R = g.and(a.lessThan(e(1.5))).select(n.w.mul(_), n.w);
-    return y(n.x, n.y, n.z, R);
-  }
-};
-var Z = I;
-export {
-  I as n,
-  Z as t
-};