shaders 3.0.452 → 3.1.454

package/dist/core/{blur-BAqURXkj.js → blur-CZuIxzX6.js}

@@ -1,5 +1,31 @@
-import { $t as struct, Dt as fract, Jt as textureStorage2d, Kt as arrayOf, Lt as round, Wt as data_exports, at as textureLoad, bt as clamp, cn as f32, in as vec2u, ln as i32, qt as texture2d, rt as std_exports, sn as vec4f, st as textureStore, tt as src_default, un as u32 } from "./edges-Dm0I-Ud7.js";
-import { n as createGuardedCompute } from "./compute-DYJOCqJI.js";
+import { At as max, Gt as data_exports, I as unpremultiplyAlpha, Jt as texture2d, Mt as mix, Ot as fract, Pt as pow, Rt as round, Yt as textureStorage2d, an as vec2u, at as std_exports, cn as vec4f, dn as i32, en as struct, f as ZERO, fn as u32, h as call, lt as textureStore, on as vec3f, pn as __export, qt as arrayOf, rn as vec2f, rt as src_default, st as textureLoad, un as f32, wt as dot, xt as clamp } from "./edges-CD7gCAto.js";
+import { M as createGuardedCompute } from "./device-B0ZwBfOg.js";
+var blur_exports = /* @__PURE__ */ __export({
+	BLUR_MAP_FORMAT: () => BLUR_MAP_FORMAT,
+	DEFAULT_COMPUTE_HEIGHT: () => 640,
+	DEFAULT_COMPUTE_WIDTH: () => DEFAULT_COMPUTE_WIDTH,
+	MAP_SOURCE_DIM_FIELDS: () => MAP_SOURCE_DIM_FIELDS,
+	REMAP_WINDOW_FIELDS: () => REMAP_WINDOW_FIELDS,
+	applyRemapWindow: () => applyRemapWindow,
+	aspectAwareComputeRes: () => aspectAwareComputeRes,
+	bloomExtractSoftKnee: () => bloomExtractSoftKnee,
+	buildBloomExtractGraph: () => buildBloomExtractGraph,
+	buildBloomExtractMapGraph: () => buildBloomExtractMapGraph,
+	buildFixedBlurGraph: () => buildFixedBlurGraph,
+	buildFixedWeights: () => buildFixedWeights,
+	buildTruncatedWeights: () => buildTruncatedWeights,
+	buildVariableBlurGraph: () => buildVariableBlurGraph,
+	composeBlurredOverSharp: () => composeBlurredOverSharp,
+	createGaussianBlurCompute: () => createGaussianBlurCompute,
+	createVariableGaussianBlurCompute: () => createVariableGaussianBlurCompute,
+	gaussianTapWeights: () => gaussianTapWeights,
+	mapSourceScalar: () => mapSourceScalar,
+	remapWindowValues: () => remapWindowValues,
+	unrolledTapGather: () => unrolledTapGather,
+	withBloomCompute: () => withBloomCompute,
+	withFixedBlurCompute: () => withFixedBlurCompute,
+	withVariableBlurCompute: () => withVariableBlurCompute
+});
 var DEFAULT_HALF_KERNEL = 24;
 const DEFAULT_COMPUTE_WIDTH = 1024;
 const DEFAULT_COMPUTE_HEIGHT = 640;
@@ -2244,4 +2270,1757 @@ function createVariableGaussianBlurCompute(root, inputTexture, inputWidth, input
 		}
 	};
 }
-export { createVariableGaussianBlurCompute as a, createGaussianBlurCompute as i, DEFAULT_COMPUTE_HEIGHT as n, DEFAULT_COMPUTE_WIDTH as r, BLUR_MAP_FORMAT as t };
+function gaussianTapWeights(count, sigma) {
+	const variance = Number((sigma * sigma).toPrecision(15));
+	const last = count - 1;
+	const raw = Array.from({ length: count }, (_, i) => {
+		const t = (i / last - .5) * 2;
+		return Math.exp(-.5 * t * t / variance);
+	});
+	const sum = raw.reduce((a, b) => a + b);
+	return raw.map((w) => w / sum);
+}
+function unrolledTapGather(config) {
+	const { weights, tapCoord, sample, component } = config;
+	let total;
+	for (let i = 0; i < weights.length; i++) {
+		const raw = sample(tapCoord(i));
+		const weighted = (component ? raw.member(component) : raw).mul(weights[i]);
+		total = total ? total.add(weighted) : weighted;
+	}
+	return total;
+}
+const MAP_SOURCE_DIM_FIELDS = {
+	inputWidth: f32,
+	inputHeight: f32
+};
+const REMAP_WINDOW_FIELDS = {
+	inputMin: f32,
+	inputMax: f32,
+	outputMin: f32,
+	outputMax: f32,
+	curve: f32
+};
+var mapSourceScalarCache = /* @__PURE__ */ new Map();
+function mapSourceScalar(channel) {
+	const cached = mapSourceScalarCache.get(channel);
+	if (cached) return cached;
+	const fn = src_default.fn([vec4f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sample) => {
+		"use gpu";
+		return channel === "alpha" ? sample.w : channel === "alphaInverted" ? __tsover_sub(1, sample.w) : channel === "luminanceInverted" ? __tsover_sub(1, dot(sample.xyz, vec3f(.2126, .7152, .0722))) : dot(sample.xyz, vec3f(.2126, .7152, .0722));
+	}), {
+		v: 1,
+		name: void 0,
+		ast: {
+			"params": [{
+				"type": "i",
+				"name": "sample"
+			}],
+			"body": [0, [[10, [
+				105,
+				[
+					1,
+					"channel",
+					"===",
+					[103, "alpha"]
+				],
+				[
+					7,
+					"sample",
+					"w"
+				],
+				[
+					105,
+					[
+						1,
+						"channel",
+						"===",
+						[103, "alphaInverted"]
+					],
+					[
+						1,
+						[5, "1"],
+						"-",
+						[
+							7,
+							"sample",
+							"w"
+						]
+					],
+					[
+						105,
+						[
+							1,
+							"channel",
+							"===",
+							[103, "luminanceInverted"]
+						],
+						[
+							1,
+							[5, "1"],
+							"-",
+							[
+								6,
+								[
+									7,
+									"std",
+									"dot"
+								],
+								[[
+									7,
+									"sample",
+									"xyz"
+								], [
+									6,
+									[
+										7,
+										"d",
+										"vec3f"
+									],
+									[
+										[5, "0.2126"],
+										[5, "0.7152"],
+										[5, "0.0722"]
+									]
+								]]
+							]
+						],
+						[
+							6,
+							[
+								7,
+								"std",
+								"dot"
+							],
+							[[
+								7,
+								"sample",
+								"xyz"
+							], [
+								6,
+								[
+									7,
+									"d",
+									"vec3f"
+								],
+								[
+									[5, "0.2126"],
+									[5, "0.7152"],
+									[5, "0.0722"]
+								]
+							]]
+						]
+					]
+				]
+			]]]],
+			"externalNames": [
+				"channel",
+				"std",
+				"d"
+			]
+		},
+		externals: () => ({
+			channel,
+			std: std_exports,
+			d: data_exports
+		})
+	}) && $.f)({})).$name(`mapSourceScalar_${channel}`);
+	mapSourceScalarCache.set(channel, fn);
+	return fn;
+}
+const applyRemapWindow = src_default.fn([
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((raw, inputMin, inputMax, outputMin, outputMax, curve) => {
+	"use gpu";
+	const inputRange = max(__tsover_sub(inputMax, inputMin), 1e-4);
+	return mix(outputMin, outputMax, pow(clamp(__tsover_div(__tsover_sub(raw, inputMin), inputRange), 0, 1), pow(2, __tsover_mul(-curve, 2))));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "raw"
+			},
+			{
+				"type": "i",
+				"name": "inputMin"
+			},
+			{
+				"type": "i",
+				"name": "inputMax"
+			},
+			{
+				"type": "i",
+				"name": "outputMin"
+			},
+			{
+				"type": "i",
+				"name": "outputMax"
+			},
+			{
+				"type": "i",
+				"name": "curve"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"inputRange",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					[[
+						1,
+						"inputMax",
+						"-",
+						"inputMin"
+					], [5, "0.0001"]]
+				]
+			],
+			[
+				13,
+				"normalised",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								1,
+								"raw",
+								"-",
+								"inputMin"
+							],
+							"/",
+							"inputRange"
+						],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"exponent",
+				[
+					6,
+					[
+						7,
+						"std",
+						"pow"
+					],
+					[[5, "2"], [
+						1,
+						[
+							4,
+							"-",
+							"curve"
+						],
+						"*",
+						[5, "2"]
+					]]
+				]
+			],
+			[
+				13,
+				"eased",
+				[
+					6,
+					[
+						7,
+						"std",
+						"pow"
+					],
+					["normalised", "exponent"]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"std",
+					"mix"
+				],
+				[
+					"outputMin",
+					"outputMax",
+					"eased"
+				]
+			]]
+		]],
+		"externalNames": ["std"]
+	},
+	externals: () => ({ std: std_exports })
+}) && $.f)({})).$name("applyRemapWindow");
+function remapWindowValues(window) {
+	return {
+		inputMin: window.inputMin,
+		inputMax: window.inputMax,
+		outputMin: window.outputMin,
+		outputMax: window.outputMax,
+		curve: window.curve
+	};
+}
+const bloomExtractSoftKnee = src_default.fn([
+	texture2d(f32),
+	u32,
+	u32,
+	vec2f,
+	vec2f,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((childTexture, cx, cy, inputSize, computeSize, threshold) => {
+	"use gpu";
+	const iw = inputSize.x;
+	const ih = inputSize.y;
+	const inputWm1 = i32(__tsover_sub(iw, 1));
+	const inputHm1 = i32(__tsover_sub(ih, 1));
+	let sample = vec4f(0, 0, 0, 0);
+	for (let ty = 0; ty < 4; ty++) for (let tx = 0; tx < 4; tx++) {
+		const su = __tsover_div(__tsover_add(f32(cx), __tsover_div(__tsover_add(f32(tx), .5), 4)), computeSize.x);
+		const sv = __tsover_div(__tsover_add(f32(cy), __tsover_div(__tsover_add(f32(ty), .5), 4)), computeSize.y);
+		const sx = clamp(i32(__tsover_mul(su, iw)), 0, inputWm1);
+		const sy = clamp(i32(__tsover_mul(sv, ih)), 0, inputHm1);
+		sample = sample.add(textureLoad(childTexture, vec2u(u32(sx), u32(sy)), 0));
+	}
+	sample = sample.mul(.0625);
+	const knee = __tsover_add(__tsover_mul(threshold, .5), 1e-4);
+	const lum = dot(sample.xyz, vec3f(.2126, .7152, .0722));
+	const soft = clamp(__tsover_add(__tsover_sub(lum, threshold), knee), 0, __tsover_mul(knee, 2));
+	const softCurve = __tsover_div(__tsover_mul(soft, soft), __tsover_mul(knee, 4));
+	const mask = __tsover_div(max(softCurve, __tsover_sub(lum, threshold)), max(lum, 1e-4));
+	return vec4f(sample.xyz.mul(mask), __tsover_mul(sample.w, mask));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "childTexture"
+			},
+			{
+				"type": "i",
+				"name": "cx"
+			},
+			{
+				"type": "i",
+				"name": "cy"
+			},
+			{
+				"type": "i",
+				"name": "inputSize"
+			},
+			{
+				"type": "i",
+				"name": "computeSize"
+			},
+			{
+				"type": "i",
+				"name": "threshold"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"iw",
+				[
+					7,
+					"inputSize",
+					"x"
+				]
+			],
+			[
+				13,
+				"ih",
+				[
+					7,
+					"inputSize",
+					"y"
+				]
+			],
+			[
+				13,
+				"inputWm1",
+				[
+					6,
+					[
+						7,
+						"d",
+						"i32"
+					],
+					[[
+						1,
+						"iw",
+						"-",
+						[5, "1"]
+					]]
+				]
+			],
+			[
+				13,
+				"inputHm1",
+				[
+					6,
+					[
+						7,
+						"d",
+						"i32"
+					],
+					[[
+						1,
+						"ih",
+						"-",
+						[5, "1"]
+					]]
+				]
+			],
+			[
+				12,
+				"sample",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec4f"
+					],
+					[
+						[5, "0"],
+						[5, "0"],
+						[5, "0"],
+						[5, "0"]
+					]
+				]
+			],
+			[
+				14,
+				[
+					12,
+					"ty",
+					[5, "0"]
+				],
+				[
+					1,
+					"ty",
+					"<",
+					[5, "4"]
+				],
+				[
+					102,
+					"++",
+					"ty"
+				],
+				[0, [[
+					14,
+					[
+						12,
+						"tx",
+						[5, "0"]
+					],
+					[
+						1,
+						"tx",
+						"<",
+						[5, "4"]
+					],
+					[
+						102,
+						"++",
+						"tx"
+					],
+					[0, [
+						[
+							13,
+							"su",
+							[
+								1,
+								[
+									1,
+									[
+										6,
+										[
+											7,
+											"d",
+											"f32"
+										],
+										["cx"]
+									],
+									"+",
+									[
+										1,
+										[
+											1,
+											[
+												6,
+												[
+													7,
+													"d",
+													"f32"
+												],
+												["tx"]
+											],
+											"+",
+											[5, "0.5"]
+										],
+										"/",
+										[5, "4"]
+									]
+								],
+								"/",
+								[
+									7,
+									"computeSize",
+									"x"
+								]
+							]
+						],
+						[
+							13,
+							"sv",
+							[
+								1,
+								[
+									1,
+									[
+										6,
+										[
+											7,
+											"d",
+											"f32"
+										],
+										["cy"]
+									],
+									"+",
+									[
+										1,
+										[
+											1,
+											[
+												6,
+												[
+													7,
+													"d",
+													"f32"
+												],
+												["ty"]
+											],
+											"+",
+											[5, "0.5"]
+										],
+										"/",
+										[5, "4"]
+									]
+								],
+								"/",
+								[
+									7,
+									"computeSize",
+									"y"
+								]
+							]
+						],
+						[
+							13,
+							"sx",
+							[
+								6,
+								[
+									7,
+									"std",
+									"clamp"
+								],
+								[
+									[
+										6,
+										[
+											7,
+											"d",
+											"i32"
+										],
+										[[
+											1,
+											"su",
+											"*",
+											"iw"
+										]]
+									],
+									[5, "0"],
+									"inputWm1"
+								]
+							]
+						],
+						[
+							13,
+							"sy",
+							[
+								6,
+								[
+									7,
+									"std",
+									"clamp"
+								],
+								[
+									[
+										6,
+										[
+											7,
+											"d",
+											"i32"
+										],
+										[[
+											1,
+											"sv",
+											"*",
+											"ih"
+										]]
+									],
+									[5, "0"],
+									"inputHm1"
+								]
+							]
+						],
+						[
+							2,
+							"sample",
+							"=",
+							[
+								6,
+								[
+									7,
+									"sample",
+									"add"
+								],
+								[[
+									6,
+									[
+										7,
+										"std",
+										"textureLoad"
+									],
+									[
+										"childTexture",
+										[
+											6,
+											[
+												7,
+												"d",
+												"vec2u"
+											],
+											[[
+												6,
+												[
+													7,
+													"d",
+													"u32"
+												],
+												["sx"]
+											], [
+												6,
+												[
+													7,
+													"d",
+													"u32"
+												],
+												["sy"]
+											]]
+										],
+										[5, "0"]
+									]
+								]]
+							]
+						]
+					]]
+				]]]
+			],
+			[
+				2,
+				"sample",
+				"=",
+				[
+					6,
+					[
+						7,
+						"sample",
+						"mul"
+					],
+					[[5, "0.0625"]]
+				]
+			],
+			[
+				13,
+				"knee",
+				[
+					1,
+					[
+						1,
+						"threshold",
+						"*",
+						[5, "0.5"]
+					],
+					"+",
+					[5, "0.0001"]
+				]
+			],
+			[
+				13,
+				"lum",
+				[
+					6,
+					[
+						7,
+						"std",
+						"dot"
+					],
+					[[
+						7,
+						"sample",
+						"xyz"
+					], [
+						6,
+						[
+							7,
+							"d",
+							"vec3f"
+						],
+						[
+							[5, "0.2126"],
+							[5, "0.7152"],
+							[5, "0.0722"]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"soft",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								1,
+								"lum",
+								"-",
+								"threshold"
+							],
+							"+",
+							"knee"
+						],
+						[5, "0"],
+						[
+							1,
+							"knee",
+							"*",
+							[5, "2"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"softCurve",
+				[
+					1,
+					[
+						1,
+						"soft",
+						"*",
+						"soft"
+					],
+					"/",
+					[
+						1,
+						"knee",
+						"*",
+						[5, "4"]
+					]
+				]
+			],
+			[
+				13,
+				"mask",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"std",
+							"max"
+						],
+						["softCurve", [
+							1,
+							"lum",
+							"-",
+							"threshold"
+						]]
+					],
+					"/",
+					[
+						6,
+						[
+							7,
+							"std",
+							"max"
+						],
+						["lum", [5, "0.0001"]]
+					]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"d",
+					"vec4f"
+				],
+				[[
+					6,
+					[
+						7,
+						[
+							7,
+							"sample",
+							"xyz"
+						],
+						"mul"
+					],
+					["mask"]
+				], [
+					1,
+					[
+						7,
+						"sample",
+						"w"
+					],
+					"*",
+					"mask"
+				]]
+			]]
+		]],
+		"externalNames": ["d", "std"]
+	},
+	externals: () => ({
+		d: data_exports,
+		std: std_exports
+	})
+}) && $.f)({})).$name("bloomExtractSoftKnee");
+var BRIGHT_FORMAT = "rgba16float";
+function buildBloomExtractGraph(computeWidth, computeHeight, kernelName) {
+	const Params = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+		threshold: f32,
+		size: f32,
+		...MAP_SOURCE_DIM_FIELDS
+	}), "Params");
+	const layout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
+		childTexture: { texture: texture2d(f32) },
+		brightMap: { storageTexture: textureStorage2d(BRIGHT_FORMAT, "write-only") },
+		blurMap: { storageTexture: textureStorage2d(BLUR_MAP_FORMAT, "write-only") },
+		params: { uniform: Params }
+	}), "layout");
+	return {
+		layout,
+		kernel: src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+			"use gpu";
+			const p = layout.$.params;
+			const bright = bloomExtractSoftKnee(layout.$.childTexture, cx, cy, vec2f(p.inputWidth, p.inputHeight), vec2f(computeWidth, computeHeight), p.threshold);
+			textureStore(layout.$.brightMap, vec2u(cx, cy), bright);
+			textureStore(layout.$.blurMap, vec2u(cx, cy), vec4f(p.size, 0, 0, 1));
+		}), {
+			v: 1,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "cx"
+				}, {
+					"type": "i",
+					"name": "cy"
+				}],
+				"body": [0, [
+					[
+						13,
+						"p",
+						[
+							7,
+							[
+								7,
+								"layout",
+								"$"
+							],
+							"params"
+						]
+					],
+					[
+						13,
+						"bright",
+						[
+							6,
+							"bloomExtractSoftKnee",
+							[
+								[
+									7,
+									[
+										7,
+										"layout",
+										"$"
+									],
+									"childTexture"
+								],
+								"cx",
+								"cy",
+								[
+									6,
+									[
+										7,
+										"d",
+										"vec2f"
+									],
+									[[
+										7,
+										"p",
+										"inputWidth"
+									], [
+										7,
+										"p",
+										"inputHeight"
+									]]
+								],
+								[
+									6,
+									[
+										7,
+										"d",
+										"vec2f"
+									],
+									["computeWidth", "computeHeight"]
+								],
+								[
+									7,
+									"p",
+									"threshold"
+								]
+							]
+						]
+					],
+					[
+						6,
+						[
+							7,
+							"std",
+							"textureStore"
+						],
+						[
+							[
+								7,
+								[
+									7,
+									"layout",
+									"$"
+								],
+								"brightMap"
+							],
+							[
+								6,
+								[
+									7,
+									"d",
+									"vec2u"
+								],
+								["cx", "cy"]
+							],
+							"bright"
+						]
+					],
+					[
+						6,
+						[
+							7,
+							"std",
+							"textureStore"
+						],
+						[
+							[
+								7,
+								[
+									7,
+									"layout",
+									"$"
+								],
+								"blurMap"
+							],
+							[
+								6,
+								[
+									7,
+									"d",
+									"vec2u"
+								],
+								["cx", "cy"]
+							],
+							[
+								6,
+								[
+									7,
+									"d",
+									"vec4f"
+								],
+								[
+									[
+										7,
+										"p",
+										"size"
+									],
+									[5, "0"],
+									[5, "0"],
+									[5, "1"]
+								]
+							]
+						]
+					]
+				]],
+				"externalNames": [
+					"layout",
+					"bloomExtractSoftKnee",
+					"d",
+					"computeWidth",
+					"computeHeight",
+					"std"
+				]
+			},
+			externals: () => ({
+				layout,
+				bloomExtractSoftKnee,
+				d: data_exports,
+				computeWidth,
+				computeHeight,
+				std: std_exports
+			})
+		}) && $.f)({})).$name(kernelName),
+		Params
+	};
+}
+function buildBloomExtractMapGraph(computeWidth, computeHeight, kernelName, channel) {
+	const Params = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+		threshold: f32,
+		...MAP_SOURCE_DIM_FIELDS,
+		...REMAP_WINDOW_FIELDS
+	}), "Params");
+	const layout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
+		childTexture: { texture: texture2d(f32) },
+		source: { texture: texture2d(f32) },
+		brightMap: { storageTexture: textureStorage2d(BRIGHT_FORMAT, "write-only") },
+		blurMap: { storageTexture: textureStorage2d(BLUR_MAP_FORMAT, "write-only") },
+		params: { uniform: Params }
+	}), "layout");
+	const channelScalar = mapSourceScalar(channel);
+	return {
+		layout,
+		kernel: src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+			"use gpu";
+			const p = layout.$.params;
+			const iw = p.inputWidth;
+			const ih = p.inputHeight;
+			const bright = bloomExtractSoftKnee(layout.$.childTexture, cx, cy, vec2f(iw, ih), vec2f(computeWidth, computeHeight), p.threshold);
+			textureStore(layout.$.brightMap, vec2u(cx, cy), bright);
+			const u = __tsover_div(__tsover_add(f32(cx), .5), computeWidth);
+			const v = __tsover_div(__tsover_add(f32(cy), .5), computeHeight);
+			const srcX = clamp(i32(round(__tsover_mul(u, iw))), 0, i32(__tsover_sub(iw, 1)));
+			const srcY = clamp(i32(round(__tsover_mul(v, ih))), 0, i32(__tsover_sub(ih, 1)));
+			const radius = applyRemapWindow(channelScalar(textureLoad(layout.$.source, vec2u(u32(srcX), u32(srcY)), 0)), p.inputMin, p.inputMax, p.outputMin, p.outputMax, p.curve);
+			textureStore(layout.$.blurMap, vec2u(cx, cy), vec4f(radius, 0, 0, 1));
+		}), {
+			v: 1,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "cx"
+				}, {
+					"type": "i",
+					"name": "cy"
+				}],
+				"body": [0, [
+					[
+						13,
+						"p",
+						[
+							7,
+							[
+								7,
+								"layout",
+								"$"
+							],
+							"params"
+						]
+					],
+					[
+						13,
+						"iw",
+						[
+							7,
+							"p",
+							"inputWidth"
+						]
+					],
+					[
+						13,
+						"ih",
+						[
+							7,
+							"p",
+							"inputHeight"
+						]
+					],
+					[
+						13,
+						"bright",
+						[
+							6,
+							"bloomExtractSoftKnee",
+							[
+								[
+									7,
+									[
+										7,
+										"layout",
+										"$"
+									],
+									"childTexture"
+								],
+								"cx",
+								"cy",
+								[
+									6,
+									[
+										7,
+										"d",
+										"vec2f"
+									],
+									["iw", "ih"]
+								],
+								[
+									6,
+									[
+										7,
+										"d",
+										"vec2f"
+									],
+									["computeWidth", "computeHeight"]
+								],
+								[
+									7,
+									"p",
+									"threshold"
+								]
+							]
+						]
+					],
+					[
+						6,
+						[
+							7,
+							"std",
+							"textureStore"
+						],
+						[
+							[
+								7,
+								[
+									7,
+									"layout",
+									"$"
+								],
+								"brightMap"
+							],
+							[
+								6,
+								[
+									7,
+									"d",
+									"vec2u"
+								],
+								["cx", "cy"]
+							],
+							"bright"
+						]
+					],
+					[
+						13,
+						"u",
+						[
+							1,
+							[
+								1,
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									["cx"]
+								],
+								"+",
+								[5, "0.5"]
+							],
+							"/",
+							"computeWidth"
+						]
+					],
+					[
+						13,
+						"v",
+						[
+							1,
+							[
+								1,
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									["cy"]
+								],
+								"+",
+								[5, "0.5"]
+							],
+							"/",
+							"computeHeight"
+						]
+					],
+					[
+						13,
+						"srcX",
+						[
+							6,
+							[
+								7,
+								"std",
+								"clamp"
+							],
+							[
+								[
+									6,
+									[
+										7,
+										"d",
+										"i32"
+									],
+									[[
+										6,
+										[
+											7,
+											"std",
+											"round"
+										],
+										[[
+											1,
+											"u",
+											"*",
+											"iw"
+										]]
+									]]
+								],
+								[5, "0"],
+								[
+									6,
+									[
+										7,
+										"d",
+										"i32"
+									],
+									[[
+										1,
+										"iw",
+										"-",
+										[5, "1"]
+									]]
+								]
+							]
+						]
+					],
+					[
+						13,
+						"srcY",
+						[
+							6,
+							[
+								7,
+								"std",
+								"clamp"
+							],
+							[
+								[
+									6,
+									[
+										7,
+										"d",
+										"i32"
+									],
+									[[
+										6,
+										[
+											7,
+											"std",
+											"round"
+										],
+										[[
+											1,
+											"v",
+											"*",
+											"ih"
+										]]
+									]]
+								],
+								[5, "0"],
+								[
+									6,
+									[
+										7,
+										"d",
+										"i32"
+									],
+									[[
+										1,
+										"ih",
+										"-",
+										[5, "1"]
+									]]
+								]
+							]
+						]
+					],
+					[
+						13,
+						"mapSample",
+						[
+							6,
+							[
+								7,
+								"std",
+								"textureLoad"
+							],
+							[
+								[
+									7,
+									[
+										7,
+										"layout",
+										"$"
+									],
+									"source"
+								],
+								[
+									6,
+									[
+										7,
+										"d",
+										"vec2u"
+									],
+									[[
+										6,
+										[
+											7,
+											"d",
+											"u32"
+										],
+										["srcX"]
+									], [
+										6,
+										[
+											7,
+											"d",
+											"u32"
+										],
+										["srcY"]
+									]]
+								],
+								[5, "0"]
+							]
+						]
+					],
+					[
+						13,
+						"radius",
+						[
+							6,
+							"applyRemapWindow",
+							[
+								[
+									6,
+									"channelScalar",
+									["mapSample"]
+								],
+								[
+									7,
+									"p",
+									"inputMin"
+								],
+								[
+									7,
+									"p",
+									"inputMax"
+								],
+								[
+									7,
+									"p",
+									"outputMin"
+								],
+								[
+									7,
+									"p",
+									"outputMax"
+								],
+								[
+									7,
+									"p",
+									"curve"
+								]
+							]
+						]
+					],
+					[
+						6,
+						[
+							7,
+							"std",
+							"textureStore"
+						],
+						[
+							[
+								7,
+								[
+									7,
+									"layout",
+									"$"
+								],
+								"blurMap"
+							],
+							[
+								6,
+								[
+									7,
+									"d",
+									"vec2u"
+								],
+								["cx", "cy"]
+							],
+							[
+								6,
+								[
+									7,
+									"d",
+									"vec4f"
+								],
+								[
+									"radius",
+									[5, "0"],
+									[5, "0"],
+									[5, "1"]
+								]
+							]
+						]
+					]
+				]],
+				"externalNames": [
+					"layout",
+					"bloomExtractSoftKnee",
+					"d",
+					"computeWidth",
+					"computeHeight",
+					"std",
+					"applyRemapWindow",
+					"channelScalar"
+				]
+			},
+			externals: () => ({
+				layout,
+				bloomExtractSoftKnee,
+				d: data_exports,
+				computeWidth,
+				computeHeight,
+				std: std_exports,
+				applyRemapWindow,
+				channelScalar
+			})
+		}) && $.f)({})).$name(kernelName),
+		Params
+	};
+}
+function aspectAwareComputeRes(canvasWidth, canvasHeight) {
+	const LONG_EDGE = Math.max(DEFAULT_COMPUTE_WIDTH, 640);
+	const aspect = canvasHeight > 0 ? canvasWidth / canvasHeight : 1;
+	return {
+		width: Math.max(8, aspect >= 1 ? LONG_EDGE : Math.round(LONG_EDGE * aspect)),
+		height: Math.max(8, aspect >= 1 ? Math.round(LONG_EDGE / aspect) : LONG_EDGE)
+	};
+}
+var DEFAULT_BLURRED_KEY = "blurredTexture";
+function canvasPixels(dimensions) {
+	return {
+		width: Math.max(1, Math.round(dimensions.width)),
+		height: Math.max(1, Math.round(dimensions.height))
+	};
+}
+function withFixedBlurCompute(params, config) {
+	const { childNode, gpu, convertToTexture, registerComputeTexture, onCleanup, onResize, dimensions } = params;
+	if (!childNode) return null;
+	const root = gpu?.root;
+	if (!root) return null;
+	const outputKey = config.outputKey ?? DEFAULT_BLURRED_KEY;
+	const childTexture = convertToTexture(childNode);
+	const canvas = canvasPixels(dimensions);
+	const gaussian = createGaussianBlurCompute(root, null, canvas.width, canvas.height, onCleanup, config.halfKernel);
+	const blurredTexture = registerComputeTexture(gaussian.outputTexture);
+	onResize(({ width, height }) => {
+		const next = canvasPixels({
+			width,
+			height
+		});
+		gaussian.setInputDimensions(next.width, next.height);
+	});
+	return {
+		outputs: {
+			childTexture,
+			[outputKey]: blurredTexture
+		},
+		bindInputs: (resolve) => {
+			const src = resolve(childTexture.key);
+			if (src) gaussian.setInputTexture(src.texture);
+		},
+		getComputeNodes: () => {
+			gaussian.updateRadius(config.radius());
+			return gaussian.computeSteps;
+		}
+	};
+}
+function withVariableBlurCompute(params, config) {
+	const { childNode, gpu, convertToTexture, registerComputeTexture, onCleanup, onResize, dimensions } = params;
+	if (!childNode) return null;
+	const root = gpu?.root;
+	if (!root) return null;
+	const outputKey = config.outputKey ?? DEFAULT_BLURRED_KEY;
+	const source = config.source;
+	const childTexture = convertToTexture(childNode);
+	let canvas = canvasPixels(dimensions);
+	const variable = createVariableGaussianBlurCompute(root, null, canvas.width, canvas.height, onCleanup, config.halfKernel);
+	const blurredTexture = registerComputeTexture(variable.outputTexture);
+	const fill = config.buildFill(variable.computeWidth, variable.computeHeight);
+	const fillParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(fill.Params), "fillParams");
+	const blurMap = variable.blurMapTexture;
+	const fillStepOpts = { size: [variable.computeWidth, variable.computeHeight] };
+	let fillStep = source ? createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+		"use gpu";
+		fill.kernel(cx, cy);
+	}), {
+		v: 1,
+		name: void 0,
+		ast: {
+			"params": [{
+				"type": "i",
+				"name": "cx"
+			}, {
+				"type": "i",
+				"name": "cy"
+			}],
+			"body": [0, [[
+				6,
+				[
+					7,
+					"fill",
+					"kernel"
+				],
+				["cx", "cy"]
+			]]],
+			"externalNames": ["fill"]
+		},
+		externals: () => ({ fill })
+	}) && $.f)({}), fillStepOpts) : createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+		"use gpu";
+		fill.kernel(cx, cy);
+	}), {
+		v: 1,
+		name: void 0,
+		ast: {
+			"params": [{
+				"type": "i",
+				"name": "cx"
+			}, {
+				"type": "i",
+				"name": "cy"
+			}],
+			"body": [0, [[
+				6,
+				[
+					7,
+					"fill",
+					"kernel"
+				],
+				["cx", "cy"]
+			]]],
+			"externalNames": ["fill"]
+		},
+		externals: () => ({ fill })
+	}) && $.f)({}), {
+		...fillStepOpts,
+		bindGroup: root.createBindGroup(fill.layout, {
+			blurMap,
+			params: fillParams.buffer
+		})
+	});
+	onResize(({ width, height }) => {
+		canvas = canvasPixels({
+			width,
+			height
+		});
+		variable.setInputDimensions(canvas.width, canvas.height);
+	});
+	return {
+		outputs: {
+			childTexture,
+			[outputKey]: blurredTexture
+		},
+		bindInputs: (resolve) => {
+			const src = resolve(childTexture.key);
+			if (src) variable.setInputTexture(src.texture);
+			if (!source) return;
+			const mapSrc = resolve(source.sourceTexture.key);
+			if (mapSrc) {
+				const bg = root.createBindGroup(fill.layout, {
+					source: mapSrc.texture,
+					blurMap,
+					params: fillParams.buffer
+				});
+				fillStep = fillStep.with(bg);
+			}
+		},
+		getComputeNodes: () => {
+			fillParams.write(config.fillValues(canvas, source?.window()));
+			return [fillStep, ...variable.computeSteps];
+		}
+	};
+}
+function withBloomCompute(params, config) {
+	const { childNode, gpu, convertToTexture, registerComputeTexture, onCleanup, onResize, dimensions } = params;
+	if (!childNode) return null;
+	const root = gpu?.root;
+	if (!root) return null;
+	const outputKey = config.outputKey ?? DEFAULT_BLURRED_KEY;
+	const mapInfo = config.mapInfo ?? null;
+	const childTexture = convertToTexture(childNode);
+	let canvas = canvasPixels(dimensions);
+	const res = aspectAwareComputeRes(canvas.width, canvas.height);
+	const brightBuffer = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
+		size: [res.width, res.height],
+		format: BRIGHT_FORMAT
+	}).$usage("storage", "sampled"), "brightBuffer");
+	onCleanup(() => brightBuffer.destroy());
+	const variable = createVariableGaussianBlurCompute(root, brightBuffer, res.width, res.height, onCleanup, void 0, res.width, res.height, { jitterTaps: true });
+	const blurredTexture = registerComputeTexture(variable.outputTexture);
+	onResize(({ width, height }) => {
+		canvas = canvasPixels({
+			width,
+			height
+		});
+	});
+	const graph = mapInfo && config.buildExtractMap ? config.buildExtractMap(res.width, res.height, mapInfo.channel) : config.buildExtract(res.width, res.height);
+	const prepassParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(graph.Params), "prepassParams");
+	let prepassStep = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+		"use gpu";
+		graph.kernel(cx, cy);
+	}), {
+		v: 1,
+		name: void 0,
+		ast: {
+			"params": [{
+				"type": "i",
+				"name": "cx"
+			}, {
+				"type": "i",
+				"name": "cy"
+			}],
+			"body": [0, [[
+				6,
+				[
+					7,
+					"graph",
+					"kernel"
+				],
+				["cx", "cy"]
+			]]],
+			"externalNames": ["graph"]
+		},
+		externals: () => ({ graph })
+	}) && $.f)({}), { size: [res.width, res.height] });
+	return {
+		outputs: {
+			childTexture,
+			[outputKey]: blurredTexture
+		},
+		bindInputs: (resolve) => {
+			const src = resolve(childTexture.key);
+			if (!src) return;
+			const mapSrc = mapInfo ? resolve(mapInfo.sourceTexture.key) : void 0;
+			if (mapInfo && !mapSrc) return;
+			const entries = {
+				childTexture: src.texture,
+				brightMap: brightBuffer,
+				blurMap: variable.blurMapTexture,
+				params: prepassParams.buffer
+			};
+			if (mapSrc) entries.source = mapSrc.texture;
+			prepassStep = prepassStep.with(root.createBindGroup(graph.layout, entries));
+		},
+		getComputeNodes: () => {
+			const threshold = config.threshold();
+			const values = mapInfo ? {
+				threshold,
+				inputWidth: canvas.width,
+				inputHeight: canvas.height,
+				...remapWindowValues(mapInfo.window())
+			} : {
+				threshold,
+				size: config.radius(),
+				inputWidth: canvas.width,
+				inputHeight: canvas.height
+			};
+			prepassParams.write(values);
+			return [prepassStep, ...variable.computeSteps];
+		}
+	};
+}
+function composeBlurredOverSharp(params, compose, options) {
+	const { childNode, computeOutputs, ctx, convertToTexture } = params;
+	if (!childNode) return ZERO;
+	const blurred = computeOutputs?.[options?.blurredKey ?? DEFAULT_BLURRED_KEY];
+	const sharp = computeOutputs?.[options?.sharpKey ?? "childTexture"];
+	if (!blurred || !sharp) return call(unpremultiplyAlpha, "unpremultiplyAlpha", [convertToTexture(childNode).sample(ctx.uv)]);
+	const sharpSample = sharp.sample(ctx.uv);
+	return call(unpremultiplyAlpha, "unpremultiplyAlpha", [compose(blurred.sample(ctx.uv), sharpSample)]);
+}
+export { withFixedBlurCompute as _, REMAP_WINDOW_FIELDS as a, buildBloomExtractGraph as c, createGaussianBlurCompute as d, gaussianTapWeights as f, withBloomCompute as g, unrolledTapGather as h, MAP_SOURCE_DIM_FIELDS as i, buildBloomExtractMapGraph as l, remapWindowValues as m, DEFAULT_COMPUTE_HEIGHT as n, applyRemapWindow as o, mapSourceScalar as p, DEFAULT_COMPUTE_WIDTH as r, blur_exports as s, BLUR_MAP_FORMAT as t, composeBlurredOverSharp as u, withVariableBlurCompute as v };