shaders 3.1.463 → 3.2.464

package/dist/core/lens-ChZyqXRf.js

@@ -0,0 +1,352 @@
+import { En as cos, Jn as vec2f, Tt as unpremultiplyAlpha, Un as sin, at as call, ct as expr, dt as vec4, ft as Expr, hr as f32, mn as typegpu_default, nt as ZERO, pt as formatFloat, r as resolveArg, zn as radians } from "./lower-z2vuXP8M.js";
+import { t as isMobileGpuViewport } from "./device-DLKcFOd2.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 };

package/dist/core/light-CJ3dY0iH.js

@@ -0,0 +1,238 @@
+import { a as uniformOf, at as call, dt as vec4, i as resolveScalar, it as asLocal, lt as floatE, o as Scalar, ut as mixExpr } from "./lower-z2vuXP8M.js";
+import { c as radialFeatherMask, d as screenGlowComposite, g as vignetteMask$1, i as chromaticHeatTaps, p as softRayLobes$1, r as beamLocalFrame, s as radialBurstFrame } from "./lightfields-BjzpZvFy.js";
+import { t as animatedTime } from "./porters-B1UjrM1y.js";
+import { _ as heatDither, b as leakStreaks, d as godraysRayStack, s as coverageOverComposite, u as godraysFrame, v as leakBloom, y as leakDrift } from "./gradientPaints-B6-PoDoK.js";
+import { a as flareFrame$1, c as flareStarburst$1, i as flareCore$1, l as flareStreak$1, o as flareGlare$1, r as flareComposite$1, s as flareHalo$1, u as lensFlareGhost } from "./shapePaints-G_Ap8xID.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 radialFrame(center) {
+	return (params) => {
+		const { uv, viewport } = paintFrame(params);
+		return call(radialBurstFrame, "radialFrame", [
+			uv,
+			viewport,
+			uniformOf(center, params)
+		]);
+	};
+}
+function seamlessRadialFrame(center) {
+	return (params) => {
+		const { uv, viewport } = paintFrame(params);
+		return call(godraysFrame, "godraysFrame", [
+			uv,
+			viewport,
+			uniformOf(center, params)
+		]);
+	};
+}
+function beamFrame(anchor) {
+	return (params) => call(beamLocalFrame, "beamFrame", [
+		params.ctx.uv,
+		params.ctx.aspect,
+		uniformOf(anchor, params)
+	]);
+}
+function withFrame(frame, part, hint) {
+	return (params) => {
+		return part(hint ? asLocal(frame(params), hint) : frame(params), params);
+	};
+}
+function modulate(first, ...rest) {
+	return (frame, params) => rest.reduce((acc, part) => acc.mul(part(frame, params)), first(frame, params));
+}
+function softRayLobes(slots) {
+	return (frame, params) => call(softRayLobes$1, "softRayLobes", [
+		frame.member("y"),
+		arg(slots.count, params),
+		animatedTime(params).mul(slots.spin),
+		arg(slots.softness, params)
+	]);
+}
+function featherMask(slots) {
+	return (frame, params) => call(radialFeatherMask, "featherMask", [
+		frame.member("x"),
+		arg(slots.radius, params),
+		arg(slots.feather, params)
+	]);
+}
+function noiseRays(slots) {
+	return (frame, params) => call(godraysRayStack, "godraysRayStack", [
+		frame,
+		animatedTime(params),
+		arg(slots.density, params),
+		arg(slots.intensity, params),
+		arg(slots.spotty, params)
+	]);
+}
+function slowDrift(slots) {
+	return (clock, params) => call(leakDrift, "leakDrift", [
+		clock,
+		arg(slots.seed, params),
+		arg(slots.flicker, params)
+	]);
+}
+function beamBloom(slots) {
+	return (frame, drift, params) => call(leakBloom, "leakBloom", [
+		frame.member("x"),
+		frame.member("y"),
+		arg(slots.spread, params),
+		drift
+	]);
+}
+function beamStreaks(slots) {
+	return (frame, drift, params) => call(leakStreaks, "leakStreaks", [
+		frame.member("x"),
+		frame.member("y"),
+		arg(slots.spread, params),
+		arg(slots.strength, params),
+		drift
+	]);
+}
+function dithered(heat, uv, clock) {
+	return call(heatDither, "heatDither", [
+		heat,
+		uv,
+		clock
+	]);
+}
+function flareFrame(slots) {
+	return (params) => {
+		const { uv, viewport } = paintFrame(params);
+		return call(flareFrame$1, "flareFrame", [
+			uv,
+			viewport,
+			animatedTime(params),
+			uniformOf(slots.position, params),
+			arg(slots.intensity, params),
+			arg(slots.edgeFade, params)
+		]);
+	};
+}
+function lensGhost(slots) {
+	return (flare, disc, tint, params) => {
+		const { uv } = paintFrame(params);
+		return call(lensFlareGhost, "lensFlareGhost", [
+			uv,
+			flare.member("aspect"),
+			flare.member("lightPos"),
+			flare.member("flareAxis"),
+			animatedTime(params),
+			arg(slots.spread, params),
+			arg(slots.chroma, params),
+			arg(slots.intensity, params),
+			vec4(...disc),
+			vec4(...tint)
+		]);
+	};
+}
+function flareHalo(slots) {
+	return (flare, params) => {
+		const { uv } = paintFrame(params);
+		return call(flareHalo$1, "flareHalo", [
+			uv,
+			flare.member("aspect"),
+			flare.member("lightPos"),
+			animatedTime(params),
+			arg(slots.intensity, params),
+			arg(slots.radius, params),
+			arg(slots.chroma, params),
+			arg(slots.softness, params)
+		]);
+	};
+}
+function flareStarburst(slots) {
+	return (flare, params) => call(flareStarburst$1, "flareStarburst", [
+		flare.member("lightAngle"),
+		flare.member("flareAxis"),
+		flare.member("aspect"),
+		animatedTime(params),
+		flare.member("lightDist"),
+		arg(slots.points, params),
+		arg(slots.intensity, params)
+	]);
+}
+function flareStreak(slots) {
+	return (flare, params) => {
+		const { uv } = paintFrame(params);
+		return call(flareStreak$1, "flareStreak", [
+			uv,
+			flare.member("lightPos"),
+			arg(slots.length, params),
+			arg(slots.intensity, params)
+		]);
+	};
+}
+function flareGlare(slots) {
+	return (flare, params) => call(flareGlare$1, "flareGlare", [
+		flare.member("lightDist"),
+		arg(slots.size, params),
+		arg(slots.intensity, params)
+	]);
+}
+function flareCore(slots) {
+	return (flare, params) => call(flareCore$1, "flareCore", [flare.member("lightDist"), arg(slots.intensity, params)]);
+}
+function flareComposite(total, flare) {
+	return call(flareComposite$1, "flareComposite", [total, flare.member("masterFade")]);
+}
+function vignetteMask(slots) {
+	return (params) => {
+		const { uv, viewport } = paintFrame(params);
+		let strength = arg(slots.strength, params);
+		if (slots.scale !== void 0) strength = strength.mul(slots.scale);
+		return call(vignetteMask$1, "vignetteMask", [
+			uv,
+			viewport,
+			strength
+		]);
+	};
+}
+function additive(first, ...rest) {
+	return rest.reduce((acc, part) => acc.add(part), first);
+}
+function heatRamp(colors) {
+	return {
+		kind: "heatRamp",
+		taps: (heat, params) => call(chromaticHeatTaps, "chromaticHeatTaps", [
+			heat,
+			uniformOf(colors.hot, params).member("rgb"),
+			uniformOf(colors.mid, params).member("rgb"),
+			uniformOf(colors.fringe, params).member("rgb")
+		])
+	};
+}
+function coverageMix(slots) {
+	return (params) => {
+		const alpha = slots.hint ? asLocal(slots.coverage(params), slots.hint) : slots.coverage(params);
+		const col = uniformOf(slots.color, params);
+		const bg = uniformOf(slots.background, params);
+		return vec4(mixExpr(bg.member("rgb"), col.member("rgb"), alpha), mixExpr(bg.member("a"), col.member("a"), alpha));
+	};
+}
+function coverageOver(slots) {
+	return (params) => call(coverageOverComposite, "coverageOver", [
+		uniformOf(slots.color, params),
+		uniformOf(slots.background, params),
+		slots.coverage(params)
+	]);
+}
+function screenGlow(glow) {
+	return {
+		kind: "pointwise",
+		body: {
+			fn: screenGlowComposite,
+			hint: "screenGlowComposite"
+		},
+		args: (params) => [glow(params)]
+	};
+}
+export { slowDrift as C, withFrame as E, seamlessRadialFrame as S, vignetteMask as T, lensGhost as _, coverageMix as a, radialFrame as b, featherMask as c, flareFrame as d, flareGlare as f, heatRamp as g, flareStreak as h, beamStreaks as i, flareComposite as l, flareStarburst as m, beamBloom as n, coverageOver as o, flareHalo as p, beamFrame as r, dithered as s, additive as t, flareCore as u, modulate as v, softRayLobes as w, screenGlow as x, noiseRays as y };