shaders 3.2.475 → 4.0.0

package/dist/core/gradients-C15o7_xy.js

@@ -1,159 +0,0 @@
-import { Bt as mixPreconvertedVariants, It as mixColorsLinear, Lt as mixColorsVariants, a as resolveScalar, ct as call, ft as floatE, jr as vec3f, jt as convertP3ToMixSpaceCPU, mt as vec4, o as uniformOf, s as Scalar, zt as mixPreconvertedLinear } from "./lower-DtoDQ7hV.js";
-import { a as colorWheelT, i as colorWheelSelect, n as colorWheelPhase, r as colorWheelRainbow, t as beamField, x as mpgFactors } from "./gradientPaints-Cx2bT20T.js";
-import { t as animatedTime } from "./porters-CQwDd2t4.js";
-import { y as local } from "./math-7PlusTFx.js";
-function arg(spec, params) {
-	if (typeof spec === "number") return floatE(spec);
-	if (spec instanceof Scalar || spec.kind !== "ctx") return resolveScalar(spec, params);
-	return params.ctx[spec.name];
-}
-function paintFrame(params) {
-	return {
-		uv: params.uvContext ?? params.ctx.uv,
-		viewport: params.effectiveViewportSize ?? params.ctx.viewportSize
-	};
-}
-function structural(ref, params) {
-	return params.propValues[ref.name];
-}
-function solidColor(color) {
-	return (params) => uniformOf(color, params);
-}
-function colorWheel(slots) {
-	return (params) => {
-		const { uv, viewport } = paintFrame(params);
-		const animTime = animatedTime(params);
-		const t = call(colorWheelT, "colorWheelT", [
-			uv,
-			viewport,
-			arg(slots.direction, params),
-			arg(slots.scale, params),
-			animTime
-		]);
-		if ((structural(slots.mode, params) ?? "rainbow") === "rainbow") return call(colorWheelRainbow, "colorWheelRainbow", [t]);
-		const phase = local(call(colorWheelPhase, "colorWheelPhase", [t]), "wheelPhase");
-		const si = phase.member("x");
-		const floorT3 = phase.member("y");
-		const variant = mixColorsVariants[structural(slots.space, params) ?? 0] ?? mixColorsLinear;
-		return call(colorWheelSelect, "colorWheelSelect", [
-			call(variant, "mixColors", [
-				uniformOf(slots.palette.a, params),
-				uniformOf(slots.palette.b, params),
-				si
-			]),
-			call(variant, "mixColors", [
-				uniformOf(slots.palette.b, params),
-				uniformOf(slots.palette.c, params),
-				si
-			]),
-			call(variant, "mixColors", [
-				uniformOf(slots.palette.c, params),
-				uniformOf(slots.palette.a, params),
-				si
-			]),
-			floorT3
-		]);
-	};
-}
-function pointCloudGradient(slots) {
-	if (slots.points.length !== 5) throw new Error("pointCloudGradient expects exactly 5 points");
-	return (params) => {
-		const { uv, viewport } = paintFrame(params);
-		const factors = local(call(mpgFactors, "mpgFactors", [
-			uv,
-			viewport,
-			...slots.points.map((pt) => uniformOf(pt.position, params)),
-			arg(slots.smoothness, params)
-		]), "mpgFactors");
-		const variant = mixColorsVariants[structural(slots.space, params) ?? 0] ?? mixColorsLinear;
-		let acc = uniformOf(slots.points[0].color, params);
-		const channels = [
-			"x",
-			"y",
-			"z",
-			"w"
-		];
-		for (let i = 1; i < 5; i++) acc = call(variant, "mixColors", [
-			acc,
-			uniformOf(slots.points[i].color, params),
-			factors.member(channels[i - 1])
-		]);
-		return acc;
-	};
-}
-const beamPreconvertedFields = {
-	convA: {
-		schema: vec3f,
-		initial: [
-			0,
-			0,
-			0
-		]
-	},
-	convB: {
-		schema: vec3f,
-		initial: [
-			0,
-			0,
-			0
-		]
-	}
-};
-function beam(slots) {
-	return (params) => {
-		const { uv, viewport } = paintFrame(params);
-		const mode = structural(slots.space, params) ?? 0;
-		const field = local(call(beamField, "beamField", [
-			uv,
-			viewport,
-			uniformOf(slots.from, params),
-			uniformOf(slots.to, params),
-			arg(slots.thickness.start, params),
-			arg(slots.thickness.end, params),
-			arg(slots.softness.start, params),
-			arg(slots.softness.end, params)
-		]), "beamField");
-		const colorT = field.member("x");
-		const alpha = field.member("y");
-		const inside = uniformOf(slots.colors.inside, params);
-		const outside = uniformOf(slots.colors.outside, params);
-		let beamColorRGB;
-		if (mode !== 0) {
-			let lastKey = "";
-			params.onBeforeRender(() => {
-				const a = params.getCpuValue(slots.colors.inside.name);
-				const b = params.getCpuValue(slots.colors.outside.name);
-				if (!a || !b) return;
-				const key = `${a.x},${a.y},${a.z}|${b.x},${b.y},${b.z}`;
-				if (key === lastKey) return;
-				lastKey = key;
-				const ca = convertP3ToMixSpaceCPU(a.x, a.y, a.z, mode);
-				const cb = convertP3ToMixSpaceCPU(b.x, b.y, b.z, mode);
-				params.setExtraField("convA", [
-					ca[0],
-					ca[1],
-					ca[2]
-				]);
-				params.setExtraField("convB", [
-					cb[0],
-					cb[1],
-					cb[2]
-				]);
-			});
-			beamColorRGB = call(mixPreconvertedVariants[mode] ?? mixPreconvertedLinear, "mixPreconvertedColors", [
-				params.uniforms.convA,
-				params.uniforms.convB,
-				inside.member("a"),
-				outside.member("a"),
-				colorT
-			]).member("rgb");
-		} else beamColorRGB = call(mixColorsLinear, "mixColors", [
-			inside,
-			outside,
-			colorT
-		]).member("rgb");
-		const avgAlpha = inside.member("a").add(outside.member("a")).mul(.5);
-		return vec4(beamColorRGB, avgAlpha.mul(alpha));
-	};
-}
-export { solidColor as a, pointCloudGradient as i, beamPreconvertedFields as n, colorWheel as r, beam as t };

package/dist/core/grids-Cv99xcJg.js

@@ -1,151 +0,0 @@
-function gridSim(build) {
-	return { compute: (params) => {
-		const { gpu, getCpuValue } = params;
-		const root = gpu?.root;
-		if (!root) return null;
-		const cfg = build(params, root);
-		if (!cfg) return null;
-		const num = (key, fallback) => {
-			const v = getCpuValue(key);
-			return typeof v === "number" ? v : fallback;
-		};
-		return {
-			outputs: cfg.outputs,
-			...cfg.bindInputs ? { bindInputs: cfg.bindInputs } : {},
-			getComputeNodes: (frameParams) => {
-				for (const s of cfg.stages) if (s.ready && !s.ready()) return null;
-				const fp = frameParams;
-				const dt = Math.min(fp.deltaTime ?? 0, cfg.clampDt);
-				if (cfg.zeroDt === "skip" && dt <= 0) return null;
-				const f = {
-					dt,
-					now: Date.now(),
-					num,
-					getCpuValue,
-					frameParams: fp
-				};
-				const nodes = [];
-				for (const s of cfg.stages) s.tick?.(f);
-				for (const s of cfg.stages) if (s.skip?.(f)) return null;
-				for (const s of cfg.stages) s.emit?.(f, nodes);
-				return nodes;
-			}
-		};
-	} };
-}
-const op = {
-	host(name, run) {
-		return { tick: run };
-	},
-	values(name, run) {
-		return { emit: (f) => run(f) };
-	},
-	settle(opts) {
-		let simSinceActive = 0;
-		return {
-			tick(f) {
-				if (opts.activeWhen(f)) simSinceActive = 0;
-			},
-			skip(f) {
-				const skip = simSinceActive > opts.settleMs(f);
-				if (!skip) simSinceActive += f.dt * 1e3;
-				return skip;
-			}
-		};
-	},
-	readyWhen(fn) {
-		return { ready: fn };
-	},
-	pass(step) {
-		return { emit: (_f, nodes) => nodes.push(step) };
-	},
-	cache(step) {
-		return { emit: (f, nodes) => nodes.push(step(f)) };
-	},
-	publish(step) {
-		return { emit: (f, nodes) => nodes.push(step(f)) };
-	},
-	seedOnce(opts) {
-		return { emit(f, nodes) {
-			if (!opts.staleWhen(f)) return;
-			opts.onSeed?.();
-			nodes.push(opts.pass);
-		} };
-	},
-	iterate(opts) {
-		return { emit(f, nodes) {
-			const n = opts.count(f);
-			for (let i = 0; i < n; i++) opts.step(i, nodes, f);
-		} };
-	},
-	sortPass(opts) {
-		let cur = "A";
-		let tick = 0;
-		return {
-			emit(f, nodes) {
-				const n = opts.passes(f);
-				for (let i = 0; i < n; i++) {
-					nodes.push(opts.pass(tick % 2, cur));
-					cur = cur === "A" ? "B" : "A";
-					tick++;
-				}
-			},
-			side: () => cur
-		};
-	}
-};
-function trackedViewport(params) {
-	let curW = Math.max(1, Math.round(params.dimensions.width));
-	let curH = Math.max(1, Math.round(params.dimensions.height));
-	params.onResize(({ width, height }) => {
-		curW = Math.max(1, Math.round(width));
-		curH = Math.max(1, Math.round(height));
-	});
-	return {
-		tracked: () => ({
-			width: curW,
-			height: curH
-		}),
-		safe: (fp) => ({
-			width: Math.max(1, fp.dimensions?.width ?? curW),
-			height: Math.max(1, fp.dimensions?.height ?? curH)
-		})
-	};
-}
-const hostStep = (name, run) => ({
-	name,
-	run
-});
-function hostGridProgram(opts) {
-	let lastTime = Date.now();
-	return (fp) => {
-		const { pointer } = fp;
-		const now = Date.now();
-		const dt = Math.min((now - lastTime) / 1e3, opts.clampDt);
-		lastTime = now;
-		const f = {
-			dt,
-			now,
-			pointer,
-			frameParams: fp
-		};
-		for (const s of opts.steps) if (s.run(f) === "skip") return;
-	};
-}
-function hostFieldTexture(params, opts) {
-	const texData = new Uint16Array(opts.size * opts.size * 4);
-	const tex = params.createDataTexture({
-		width: opts.size,
-		height: opts.size,
-		format: "rgba16float",
-		data: texData,
-		label: opts.label
-	});
-	params.onCleanup(() => tex.destroy());
-	return {
-		texData,
-		texture: params.registerMediaTexture(() => tex.texture),
-		upload: () => tex.write(texData)
-	};
-}
-export { op as a, hostStep as i, hostFieldTexture as n, trackedViewport as o, hostGridProgram as r, gridSim as t };

package/dist/core/lens-ChO_HVpe.js

@@ -1,352 +0,0 @@
-import { Cr as sin, Gn as typegpu_default, Or as vec2f, Ot as unpremultiplyAlpha, at as ZERO, br as radians, ct as call, dt as expr, gt as formatFloat, ht as Expr, i as resolveArg, mt as vec4, or as cos, qr as f32 } from "./lower-DtoDQ7hV.js";
-import { t as isMobileGpuViewport } from "./device-m0ud8-Fn.js";
-const LENS_MAX_SAMPLES = 50;
-const LENS_MAX_TAPS = isMobileGpuViewport() ? 24 : 50;
-function valueNoiseStmts(em, lines, inputExpr, outName) {
-	const n = `${em.p}_vn${em.noiseIdx.value++}`;
-	lines.push(`let ${n}_st = ${inputExpr};`);
-	lines.push(`let ${n}_fi = floor(${n}_st);`);
-	lines.push(`let ${n}_ff = fract(${n}_st);`);
-	for (const [k, off] of [
-		["a", "vec2f(0.0, 0.0)"],
-		["b", "vec2f(1.0, 0.0)"],
-		["c", "vec2f(0.0, 1.0)"],
-		["d", "vec2f(1.0, 1.0)"]
-	]) {
-		lines.push(`var ${n}_q${k} = fract((${n}_fi + ${off}) * vec2f(0.3183099, 0.3678794)) + vec2f(0.1);`);
-		lines.push(`${n}_q${k} = ${n}_q${k} + vec2f(dot(${n}_q${k}, ${n}_q${k} + vec2f(19.19)));`);
-		lines.push(`let ${n}_h${k} = fract(${n}_q${k}.x * ${n}_q${k}.y);`);
-	}
-	lines.push(`let ${n}_u = ${n}_ff * ${n}_ff * (vec2f(3.0) - 2.0 * ${n}_ff);`);
-	lines.push(`let ${outName} = mix(mix(${n}_ha, ${n}_hb, ${n}_u.x), mix(${n}_hc, ${n}_hd, ${n}_u.x), ${n}_u.y);`);
-}
-function lensGeometryStmts(em, uvExpr, aspectExpr) {
-	const { p, stmts, U } = em;
-	stmts.push(`let ${p}_uv = ${uvExpr};`);
-	stmts.push(`let ${p}_aspect = ${aspectExpr};`);
-	stmts.push(`let ${p}_invAspect = 1.0 / ${p}_aspect;`);
-	stmts.push(`let ${p}_inradius = 0.5 * min(${p}_aspect, 1.0);`);
-	stmts.push(`let ${p}_outradius = 0.5 * length(vec2f(${p}_aspect, 1.0));`);
-	stmts.push(`let ${p}_spread = ${U("spread")};`);
-	stmts.push(`let ${p}_reach = 0.7 * pow(${p}_spread, 1.3 + 2.7 * ${p}_spread);`);
-	stmts.push(`let ${p}_centerU = ${U("center")};`);
-	stmts.push(`let ${p}_c = vec2f(${p}_centerU.x, 1.0 - ${p}_centerU.y);`);
-	stmts.push(`let ${p}_fromCenter = vec2f((${p}_uv.x - ${p}_c.x) * ${p}_aspect, ${p}_uv.y - ${p}_c.y);`);
-	stmts.push(`let ${p}_radius = length(${p}_fromCenter);`);
-	stmts.push(`let ${p}_lensBulge = ${U("lensBulge")};`);
-	stmts.push(`let ${p}_lensCircle = ${U("lensCircle")};`);
-	stmts.push(`var ${p}_bulgeFade = 1.0;`);
-	stmts.push(`var ${p}_warped = ${p}_fromCenter;`);
-	stmts.push(`let ${p}_rSafe = max(${p}_radius, 1e-5);`);
-	stmts.push(`if (${p}_lensBulge != 0.0) {`);
-	stmts.push(`  let ${p}_rn = ${p}_rSafe / ${p}_inradius;`);
-	stmts.push(`  let ${p}_bulgeAmt = abs(${p}_lensBulge) * select(1.2, 1.4, ${p}_lensBulge > 0.0);`);
-	stmts.push(`  ${p}_bulgeFade = select(1.0, 1.0 - smoothstep(1.45, 1.53, ${p}_rn * ${p}_bulgeAmt), ${p}_lensBulge > 0.0);`);
-	stmts.push(`  let ${p}_mapPos = tan(min(${p}_rn * ${p}_bulgeAmt, 1.53)) / tan(${p}_bulgeAmt);`);
-	stmts.push(`  let ${p}_mapNeg = atan(${p}_rn * tan(${p}_bulgeAmt)) / ${p}_bulgeAmt;`);
-	stmts.push(`  let ${p}_bulgeScale = select(${p}_mapNeg, ${p}_mapPos, ${p}_lensBulge > 0.0) / ${p}_rn;`);
-	stmts.push(`  ${p}_warped = ${p}_warped * ${p}_bulgeScale;`);
-	stmts.push(`}`);
-	stmts.push(`if (${p}_lensCircle > 0.0) {`);
-	stmts.push(`  let ${p}_wr = length(${p}_warped);`);
-	stmts.push(`  let ${p}_dir = ${p}_warped / max(${p}_wr, 1e-5);`);
-	stmts.push(`  let ${p}_halfBox = vec2f(${p}_aspect, 1.0) * 0.5;`);
-	stmts.push(`  let ${p}_boxOff = vec2f((${p}_c.x - 0.5) * ${p}_aspect, ${p}_c.y - 0.5);`);
-	stmts.push(`  let ${p}_rBox = min((${p}_halfBox.x - sign(${p}_dir.x) * ${p}_boxOff.x) / max(abs(${p}_dir.x), 1e-4), (${p}_halfBox.y - sign(${p}_dir.y) * ${p}_boxOff.y) / max(abs(${p}_dir.y), 1e-4));`);
-	stmts.push(`  let ${p}_band = ${p}_inradius * mix(0.03, 0.2, 0.5 * (${p}_lensBulge + 1.0));`);
-	stmts.push(`  let ${p}_over = smoothstep(0.0, 1.0, (${p}_wr - (${p}_inradius - ${p}_band)) / ${p}_band);`);
-	stmts.push(`  let ${p}_g = ${p}_wr + (${p}_rBox - ${p}_inradius) * pow(${p}_over, 14.0);`);
-	stmts.push(`  ${p}_warped = ${p}_dir * mix(${p}_wr, ${p}_g, ${p}_lensCircle);`);
-	stmts.push(`}`);
-	stmts.push(`let ${p}_baseUV = vec2f(${p}_warped.x * ${p}_invAspect, ${p}_warped.y) + ${p}_c;`);
-	stmts.push(`let ${p}_baseDeriv = fwidth(${p}_baseUV);`);
-	stmts.push(`let ${p}_edgeAA = clamp(2.0 * max(${p}_baseDeriv.x, ${p}_baseDeriv.y), 0.001, 0.02);`);
-	stmts.push(`let ${p}_frameInvAA = 1.0 / clamp(${p}_baseDeriv, vec2f(1e-5), vec2f(0.02));`);
-	stmts.push(`let ${p}_grainUV = (${p}_uv - vec2f(0.5)) * (0.8 / vec2f(length(dpdx(${p}_uv)), length(dpdy(${p}_uv)))) + vec2f(0.5);`);
-}
-function spreadAxisStmts(em) {
-	const { p, stmts, U } = em;
-	stmts.push(`let ${p}_angleRad = radians(${U("angle")});`);
-	stmts.push(`let ${p}_uniformDir = vec2f(cos(${p}_angleRad), sin(${p}_angleRad));`);
-	stmts.push(`let ${p}_invInradius = 1.0 / ${p}_inradius;`);
-	stmts.push(`let ${p}_maxLen = (${p}_outradius + ${p}_reach) * ${p}_invInradius;`);
-	stmts.push(`let ${p}_radialLen = ${p}_radius * ${p}_invInradius;`);
-	stmts.push(`let ${p}_radialDir = ${p}_fromCenter * ${p}_invInradius * min(1.0, ${p}_maxLen / max(${p}_radialLen, 1e-6));`);
-	stmts.push(`let ${p}_bandProximity = smoothstep(${p}_inradius * 0.8, ${p}_inradius, ${p}_radius);`);
-	stmts.push(`let ${p}_circleMaxing = ${p}_bandProximity * ${p}_lensCircle * ${p}_lensCircle * ${p}_lensCircle;`);
-	stmts.push(`let ${p}_spreadDir = mix(mix(${p}_uniformDir, ${p}_radialDir, ${U("perspective")}), ${p}_radialDir, ${p}_circleMaxing);`);
-	stmts.push(`let ${p}_warpedAbs = abs(${p}_baseUV - vec2f(0.5));`);
-	stmts.push(`let ${p}_focusCenter = ${U("focusCenter")};`);
-	stmts.push(`let ${p}_inner = mix(1.0, smoothstep(0.0, mix(${p}_inradius, ${p}_outradius, ${p}_focusCenter), ${p}_radius), ${p}_focusCenter);`);
-	stmts.push(`let ${p}_boxDist = max(${p}_warpedAbs.x, ${p}_warpedAbs.y) * 2.0;`);
-	stmts.push(`let ${p}_outer = mix(1.0, 1.0 - min(${p}_boxDist, 1.0), ${U("focusEdges")});`);
-	stmts.push(`var ${p}_strength = ${p}_inner * ${p}_outer * mix(1.0, mix(0.15, 0.03, max(-${p}_lensBulge, 0.0)), ${p}_circleMaxing);`);
-	stmts.push(`let ${p}_outside = max(${p}_warpedAbs - vec2f(0.5), vec2f(0.0));`);
-	stmts.push(`let ${p}_margin = max(${p}_reach * length(${p}_spreadDir) * (1.0 - ${p}_lensCircle), ${p}_edgeAA);`);
-	stmts.push(`${p}_strength = ${p}_strength * (1.0 - smoothstep(0.0, ${p}_margin, length(${p}_outside)));`);
-	stmts.push(`var ${p}_axis = ${p}_spreadDir * (${p}_reach * ${p}_strength);`);
-	stmts.push(`let ${p}_noise = ${U("noise")};`);
-	stmts.push(`if (${p}_noise > 0.0) {`);
-	{
-		const lines = [];
-		valueNoiseStmts(em, lines, `${p}_fromCenter * (${U("noiseFrequency")} * 18.0) + vec2f(${U("noiseOffset")} * 30.0)`, `${p}_turnNoise`);
-		for (const l of lines) stmts.push(`  ${l}`);
-	}
-	stmts.push(`  let ${p}_turn = (${p}_turnNoise - 0.5) * 2.0 * ${p}_noise;`);
-	stmts.push(`  let ${p}_tc = cos(${p}_turn);`);
-	stmts.push(`  let ${p}_ts = sin(${p}_turn);`);
-	stmts.push(`  ${p}_axis = vec2f(${p}_tc * ${p}_axis.x + ${p}_ts * ${p}_axis.y, -${p}_ts * ${p}_axis.x + ${p}_tc * ${p}_axis.y);`);
-	stmts.push(`}`);
-	stmts.push(`${p}_axis = vec2f(${p}_axis.x * ${p}_invAspect, ${p}_axis.y);`);
-	stmts.push(`let ${p}_grainMixer = ${U("grainMixer")};`);
-	stmts.push(`if (${p}_grainMixer > 0.0) {`);
-	{
-		const lines = [];
-		valueNoiseStmts(em, lines, `${p}_grainUV`, `${p}_grainSeed`);
-		for (const l of lines) stmts.push(`  ${l}`);
-	}
-	stmts.push(`  let ${p}_jit = fract(${p}_grainSeed * vec2f(157.31, 113.57)) * 2.0 - vec2f(1.0);`);
-	stmts.push(`  ${p}_axis = ${p}_axis + ${p}_jit * (0.3 * ${p}_grainMixer * length(${p}_axis));`);
-	stmts.push(`}`);
-}
-function frameAAMaskStmts(em, body) {
-	const { p } = em;
-	body.push(`let ${p}_lo = clamp(${p}_sampleUV * ${p}_frameInvAA + vec2f(0.5), vec2f(0.0), vec2f(1.0));`);
-	body.push(`let ${p}_hi = clamp((vec2f(1.0) - ${p}_sampleUV) * ${p}_frameInvAA + vec2f(0.5), vec2f(0.0), vec2f(1.0));`);
-	body.push(`let ${p}_frame = ${p}_lo.x * ${p}_hi.x * ${p}_lo.y * ${p}_hi.y;`);
-}
-function spectralFanStmts(em, texKey) {
-	const { p, stmts, U, L } = em;
-	const PI = Math.PI;
-	stmts.push(`let ${p}_countF = clamp(floor(${U("count")}), 2.0, ${L(LENS_MAX_TAPS)});`);
-	stmts.push(`let ${p}_hueBase = ${U("dispersionColor")} + 0.5;`);
-	stmts.push(`let ${p}_bias = ${U("bias")};`);
-	stmts.push(`let ${p}_biasPower = 1.0 + 2.0 * abs(${p}_bias);`);
-	stmts.push(`let ${p}_biasNeg = ${p}_bias < 0.0;`);
-	stmts.push(`let ${p}_dispShift = ${U("dispersionShift")};`);
-	stmts.push(`let ${p}_icMask = 1.0 - smoothstep(0.5 * ${p}_inradius, 1.1 * ${p}_inradius, ${p}_radius);`);
-	stmts.push(`let ${p}_dispAmt = ${U("dispersion")} * mix(clamp(1.0 + ${p}_dispShift, 0.0, 1.0), clamp(1.0 - ${p}_dispShift, 0.0, 1.0), ${p}_icMask);`);
-	stmts.push(`let ${p}_dispPower = pow(${p}_dispAmt, 0.8);`);
-	stmts.push(`let ${p}_warpedRadius = length(${p}_warped);`);
-	stmts.push(`let ${p}_swirlAngle = ${U("swirl")} * ${L(.4 * PI)} * ${p}_strength * ${p}_spread * min(1.0, ${p}_inradius / max(${p}_warpedRadius, 1e-4));`);
-	stmts.push(`let ${p}_texel = max((${p}_baseDeriv.x + ${p}_baseDeriv.y) * 0.5, 1e-6);`);
-	stmts.push(`let ${p}_fanPx = (2.0 * length(${p}_axis) + abs(${p}_swirlAngle) * ${p}_warpedRadius) / ${p}_texel;`);
-	stmts.push(`let ${p}_tapsF = clamp(ceil(${p}_fanPx * ${p}_biasPower) + 1.0, 2.0, ${p}_countF);`);
-	stmts.push(`let ${p}_invCount = 1.0 / ${p}_tapsF;`);
-	stmts.push(`let ${p}_invSpan = 1.0 / max(${p}_tapsF - 1.0, 1.0);`);
-	stmts.push(`var ${p}_colorSum = vec3f(0.0);`);
-	stmts.push(`var ${p}_weightSum = vec3f(0.0);`);
-	stmts.push(`var ${p}_coverSum = 0.0;`);
-	const body = [];
-	body.push(`let ${p}_layer = f32(${p}_i);`);
-	body.push(`let ${p}_hue = ${p}_hueBase + ${p}_layer * ${p}_invCount;`);
-	body.push(`let ${p}_t0 = ${p}_layer * ${p}_invSpan;`);
-	body.push(`let ${p}_curved = pow(select(${p}_t0, 1.0 - ${p}_t0, ${p}_biasNeg), ${p}_biasPower);`);
-	body.push(`let ${p}_spreadT = select(${p}_curved, 1.0 - ${p}_curved, ${p}_biasNeg);`);
-	body.push(`let ${p}_fanPos = 1.0 - 2.0 * ${p}_spreadT;`);
-	body.push(`let ${p}_tap0 = ${p}_baseUV + ${p}_axis * ${p}_fanPos - ${p}_c;`);
-	body.push(`let ${p}_sa = ${p}_swirlAngle * ${p}_fanPos;`);
-	body.push(`let ${p}_sc = cos(${p}_sa);`);
-	body.push(`let ${p}_ss = sin(${p}_sa);`);
-	body.push(`let ${p}_tx = ${p}_tap0.x * ${p}_aspect;`);
-	body.push(`let ${p}_sampleUV = vec2f((${p}_sc * ${p}_tx - ${p}_ss * ${p}_tap0.y) * ${p}_invAspect, ${p}_ss * ${p}_tx + ${p}_sc * ${p}_tap0.y) + ${p}_c;`);
-	frameAAMaskStmts(em, body);
-	body.push(`let ${p}_tapC = textureSampleLevel(tex.$.${texKey}, samp.$.linearClamp, ${p}_sampleUV, 0.0);`);
-	body.push(`let ${p}_cover = ${p}_tapC.a * ${p}_frame;`);
-	body.push(`let ${p}_overWhite = vec3f(1.0 - ${p}_cover) + ${p}_tapC.rgb * ${p}_frame;`);
-	body.push(`let ${p}_hraw = ${p}_hue * 6.0 + vec3f(0.0, 4.0, 2.0);`);
-	body.push(`let ${p}_hmod = ${p}_hraw - 6.0 * floor(${p}_hraw / 6.0);`);
-	body.push(`let ${p}_hclamped = clamp(abs(${p}_hmod - vec3f(3.0)) - vec3f(1.0), vec3f(0.0), vec3f(1.0));`);
-	body.push(`let ${p}_hrgb = ${p}_hclamped * ${p}_hclamped * (vec3f(3.0) - 2.0 * ${p}_hclamped);`);
-	body.push(`let ${p}_weight = vec3f(1.0) - ${p}_dispPower * ${p}_hrgb;`);
-	body.push(`${p}_colorSum = ${p}_colorSum + ${p}_overWhite * ${p}_weight;`);
-	body.push(`${p}_weightSum = ${p}_weightSum + ${p}_weight;`);
-	body.push(`${p}_coverSum = ${p}_coverSum + ${p}_cover;`);
-	stmts.push(`for (var ${p}_i = 0u; ${p}_i < u32(${p}_tapsF); ${p}_i++) {`);
-	for (const b of body) stmts.push(`  ${b}`);
-	stmts.push(`}`);
-	stmts.push(`let ${p}_color = ${p}_colorSum / max(${p}_weightSum, vec3f(1e-4));`);
-	stmts.push(`let ${p}_coverAvg = ${p}_coverSum * ${p}_invCount;`);
-	stmts.push(`let ${p}_ground = min(${p}_color.r, min(${p}_color.g, ${p}_color.b));`);
-	stmts.push(`let ${p}_alpha = max(${p}_coverAvg, 1.0 - ${p}_ground);`);
-	stmts.push(`let ${p}_premul = max(${p}_color - vec3f(1.0 - ${p}_alpha), vec3f(0.0));`);
-	stmts.push(`var ${p}_out = vec4f(${p}_premul, ${p}_alpha) * ${p}_bulgeFade;`);
-}
-function grainOverlayStmts(em) {
-	const { p, stmts, L } = em;
-	stmts.push(`let ${p}_grainOverlay = ${em.U("grainOverlay")};`);
-	stmts.push(`if (${p}_grainOverlay > 0.0) {`);
-	{
-		const lines = [];
-		const c1 = L(Math.cos(1)), s1 = L(Math.sin(1));
-		const c2 = L(Math.cos(2)), s2 = L(Math.sin(2));
-		lines.push(`let ${p}_gr1 = vec2f(${c1} * ${p}_grainUV.x - ${s1} * ${p}_grainUV.y, ${s1} * ${p}_grainUV.x + ${c1} * ${p}_grainUV.y) + vec2f(3.0);`);
-		lines.push(`let ${p}_gr2 = vec2f(${c2} * ${p}_grainUV.x - ${s2} * ${p}_grainUV.y, ${s2} * ${p}_grainUV.x + ${c2} * ${p}_grainUV.y) + vec2f(-1.0);`);
-		valueNoiseStmts(em, lines, `${p}_gr1`, `${p}_gn1`);
-		valueNoiseStmts(em, lines, `${p}_gr2`, `${p}_gn2`);
-		lines.push(`let ${p}_grain = pow(mix(${p}_gn1, ${p}_gn2, 0.5), 1.3);`);
-		lines.push(`let ${p}_grainV = ${p}_grain * 2.0 - 1.0;`);
-		lines.push(`let ${p}_grainStrength = pow(${p}_grainOverlay * abs(${p}_grainV), 0.8) * ${p}_out.a;`);
-		lines.push(`${p}_out = vec4f(mix(${p}_out.rgb, vec3f(step(0.0, ${p}_grainV)) * ${p}_out.a, 0.35 * ${p}_grainStrength), ${p}_out.a);`);
-		for (const l of lines) stmts.push(`  ${l}`);
-	}
-	stmts.push(`}`);
-}
-const chromaticOffsetUV = typegpu_default.fn([
-	vec2f,
-	f32,
-	f32,
-	f32,
-	f32
-], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, angle, strength, aspect, channelOffset) => {
-	"use gpu";
-	const angleRad = radians(angle);
-	const direction = vec2f(__tsover_div(cos(angleRad), aspect), sin(angleRad));
-	const scaledStrength = __tsover_mul(strength, .1);
-	const offsetBase = direction.mul(scaledStrength);
-	return uv.add(offsetBase.mul(channelOffset));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "uv"
-			},
-			{
-				"type": "i",
-				"name": "angle"
-			},
-			{
-				"type": "i",
-				"name": "strength"
-			},
-			{
-				"type": "i",
-				"name": "aspect"
-			},
-			{
-				"type": "i",
-				"name": "channelOffset"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"angleRad",
-				[
-					6,
-					"std.radians",
-					["angle"]
-				]
-			],
-			[
-				13,
-				"direction",
-				[
-					6,
-					"d.vec2f",
-					[[
-						1,
-						[
-							6,
-							"std.cos",
-							["angleRad"]
-						],
-						"/",
-						"aspect"
-					], [
-						6,
-						"std.sin",
-						["angleRad"]
-					]]
-				]
-			],
-			[
-				13,
-				"scaledStrength",
-				[
-					1,
-					"strength",
-					"*",
-					[5, "0.1"]
-				]
-			],
-			[
-				13,
-				"offsetBase",
-				[
-					6,
-					[
-						7,
-						"direction",
-						"mul"
-					],
-					["scaledStrength"]
-				]
-			],
-			[10, [
-				6,
-				[
-					7,
-					"uv",
-					"add"
-				],
-				[[
-					6,
-					[
-						7,
-						"offsetBase",
-						"mul"
-					],
-					["channelOffset"]
-				]]
-			]]
-		]]
-	},
-	externals: {
-		"std.radians": () => radians,
-		"d.vec2f": () => vec2f,
-		"std.cos": () => cos,
-		"std.sin": () => sin
-	}
-}) && $.f)({}));
-function chromaticFan(opts) {
-	return (params) => {
-		const tapUV = (offset) => call(chromaticOffsetUV, "chromaticOffsetUV", [
-			params.ctx.uv,
-			resolveArg(opts.angle, params),
-			resolveArg(opts.strength, params),
-			params.ctx.aspect,
-			resolveArg(offset, params)
-		]);
-		const redSample = params.texture.sample(tapUV(opts.red));
-		const greenSample = params.texture.sample(tapUV(opts.green));
-		const blueSample = params.texture.sample(tapUV(opts.blue));
-		return vec4(redSample.member("r"), greenSample.member("g"), blueSample.member("b"), greenSample.member("a"));
-	};
-}
-function spectralLens(slots) {
-	return (params) => {
-		const { uniforms, childNode, ctx, convertToTexture } = params;
-		if (!childNode) return ZERO;
-		const texKey = convertToTexture(childNode).key;
-		return new Expr((ec) => {
-			const em = {
-				p: ec.freshLocal("lens"),
-				stmts: [],
-				U: (name) => uniforms[slots[name].name]._emit(ec),
-				L: (n) => formatFloat(n),
-				noiseIdx: { value: 0 }
-			};
-			lensGeometryStmts(em, ctx.uv._emit(ec), ctx.aspect._emit(ec));
-			spreadAxisStmts(em);
-			spectralFanStmts(em, texKey);
-			grainOverlayStmts(em);
-			for (const s of em.stmts) ec.statement(s);
-			return call(unpremultiplyAlpha, "unpremultiplyAlpha", [expr(`${em.p}_out`)])._emit(ec);
-		});
-	};
-}
-export { spectralLens as n, LENS_MAX_SAMPLES as r, chromaticFan as t };