shaders 2.2.24 → 2.2.25

package/dist/core/Godrays-DjLVuZa4.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-BbsdDa_X.js

@@ -1,21 +0,0 @@
-import { O as t } from "./three.tsl-Btj1hLsf.js";
-import { t as s } from "./ColorAdjustment-FeXXpypd.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
-};

package/dist/core/Grid-ByjU-_ua.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-C_eIlhkW.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-CyaDLGpI.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-BvuAe_k-.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-B_qE9c08.js

@@ -1,32 +0,0 @@
-import { O as n } from "./three.tsl-Btj1hLsf.js";
-import { n as s } from "./ColorAdjustment-FeXXpypd.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-h00TFC1l.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-BEDDB0sm.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-CLKxuyeT.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
-};