@basementstudio/shader-lab 0.1.0 → 1.0.2

package/dist/src/renderer/shaders/tsl/noise/curl-noise-4d.js

@@ -0,0 +1,27 @@
+// @ts-nocheck
+import { EPSILON, Fn, cross, vec3, vec4 } from "three/tsl";
+import { simplexNoise4d } from "./simplex-noise-4d.js";
+export const curlNoise4d = Fn(([inputA]) => {
+    const aXPos = simplexNoise4d(inputA.add(vec4(EPSILON, 0, 0, 0)));
+    const aXNeg = simplexNoise4d(inputA.sub(vec4(EPSILON, 0, 0, 0)));
+    const aXAverage = aXPos.sub(aXNeg).div(EPSILON.mul(2));
+    const aYPos = simplexNoise4d(inputA.add(vec4(0, EPSILON, 0, 0)));
+    const aYNeg = simplexNoise4d(inputA.sub(vec4(0, EPSILON, 0, 0)));
+    const aYAverage = aYPos.sub(aYNeg).div(EPSILON.mul(2));
+    const aZPos = simplexNoise4d(inputA.add(vec4(0, 0, EPSILON, 0)));
+    const aZNeg = simplexNoise4d(inputA.sub(vec4(0, 0, EPSILON, 0)));
+    const aZAverage = aZPos.sub(aZNeg).div(EPSILON.mul(2));
+    const aGrabNoise = vec3(aXAverage, aYAverage, aZAverage).normalize();
+    const inputB = inputA.add(3.5);
+    const bXPos = simplexNoise4d(inputB.add(vec4(EPSILON, 0, 0, 0)));
+    const bXNeg = simplexNoise4d(inputB.sub(vec4(EPSILON, 0, 0, 0)));
+    const bXAverage = bXPos.sub(bXNeg).div(EPSILON.mul(2));
+    const bYPos = simplexNoise4d(inputB.add(vec4(0, EPSILON, 0, 0)));
+    const bYNeg = simplexNoise4d(inputB.sub(vec4(0, EPSILON, 0, 0)));
+    const bYAverage = bYPos.sub(bYNeg).div(EPSILON.mul(2));
+    const bZPos = simplexNoise4d(inputB.add(vec4(0, 0, EPSILON, 0)));
+    const bZNeg = simplexNoise4d(inputB.sub(vec4(0, 0, EPSILON, 0)));
+    const bZAverage = bZPos.sub(bZNeg).div(EPSILON.mul(2));
+    const bGrabNoise = vec3(bXAverage, bYAverage, bZAverage).normalize();
+    return cross(aGrabNoise, bGrabNoise).normalize();
+});

package/dist/src/renderer/shaders/tsl/noise/fbm.d.ts

@@ -0,0 +1 @@
+export declare const fbm: (...args: unknown[]) => import("three/tsl").TSLNode;

package/dist/src/renderer/shaders/tsl/noise/fbm.js

@@ -0,0 +1,11 @@
+// @ts-nocheck
+import { Fn, vec3 } from "three/tsl";
+import { simplexNoise3d } from "./simplex-noise-3d.js";
+export const fbm = Fn(([pImmutable]) => {
+    const p = vec3(pImmutable).toVar();
+    const n1 = simplexNoise3d(p).mul(0.5).add(0.5);
+    const n2 = simplexNoise3d(p.mul(2.02).add(vec3(19.1, 7.3, 13.7)))
+        .mul(0.5)
+        .add(0.5);
+    return n1.mul(0.7).add(n2.mul(0.3));
+});

package/dist/src/renderer/shaders/tsl/noise/perlin-noise-3d.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Classic Perlin noise (3D) — Ashima Arts / Stefan Gustavson port.
+ * Uses permute + taylorInvSqrt (same as simplex noise) for gradient generation.
+ */
+export declare const perlinNoise3d: (...args: unknown[]) => import("three/tsl").TSLNode;

package/dist/src/renderer/shaders/tsl/noise/perlin-noise-3d.js

@@ -0,0 +1,66 @@
+// @ts-nocheck
+import { Fn, abs, dot, floor, fract, mix, mod, mul, step, sub, vec2, vec3, vec4, } from "three/tsl";
+import { fade, permute, taylorInvSqrt } from "./common.js";
+/**
+ * Classic Perlin noise (3D) — Ashima Arts / Stefan Gustavson port.
+ * Uses permute + taylorInvSqrt (same as simplex noise) for gradient generation.
+ */
+export const perlinNoise3d = Fn(([pImmutable]) => {
+    const P = vec3(pImmutable).toVar();
+    const Pi0 = vec3(mod(floor(P), 289.0)).toVar();
+    const Pi1 = vec3(mod(Pi0.add(1.0), 289.0)).toVar();
+    const Pf0 = vec3(fract(P)).toVar();
+    const Pf1 = vec3(Pf0.sub(1.0)).toVar();
+    const ix = vec4(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
+    const iy = vec4(Pi0.y, Pi0.y, Pi1.y, Pi1.y);
+    const iz0 = vec4(Pi0.z, Pi0.z, Pi0.z, Pi0.z);
+    const iz1 = vec4(Pi1.z, Pi1.z, Pi1.z, Pi1.z);
+    const ixy = vec4(permute(permute(ix).add(iy))).toVar();
+    const ixy0 = vec4(permute(ixy.add(iz0))).toVar();
+    const ixy1 = vec4(permute(ixy.add(iz1))).toVar();
+    const gx0 = vec4(ixy0.div(7.0)).toVar();
+    const gy0 = vec4(fract(floor(gx0).div(7.0)).sub(0.5)).toVar();
+    gx0.assign(fract(gx0));
+    const gz0 = vec4(sub(0.5, abs(gx0)).sub(abs(gy0))).toVar();
+    const sz0 = vec4(step(gz0, vec4(0.0))).toVar();
+    gx0.assign(gx0.sub(sz0.mul(step(0.0, gx0).sub(0.5))));
+    gy0.assign(gy0.sub(sz0.mul(step(0.0, gy0).sub(0.5))));
+    const gx1 = vec4(ixy1.div(7.0)).toVar();
+    const gy1 = vec4(fract(floor(gx1).div(7.0)).sub(0.5)).toVar();
+    gx1.assign(fract(gx1));
+    const gz1 = vec4(sub(0.5, abs(gx1)).sub(abs(gy1))).toVar();
+    const sz1 = vec4(step(gz1, vec4(0.0))).toVar();
+    gx1.assign(gx1.sub(sz1.mul(step(0.0, gx1).sub(0.5))));
+    gy1.assign(gy1.sub(sz1.mul(step(0.0, gy1).sub(0.5))));
+    const g000 = vec3(gx0.x, gy0.x, gz0.x).toVar();
+    const g100 = vec3(gx0.y, gy0.y, gz0.y).toVar();
+    const g010 = vec3(gx0.z, gy0.z, gz0.z).toVar();
+    const g110 = vec3(gx0.w, gy0.w, gz0.w).toVar();
+    const g001 = vec3(gx1.x, gy1.x, gz1.x).toVar();
+    const g101 = vec3(gx1.y, gy1.y, gz1.y).toVar();
+    const g011 = vec3(gx1.z, gy1.z, gz1.z).toVar();
+    const g111 = vec3(gx1.w, gy1.w, gz1.w).toVar();
+    const norm0 = vec4(taylorInvSqrt(vec4(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)))).toVar();
+    g000.mulAssign(norm0.x);
+    g010.mulAssign(norm0.y);
+    g100.mulAssign(norm0.z);
+    g110.mulAssign(norm0.w);
+    const norm1 = vec4(taylorInvSqrt(vec4(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)))).toVar();
+    g001.mulAssign(norm1.x);
+    g011.mulAssign(norm1.y);
+    g101.mulAssign(norm1.z);
+    g111.mulAssign(norm1.w);
+    const n000 = dot(g000, Pf0);
+    const n100 = dot(g100, vec3(Pf1.x, Pf0.y, Pf0.z));
+    const n010 = dot(g010, vec3(Pf0.x, Pf1.y, Pf0.z));
+    const n110 = dot(g110, vec3(Pf1.x, Pf1.y, Pf0.z));
+    const n001 = dot(g001, vec3(Pf0.x, Pf0.y, Pf1.z));
+    const n101 = dot(g101, vec3(Pf1.x, Pf0.y, Pf1.z));
+    const n011 = dot(g011, vec3(Pf0.x, Pf1.y, Pf1.z));
+    const n111 = dot(g111, Pf1);
+    const fadeXyz = vec3(fade(Pf0)).toVar();
+    const nZ = vec4(mix(vec4(n000, n100, n010, n110), vec4(n001, n101, n011, n111), fadeXyz.z));
+    const nYz = vec2(mix(nZ.xy, nZ.zw, fadeXyz.y));
+    const nXyz = mix(nYz.x, nYz.y, fadeXyz.x);
+    return mul(2.2, nXyz);
+});

package/dist/src/renderer/shaders/tsl/noise/ridge-noise.d.ts

@@ -0,0 +1 @@
+export declare const ridgeNoise: (...args: unknown[]) => import("three/tsl").TSLNode;

package/dist/src/renderer/shaders/tsl/noise/ridge-noise.js

@@ -0,0 +1,19 @@
+// @ts-nocheck
+import { Fn, Loop, abs, clamp, float } from "three/tsl";
+import { simplexNoise3d } from "./simplex-noise-3d.js";
+export const ridgeNoise = Fn(([pImmutable]) => {
+    const p = pImmutable.toVar();
+    const value = float(0).toVar();
+    const amplitude = float(0.5).toVar();
+    const frequency = float(1).toVar();
+    const weight = float(1).toVar();
+    Loop({ end: 6, start: 0, type: "int" }, () => {
+        const n = float(1).sub(abs(simplexNoise3d(p.mul(frequency)).mul(2)));
+        const signal = n.mul(n).mul(weight);
+        value.addAssign(signal.mul(amplitude));
+        weight.assign(clamp(signal, 0, 1));
+        frequency.mulAssign(2.0);
+        amplitude.mulAssign(0.5);
+    });
+    return value;
+});

package/dist/src/renderer/shaders/tsl/noise/simplex-noise-3d.d.ts

@@ -0,0 +1 @@
+export declare const simplexNoise3d: (...args: unknown[]) => import("three/tsl").TSLNode;

package/dist/src/renderer/shaders/tsl/noise/simplex-noise-3d.js

@@ -0,0 +1,44 @@
+// @ts-nocheck
+import { Fn, abs, dot, float, floor, max, min, mod, mul, step, sub, vec2, vec3, vec4, } from "three/tsl";
+import { permute, taylorInvSqrt } from "./common.js";
+export const simplexNoise3d = Fn(([vImmutable]) => {
+    const v = vec3(vImmutable).toVar();
+    const c = vec2(1.0 / 6.0, 1.0 / 3.0);
+    const d = vec4(0.0, 0.5, 1.0, 2.0);
+    const i = vec3(floor(v.add(dot(v, c.yyy)))).toVar();
+    const x0 = vec3(v.sub(i).add(dot(i, c.xxx))).toVar();
+    const g = vec3(step(x0.yzx, x0.xyz)).toVar();
+    const l = vec3(sub(1.0, g)).toVar();
+    const i1 = vec3(min(g.xyz, l.zxy)).toVar();
+    const i2 = vec3(max(g.xyz, l.zxy)).toVar();
+    const x1 = vec3(x0.sub(i1).add(mul(1.0, c.xxx))).toVar();
+    const x2 = vec3(x0.sub(i2).add(mul(2.0, c.xxx))).toVar();
+    const x3 = vec3(x0.sub(1).add(mul(3.0, c.xxx))).toVar();
+    i.assign(mod(i, 289.0));
+    const p = vec4(permute(permute(permute(i.z.add(vec4(0.0, i1.z, i2.z, 1.0))).add(i.y.add(vec4(0.0, i1.y, i2.y, 1.0)))).add(i.x.add(vec4(0.0, i1.x, i2.x, 1.0))))).toVar();
+    const n = float(1.0 / 7.0).toVar();
+    const ns = vec3(n.mul(d.wyz).sub(d.xzx)).toVar();
+    const j = vec4(p.sub(mul(49.0, floor(p.mul(ns.z.mul(ns.z)))))).toVar();
+    const x = vec4(floor(j.mul(ns.z)).mul(ns.x).add(ns.yyyy)).toVar();
+    const y = vec4(floor(j.sub(mul(7.0, floor(j.mul(ns.z))))).mul(ns.x).add(ns.yyyy)).toVar();
+    const h = vec4(sub(1.0, abs(x).sub(abs(y)))).toVar();
+    const b0 = vec4(x.xy, y.xy).toVar();
+    const b1 = vec4(x.zw, y.zw).toVar();
+    const s0 = vec4(floor(b0).mul(2.0).add(1.0)).toVar();
+    const s1 = vec4(floor(b1).mul(2.0).add(1.0)).toVar();
+    const sh = vec4(step(h, vec4(0.0)).negate()).toVar();
+    const a0 = vec4(b0.xzyw.add(s0.xzyw.mul(sh.xxyy))).toVar();
+    const a1 = vec4(b1.xzyw.add(s1.xzyw.mul(sh.zzww))).toVar();
+    const p0 = vec3(a0.xy, h.x).toVar();
+    const p1 = vec3(a0.zw, h.y).toVar();
+    const p2 = vec3(a1.xy, h.z).toVar();
+    const p3 = vec3(a1.zw, h.w).toVar();
+    const norm = vec4(taylorInvSqrt(vec4(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)))).toVar();
+    p0.mulAssign(norm.x);
+    p1.mulAssign(norm.y);
+    p2.mulAssign(norm.z);
+    p3.mulAssign(norm.w);
+    const m = vec4(max(sub(0.6, vec4(dot(x0, x0), dot(x1, x1), dot(x2, x2), dot(x3, x3))), 0.0)).toVar();
+    m.assign(m.mul(m));
+    return mul(42.0, dot(m.mul(m), vec4(dot(p0, x0), dot(p1, x1), dot(p2, x2), dot(p3, x3))));
+});

package/dist/src/renderer/shaders/tsl/noise/simplex-noise-4d.d.ts

@@ -0,0 +1 @@
+export declare const simplexNoise4d: (...args: unknown[]) => import("three/tsl").TSLNode;

package/dist/src/renderer/shaders/tsl/noise/simplex-noise-4d.js

@@ -0,0 +1,51 @@
+// @ts-nocheck
+import { Fn, clamp, dot, float, floor, max, mod, mul, step, sub, vec2, vec3, vec4, } from "three/tsl";
+import { grad4, permute, taylorInvSqrt } from "./common.js";
+export const simplexNoise4d = Fn(([vImmutable]) => {
+    const v = vec4(vImmutable).toVar();
+    const c = vec2(0.1381966011250105, 0.30901699437494745);
+    const i = vec4(floor(v.add(dot(v, c.yyyy)))).toVar();
+    const x0 = vec4(v.sub(i).add(dot(i, c.xxxx))).toVar();
+    const i0 = vec4().toVar();
+    const isX = vec3(step(x0.yzw, x0.xxx)).toVar();
+    const isYZ = vec3(step(x0.zww, x0.yyz)).toVar();
+    i0.x.assign(isX.x.add(isX.y).add(isX.z));
+    i0.yzw.assign(sub(1.0, isX));
+    i0.y.addAssign(isYZ.x.add(isYZ.y));
+    i0.zw.addAssign(sub(1.0, isYZ.xy));
+    i0.z.addAssign(isYZ.z);
+    i0.w.addAssign(sub(1.0, isYZ.z));
+    const i3 = vec4(clamp(i0, 0.0, 1.0)).toVar();
+    const i2 = vec4(clamp(i0.sub(1.0), 0.0, 1.0)).toVar();
+    const i1 = vec4(clamp(i0.sub(2.0), 0.0, 1.0)).toVar();
+    const x1 = vec4(x0.sub(i1).add(mul(1.0, c.xxxx))).toVar();
+    const x2 = vec4(x0.sub(i2).add(mul(2.0, c.xxxx))).toVar();
+    const x3 = vec4(x0.sub(i3).add(mul(3.0, c.xxxx))).toVar();
+    const x4 = vec4(x0.sub(1.0).add(mul(4.0, c.xxxx))).toVar();
+    i.assign(mod(i, 289.0));
+    const j0 = float(permute(permute(permute(permute(i.w).add(i.z)).add(i.y)).add(i.x))).toVar();
+    const j1 = vec4(permute(permute(permute(permute(i.w.add(vec4(i1.w, i2.w, i3.w, 1.0)))
+        .add(i.z)
+        .add(vec4(i1.z, i2.z, i3.z, 1.0)))
+        .add(i.y)
+        .add(vec4(i1.y, i2.y, i3.y, 1.0)))
+        .add(i.x)
+        .add(vec4(i1.x, i2.x, i3.x, 1.0)))).toVar();
+    const ip = vec4(1.0 / 294.0, 1.0 / 49.0, 1.0 / 7.0, 0.0).toVar();
+    const p0 = vec4(grad4(j0, ip)).toVar();
+    const p1 = vec4(grad4(j1.x, ip)).toVar();
+    const p2 = vec4(grad4(j1.y, ip)).toVar();
+    const p3 = vec4(grad4(j1.z, ip)).toVar();
+    const p4 = vec4(grad4(j1.w, ip)).toVar();
+    const norm = vec4(taylorInvSqrt(vec4(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)))).toVar();
+    p0.mulAssign(norm.x);
+    p1.mulAssign(norm.y);
+    p2.mulAssign(norm.z);
+    p3.mulAssign(norm.w);
+    p4.mulAssign(taylorInvSqrt(dot(p4, p4)));
+    const m0 = vec3(max(sub(0.6, vec3(dot(x0, x0), dot(x1, x1), dot(x2, x2))), 0.0)).toVar();
+    const m1 = vec2(max(sub(0.6, vec2(dot(x3, x3), dot(x4, x4))), 0.0)).toVar();
+    m0.assign(m0.mul(m0));
+    m1.assign(m1.mul(m1));
+    return mul(49.0, dot(m0.mul(m0), vec3(dot(p0, x0), dot(p1, x1), dot(p2, x2))).add(dot(m1.mul(m1), vec2(dot(p3, x3), dot(p4, x4)))));
+});

package/dist/src/renderer/shaders/tsl/noise/turbulence.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Turbulence based on XorDev's "Turbulent Dark" technique.
+ * Displaces coordinates by layering rotated sine waves at increasing frequencies
+ *
+ * @see https://mini.gmshaders.com/p/turbulence
+ */
+export declare const turbulence: (...args: unknown[]) => import("three/tsl").TSLNode;

package/dist/src/renderer/shaders/tsl/noise/turbulence.js

@@ -0,0 +1,34 @@
+// @ts-nocheck
+import { Fn, float, Loop, sin, vec2 } from "three/tsl";
+const HALF_PI = 1.5707963267948966;
+const THETA = 0.9272952180016122;
+/**
+ * Turbulence based on XorDev's "Turbulent Dark" technique.
+ * Displaces coordinates by layering rotated sine waves at increasing frequencies
+ *
+ * @see https://mini.gmshaders.com/p/turbulence
+ */
+export const turbulence = Fn(([pInput, time, rawOptions]) => {
+    const options = rawOptions ?? {};
+    const { _num = 10, _amp = 0.7, _speed = 0.3, _freq = 2.0, _exp = 1.4, } = options;
+    const p = vec2(pInput.xy).toVar();
+    const t = time.mul(float(_speed));
+    const freq = float(_freq).toVar();
+    const angle = float(0.0).toVar();
+    const iter = float(0.0).toVar();
+    Loop({ end: _num, start: 0, type: "int" }, () => {
+        const c = sin(angle.add(HALF_PI));
+        const s = sin(angle);
+        const phase = freq
+            .mul(p.x.mul(s).add(p.y.mul(c)))
+            .add(t)
+            .add(iter);
+        const scale = float(_amp).mul(sin(phase)).div(freq);
+        p.x.addAssign(scale.mul(c));
+        p.y.addAssign(scale.mul(s.negate()));
+        angle.addAssign(THETA);
+        freq.mulAssign(float(_exp));
+        iter.addAssign(1.0);
+    });
+    return p.sub(pInput.xy);
+});

package/dist/src/renderer/shaders/tsl/noise/value-noise-3d.d.ts

@@ -0,0 +1 @@
+export declare const valueNoise3d: (...args: unknown[]) => import("three/tsl").TSLNode;

package/dist/src/renderer/shaders/tsl/noise/value-noise-3d.js

@@ -0,0 +1,27 @@
+// @ts-nocheck
+import { Fn, dot, floor, fract, mix, sin, vec3 } from "three/tsl";
+import { fade } from "./common.js";
+const hash31 = Fn(([p]) => {
+    return fract(sin(dot(p, vec3(127.1, 311.7, 74.7))).mul(43758.5453123));
+});
+export const valueNoise3d = Fn(([pImmutable]) => {
+    const p = vec3(pImmutable).toVar();
+    const cell = vec3(floor(p)).toVar();
+    const local = vec3(fract(p)).toVar();
+    const eased = vec3(fade(local)).toVar();
+    const n000 = hash31(cell);
+    const n100 = hash31(cell.add(vec3(1, 0, 0)));
+    const n010 = hash31(cell.add(vec3(0, 1, 0)));
+    const n110 = hash31(cell.add(vec3(1, 1, 0)));
+    const n001 = hash31(cell.add(vec3(0, 0, 1)));
+    const n101 = hash31(cell.add(vec3(1, 0, 1)));
+    const n011 = hash31(cell.add(vec3(0, 1, 1)));
+    const n111 = hash31(cell.add(vec3(1, 1, 1)));
+    const nx00 = mix(n000, n100, eased.x);
+    const nx10 = mix(n010, n110, eased.x);
+    const nx01 = mix(n001, n101, eased.x);
+    const nx11 = mix(n011, n111, eased.x);
+    const nxy0 = mix(nx00, nx10, eased.y);
+    const nxy1 = mix(nx01, nx11, eased.y);
+    return mix(nxy0, nxy1, eased.z).mul(2).sub(1);
+});

package/dist/src/renderer/shaders/tsl/noise/voronoi-noise-3d.d.ts

@@ -0,0 +1 @@
+export declare const voronoiNoise3d: (...args: unknown[]) => import("three/tsl").TSLNode;

package/dist/src/renderer/shaders/tsl/noise/voronoi-noise-3d.js

@@ -0,0 +1,45 @@
+// @ts-nocheck
+import { Fn, dot, float, floor, fract, length, min, sin, vec3 } from "three/tsl";
+const random3 = Fn(([p]) => {
+    return fract(sin(vec3(dot(p, vec3(127.1, 311.7, 74.7)), dot(p, vec3(269.5, 183.3, 246.1)), dot(p, vec3(113.5, 271.9, 124.6)))).mul(43758.5453));
+});
+const checkNeighbor = Fn(([i, f, neighbor, currentMin]) => {
+    const point = random3(i.add(neighbor));
+    const diff = neighbor.add(point).sub(f);
+    return min(currentMin, length(diff));
+});
+export const voronoiNoise3d = Fn(([pImmutable]) => {
+    const p = vec3(pImmutable).toVar();
+    const i = vec3(floor(p)).toVar();
+    const f = vec3(fract(p)).toVar();
+    const d = float(1).toVar();
+    // Unrolled 3x3x3 neighbor search
+    d.assign(checkNeighbor(i, f, vec3(-1, -1, -1), d));
+    d.assign(checkNeighbor(i, f, vec3(-1, -1, 0), d));
+    d.assign(checkNeighbor(i, f, vec3(-1, -1, 1), d));
+    d.assign(checkNeighbor(i, f, vec3(-1, 0, -1), d));
+    d.assign(checkNeighbor(i, f, vec3(-1, 0, 0), d));
+    d.assign(checkNeighbor(i, f, vec3(-1, 0, 1), d));
+    d.assign(checkNeighbor(i, f, vec3(-1, 1, -1), d));
+    d.assign(checkNeighbor(i, f, vec3(-1, 1, 0), d));
+    d.assign(checkNeighbor(i, f, vec3(-1, 1, 1), d));
+    d.assign(checkNeighbor(i, f, vec3(0, -1, -1), d));
+    d.assign(checkNeighbor(i, f, vec3(0, -1, 0), d));
+    d.assign(checkNeighbor(i, f, vec3(0, -1, 1), d));
+    d.assign(checkNeighbor(i, f, vec3(0, 0, -1), d));
+    d.assign(checkNeighbor(i, f, vec3(0, 0, 0), d));
+    d.assign(checkNeighbor(i, f, vec3(0, 0, 1), d));
+    d.assign(checkNeighbor(i, f, vec3(0, 1, -1), d));
+    d.assign(checkNeighbor(i, f, vec3(0, 1, 0), d));
+    d.assign(checkNeighbor(i, f, vec3(0, 1, 1), d));
+    d.assign(checkNeighbor(i, f, vec3(1, -1, -1), d));
+    d.assign(checkNeighbor(i, f, vec3(1, -1, 0), d));
+    d.assign(checkNeighbor(i, f, vec3(1, -1, 1), d));
+    d.assign(checkNeighbor(i, f, vec3(1, 0, -1), d));
+    d.assign(checkNeighbor(i, f, vec3(1, 0, 0), d));
+    d.assign(checkNeighbor(i, f, vec3(1, 0, 1), d));
+    d.assign(checkNeighbor(i, f, vec3(1, 1, -1), d));
+    d.assign(checkNeighbor(i, f, vec3(1, 1, 0), d));
+    d.assign(checkNeighbor(i, f, vec3(1, 1, 1), d));
+    return d;
+});

package/dist/src/renderer/shaders/tsl/patterns/bloom-edge-pattern.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Returns a repeating pattern of lines with a bloom effect.
+ */
+export declare const bloomEdgePattern: (...args: unknown[]) => import("three/tsl").TSLNode;

package/dist/src/renderer/shaders/tsl/patterns/bloom-edge-pattern.js

@@ -0,0 +1,13 @@
+// @ts-nocheck
+import { Fn, abs, float } from "three/tsl";
+import { bloom } from "./bloom.js";
+import { repeatingPattern } from "./repeating-pattern.js";
+/**
+ * Returns a repeating pattern of lines with a bloom effect.
+ */
+export const bloomEdgePattern = Fn(([pattern, repeat, edge, exponent, time = float(0)]) => {
+    pattern.assign(repeatingPattern(pattern, repeat, time));
+    pattern.assign(abs(pattern));
+    pattern.assign(bloom(pattern, edge, exponent));
+    return pattern;
+});

package/dist/src/renderer/shaders/tsl/patterns/bloom.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Returns a bloomed edge based on a given edge and pattern.
+ */
+export declare const bloom: (...args: unknown[]) => import("three/tsl").TSLNode;

package/{packages/shader-lab-react/src/renderer/shaders/tsl/patterns/bloom.ts → dist/src/renderer/shaders/tsl/patterns/bloom.js}

@@ -1,11 +1,9 @@
 // @ts-nocheck
-import { Fn, pow } from "three/tsl"
-
+import { Fn, pow } from "three/tsl";
 /**
  * Returns a bloomed edge based on a given edge and pattern.
  */
 export const bloom = Fn(([pattern, edge, exponent]) => {
-  pattern.assign(pow(edge.div(pattern), exponent))
-
-  return pattern
-})
+    pattern.assign(pow(edge.div(pattern), exponent));
+    return pattern;
+});

package/dist/src/renderer/shaders/tsl/patterns/canvas-weave-pattern.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Returns a canvas weave pattern value for a given UV coordinate.
+ */
+export declare const canvasWeavePattern: (...args: unknown[]) => import("three/tsl").TSLNode;

package/dist/src/renderer/shaders/tsl/patterns/canvas-weave-pattern.js

@@ -0,0 +1,16 @@
+// @ts-nocheck
+import { Fn, PI, mix, sin, smoothstep, vec3 } from "three/tsl";
+import { fbm } from "../noise/fbm.js";
+/**
+ * Returns a canvas weave pattern value for a given UV coordinate.
+ */
+export const canvasWeavePattern = Fn(([uv]) => {
+    const grid = uv.mul(200.0).fract();
+    const noiseOffset = fbm(vec3(uv.mul(30.0), 0.0), { octaves: 3 }).mul(0.1);
+    const warpedGrid = grid.add(noiseOffset);
+    const weaveX = sin(warpedGrid.x.mul(PI).add(fbm(vec3(uv.mul(100.0), 0.0), { octaves: 2 }).mul(0.5)));
+    const weaveY = sin(warpedGrid.y.mul(PI).add(fbm(vec3(uv.mul(100.0).add(0.5), 0.0), { octaves: 2 }).mul(0.5)));
+    const weave = weaveX.mul(weaveY);
+    const smoothedWeave = smoothstep(-0.3, 0.3, weave);
+    return mix(0.9, 1.0, smoothedWeave);
+});

package/dist/src/renderer/shaders/tsl/patterns/grain-texture-pattern.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Returns a grain texture pattern value for a given UV coordinate.
+ */
+export declare const grainTexturePattern: (...args: unknown[]) => import("three/tsl").TSLNode;

package/{packages/shader-lab-react/src/renderer/shaders/tsl/patterns/grain-texture-pattern.ts → dist/src/renderer/shaders/tsl/patterns/grain-texture-pattern.js}

@@ -1,9 +1,8 @@
 // @ts-nocheck
-import { Fn, dot, fract, sin, vec2 } from "three/tsl"
-
+import { Fn, dot, fract, sin, vec2 } from "three/tsl";
 /**
  * Returns a grain texture pattern value for a given UV coordinate.
  */
 export const grainTexturePattern = Fn(([uv]) => {
-  return fract(sin(dot(uv, vec2(12.9898, 78.233))).mul(43758.5453123))
-})
+    return fract(sin(dot(uv, vec2(12.9898, 78.233))).mul(43758.5453123));
+});

package/dist/src/renderer/shaders/tsl/patterns/repeating-pattern.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Returns a repeating pattern of a sine function.
+ */
+export declare const repeatingPattern: (...args: unknown[]) => import("three/tsl").TSLNode;

package/{packages/shader-lab-react/src/renderer/shaders/tsl/patterns/repeating-pattern.ts → dist/src/renderer/shaders/tsl/patterns/repeating-pattern.js}

@@ -1,11 +1,9 @@
 // @ts-nocheck
-import { Fn, float, sin } from "three/tsl"
-
+import { Fn, float, sin } from "three/tsl";
 /**
  * Returns a repeating pattern of a sine function.
  */
 export const repeatingPattern = Fn(([pattern, repeat, time = float(0)]) => {
-  pattern.assign(sin(pattern.mul(repeat).add(time)).div(repeat))
-
-  return pattern
-})
+    pattern.assign(sin(pattern.mul(repeat).add(time)).div(repeat));
+    return pattern;
+});

package/dist/src/renderer/shaders/tsl/utils/atan2.d.ts

@@ -0,0 +1 @@
+export declare const atan2: (...args: unknown[]) => import("three/tsl").TSLNode;

package/dist/src/renderer/shaders/tsl/utils/atan2.js

@@ -0,0 +1,7 @@
+// @ts-nocheck
+import { atan, Fn, PI, select, sign } from "three/tsl";
+export const atan2 = Fn(([y, x]) => {
+    const base = atan(y.div(x));
+    const offset = sign(y).mul(PI);
+    return select(x.greaterThanEqual(0), base, base.add(offset));
+});

package/dist/src/renderer/shaders/tsl/utils/complex-conj.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Complex conjugate: conj(a + bi) = a - bi
+ */
+export declare const complexConj: (...args: unknown[]) => import("three/tsl").TSLNode;

package/{packages/shader-lab-react/src/renderer/shaders/tsl/utils/complex-conj.ts → dist/src/renderer/shaders/tsl/utils/complex-conj.js}

@@ -1,9 +1,8 @@
 // @ts-nocheck
-import { Fn, vec2 } from "three/tsl"
-
+import { Fn, vec2 } from "three/tsl";
 /**
  * Complex conjugate: conj(a + bi) = a - bi
  */
 export const complexConj = Fn(([z]) => {
-  return vec2(z.x, z.y.negate())
-})
+    return vec2(z.x, z.y.negate());
+});

package/dist/src/renderer/shaders/tsl/utils/complex-cos.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Complex cosine: cos(a + bi) = cos(a)cosh(b) - i sin(a)sinh(b)
+ */
+export declare const complexCos: (...args: unknown[]) => import("three/tsl").TSLNode;

package/dist/src/renderer/shaders/tsl/utils/complex-cos.js

@@ -0,0 +1,9 @@
+// @ts-nocheck
+import { cos, Fn, sin, vec2 } from "three/tsl";
+import { cosh, sinh } from "./hyperbolic.js";
+/**
+ * Complex cosine: cos(a + bi) = cos(a)cosh(b) - i sin(a)sinh(b)
+ */
+export const complexCos = Fn(([z]) => {
+    return vec2(cos(z.x).mul(cosh(z.y)), sin(z.x).mul(sinh(z.y)).negate());
+});

package/dist/src/renderer/shaders/tsl/utils/complex-div.d.ts

@@ -0,0 +1 @@
+export declare const complexDiv: (...args: unknown[]) => import("three/tsl").TSLNode;

package/dist/src/renderer/shaders/tsl/utils/complex-div.js

@@ -0,0 +1,6 @@
+// @ts-nocheck
+import { div, dot, Fn, vec2 } from "three/tsl";
+export const complexDiv = Fn(([a, b]) => {
+    const denominator = dot(b, b);
+    return vec2(div(a.x.mul(b.x).add(a.y.mul(b.y)), denominator), div(a.y.mul(b.x).sub(a.x.mul(b.y)), denominator));
+});

package/dist/src/renderer/shaders/tsl/utils/complex-log.d.ts

@@ -0,0 +1 @@
+export declare const complexLog: (...args: unknown[]) => import("three/tsl").TSLNode;

package/dist/src/renderer/shaders/tsl/utils/complex-log.js

@@ -0,0 +1,6 @@
+// @ts-nocheck
+import { Fn, length, log, vec2 } from "three/tsl";
+import { atan2 } from "./atan2.js";
+export const complexLog = Fn(([z]) => {
+    return vec2(log(length(z)), atan2(z.y, z.x));
+});

package/dist/src/renderer/shaders/tsl/utils/complex-mobius.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Möbius transformation: (z - 1) / (z + 1)
+ */
+export declare const complexMobius: (...args: unknown[]) => import("three/tsl").TSLNode;

package/dist/src/renderer/shaders/tsl/utils/complex-mobius.js

@@ -0,0 +1,10 @@
+// @ts-nocheck
+import { Fn, vec2 } from "three/tsl";
+import { complexDiv } from "./complex-div.js";
+/**
+ * Möbius transformation: (z - 1) / (z + 1)
+ */
+export const complexMobius = Fn(([z]) => {
+    const one = vec2(1.0, 0.0);
+    return complexDiv(z.sub(one), z.add(one));
+});

package/dist/src/renderer/shaders/tsl/utils/complex-mul.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Complex multiplication: (a + bi)(c + di) = (ac - bd) + (ad + bc)i
+ */
+export declare const complexMul: (...args: unknown[]) => import("three/tsl").TSLNode;

package/{packages/shader-lab-react/src/renderer/shaders/tsl/utils/complex-mul.ts → dist/src/renderer/shaders/tsl/utils/complex-mul.js}

@@ -1,9 +1,8 @@
 // @ts-nocheck
-import { Fn, vec2 } from "three/tsl"
-
+import { Fn, vec2 } from "three/tsl";
 /**
  * Complex multiplication: (a + bi)(c + di) = (ac - bd) + (ad + bc)i
  */
 export const complexMul = Fn(([a, b]) => {
-  return vec2(a.x.mul(b.x).sub(a.y.mul(b.y)), a.x.mul(b.y).add(a.y.mul(b.x)))
-})
+    return vec2(a.x.mul(b.x).sub(a.y.mul(b.y)), a.x.mul(b.y).add(a.y.mul(b.x)));
+});

package/dist/src/renderer/shaders/tsl/utils/complex-pow.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Complex power: z^n
+ * Let z = r(cos θ + i sin θ), then z^n = r^n (cos nθ + i sin nθ)
+ */
+export declare const complexPow: (...args: unknown[]) => import("three/tsl").TSLNode;

package/dist/src/renderer/shaders/tsl/utils/complex-pow.js

@@ -0,0 +1,14 @@
+// @ts-nocheck
+import { cos, Fn, length, pow, sin, vec2 } from "three/tsl";
+import { atan2 } from "./atan2.js";
+/**
+ * Complex power: z^n
+ * Let z = r(cos θ + i sin θ), then z^n = r^n (cos nθ + i sin nθ)
+ */
+export const complexPow = Fn(([z, n]) => {
+    const angle = atan2(z.y, z.x);
+    const r = length(z);
+    const rn = pow(r, n);
+    const nAngle = n.mul(angle);
+    return vec2(rn.mul(cos(nAngle)), rn.mul(sin(nAngle)));
+});

package/dist/src/renderer/shaders/tsl/utils/complex-sin.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Complex sine: sin(a + bi) = sin(a)cosh(b) + i cos(a)sinh(b)
+ */
+export declare const complexSin: (...args: unknown[]) => import("three/tsl").TSLNode;

package/dist/src/renderer/shaders/tsl/utils/complex-sin.js

@@ -0,0 +1,9 @@
+// @ts-nocheck
+import { cos, Fn, sin, vec2 } from "three/tsl";
+import { cosh, sinh } from "./hyperbolic.js";
+/**
+ * Complex sine: sin(a + bi) = sin(a)cosh(b) + i cos(a)sinh(b)
+ */
+export const complexSin = Fn(([z]) => {
+    return vec2(sin(z.x).mul(cosh(z.y)), cos(z.x).mul(sinh(z.y)));
+});

package/dist/src/renderer/shaders/tsl/utils/complex-sqrt.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Complex square root.
+ * sqrt(a + bi) = (sqrt((r+a)/2), sign(b) * sqrt((r-a)/2))
+ */
+export declare const complexSqrt: (...args: unknown[]) => import("three/tsl").TSLNode;