shaders 3.0.447 → 3.0.449

package/dist/core/blur-tvWOoxKt.js

@@ -0,0 +1,2247 @@
+import { Gt as textureStorage2d, Pt as round, Ut as arrayOf, Vt as data_exports, Wt as texture2d, Xt as struct, _t as clamp, an as f32, at as textureStore, et as src_default, in as vec4f, it as textureLoad, nt as std_exports, on as i32, sn as u32, tn as vec2u, wt as fract } from "./edges-BXNBKxSN.js";
+import { n as createGuardedCompute } from "./compute-BjeJ0sIA.js";
+var DEFAULT_HALF_KERNEL = 24;
+const DEFAULT_COMPUTE_WIDTH = 1024;
+const DEFAULT_COMPUTE_HEIGHT = 640;
+var PASSTHROUGH_THRESHOLD = .5;
+var INTERMEDIATE_FORMAT = "rgba32float";
+var OUTPUT_FORMAT = "rgba16float";
+const BLUR_MAP_FORMAT = "rgba32float";
+function buildFixedWeights(halfKernel) {
+	const sigma = halfKernel / 3;
+	const size = halfKernel * 2 + 1;
+	const weights = [];
+	let sum = 0;
+	for (let i = -halfKernel; i <= halfKernel; i++) {
+		const w = Math.exp(-(i * i) / (2 * sigma * sigma));
+		weights.push(w);
+		sum += w;
+	}
+	for (let i = 0; i < size; i++) weights[i] /= sum;
+	return weights;
+}
+function buildTruncatedWeights(halfKernel, sigma) {
+	const size = halfKernel * 2 + 1;
+	const activeHalf = Math.max(1, Math.min(halfKernel, Math.ceil(sigma * 3)));
+	const weights = new Array(size).fill(0);
+	let total = 0;
+	for (let i = -halfKernel; i <= halfKernel; i++) if (Math.abs(i) <= activeHalf) {
+		const w = Math.exp(-(i * i) / (2 * sigma * sigma));
+		weights[i + halfKernel] = w;
+		total += w;
+	}
+	for (let i = 0; i < size; i++) weights[i] /= total;
+	return {
+		weights,
+		activeHalf
+	};
+}
+function fixedHParams() {
+	return struct({
+		activeHalf: i32,
+		inputWidth: f32,
+		inputHeight: f32
+	});
+}
+function fixedVParams() {
+	return struct({ activeHalf: i32 });
+}
+function buildFixedBlurGraph(halfKernel, computeWidth, computeHeight) {
+	const KERNEL_SIZE = halfKernel * 2 + 1;
+	const HALF_KERNEL = halfKernel;
+	const HParams = fixedHParams();
+	const VParams = fixedVParams();
+	const hLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
+		input: { texture: texture2d(f32) },
+		intermediate: { storageTexture: textureStorage2d(INTERMEDIATE_FORMAT, "write-only") },
+		weights: {
+			storage: arrayOf(f32, KERNEL_SIZE),
+			access: "readonly"
+		},
+		params: { uniform: HParams }
+	}), "hLayout");
+	const vLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
+		src: { storageTexture: textureStorage2d(INTERMEDIATE_FORMAT, "read-only") },
+		output: { storageTexture: textureStorage2d(OUTPUT_FORMAT, "write-only") },
+		weights: {
+			storage: arrayOf(f32, KERNEL_SIZE),
+			access: "readonly"
+		},
+		params: { uniform: VParams }
+	}), "vLayout");
+	return {
+		hLayout,
+		vLayout,
+		kernelH: src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+			"use gpu";
+			const p = hLayout.$.params;
+			const inputCx = __tsover_sub(__tsover_div(__tsover_mul(__tsover_add(f32(cx), .5), p.inputWidth), computeWidth), .5);
+			const inputCy = __tsover_sub(__tsover_div(__tsover_mul(__tsover_add(f32(cy), .5), p.inputHeight), computeHeight), .5);
+			const inputWm1 = i32(__tsover_sub(p.inputWidth, 1));
+			const inputHm1 = i32(__tsover_sub(p.inputHeight, 1));
+			const inputCxI = i32(round(inputCx));
+			const inputCyI = clamp(i32(round(inputCy)), 0, inputHm1);
+			const ah = p.activeHalf;
+			const count = __tsover_add(__tsover_mul(ah, 2), 1);
+			let sum = vec4f(0, 0, 0, 0);
+			for (let i = 0; i < count; i++) {
+				const off = __tsover_sub(i, ah);
+				const sampleX = clamp(__tsover_add(inputCxI, off), 0, inputWm1);
+				const texel = textureLoad(hLayout.$.input, vec2u(u32(sampleX), u32(inputCyI)), 0);
+				sum = sum.add(texel.mul(hLayout.$.weights[__tsover_add(off, HALF_KERNEL)]));
+			}
+			textureStore(hLayout.$.intermediate, vec2u(cx, cy), sum);
+		}), {
+			v: 1,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "cx"
+				}, {
+					"type": "i",
+					"name": "cy"
+				}],
+				"body": [0, [
+					[
+						13,
+						"p",
+						[
+							7,
+							[
+								7,
+								"hLayout",
+								"$"
+							],
+							"params"
+						]
+					],
+					[
+						13,
+						"inputCx",
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									[
+										1,
+										[
+											6,
+											[
+												7,
+												"d",
+												"f32"
+											],
+											["cx"]
+										],
+										"+",
+										[5, "0.5"]
+									],
+									"*",
+									[
+										7,
+										"p",
+										"inputWidth"
+									]
+								],
+								"/",
+								"computeWidth"
+							],
+							"-",
+							[5, "0.5"]
+						]
+					],
+					[
+						13,
+						"inputCy",
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									[
+										1,
+										[
+											6,
+											[
+												7,
+												"d",
+												"f32"
+											],
+											["cy"]
+										],
+										"+",
+										[5, "0.5"]
+									],
+									"*",
+									[
+										7,
+										"p",
+										"inputHeight"
+									]
+								],
+								"/",
+								"computeHeight"
+							],
+							"-",
+							[5, "0.5"]
+						]
+					],
+					[
+						13,
+						"inputWm1",
+						[
+							6,
+							[
+								7,
+								"d",
+								"i32"
+							],
+							[[
+								1,
+								[
+									7,
+									"p",
+									"inputWidth"
+								],
+								"-",
+								[5, "1"]
+							]]
+						]
+					],
+					[
+						13,
+						"inputHm1",
+						[
+							6,
+							[
+								7,
+								"d",
+								"i32"
+							],
+							[[
+								1,
+								[
+									7,
+									"p",
+									"inputHeight"
+								],
+								"-",
+								[5, "1"]
+							]]
+						]
+					],
+					[
+						13,
+						"inputCxI",
+						[
+							6,
+							[
+								7,
+								"d",
+								"i32"
+							],
+							[[
+								6,
+								[
+									7,
+									"std",
+									"round"
+								],
+								["inputCx"]
+							]]
+						]
+					],
+					[
+						13,
+						"inputCyI",
+						[
+							6,
+							[
+								7,
+								"std",
+								"clamp"
+							],
+							[
+								[
+									6,
+									[
+										7,
+										"d",
+										"i32"
+									],
+									[[
+										6,
+										[
+											7,
+											"std",
+											"round"
+										],
+										["inputCy"]
+									]]
+								],
+								[5, "0"],
+								"inputHm1"
+							]
+						]
+					],
+					[
+						13,
+						"ah",
+						[
+							7,
+							"p",
+							"activeHalf"
+						]
+					],
+					[
+						13,
+						"count",
+						[
+							1,
+							[
+								1,
+								"ah",
+								"*",
+								[5, "2"]
+							],
+							"+",
+							[5, "1"]
+						]
+					],
+					[
+						12,
+						"sum",
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec4f"
+							],
+							[
+								[5, "0"],
+								[5, "0"],
+								[5, "0"],
+								[5, "0"]
+							]
+						]
+					],
+					[
+						14,
+						[
+							12,
+							"i",
+							[5, "0"]
+						],
+						[
+							1,
+							"i",
+							"<",
+							"count"
+						],
+						[
+							102,
+							"++",
+							"i"
+						],
+						[0, [
+							[
+								13,
+								"off",
+								[
+									1,
+									"i",
+									"-",
+									"ah"
+								]
+							],
+							[
+								13,
+								"sampleX",
+								[
+									6,
+									[
+										7,
+										"std",
+										"clamp"
+									],
+									[
+										[
+											1,
+											"inputCxI",
+											"+",
+											"off"
+										],
+										[5, "0"],
+										"inputWm1"
+									]
+								]
+							],
+							[
+								13,
+								"texel",
+								[
+									6,
+									[
+										7,
+										"std",
+										"textureLoad"
+									],
+									[
+										[
+											7,
+											[
+												7,
+												"hLayout",
+												"$"
+											],
+											"input"
+										],
+										[
+											6,
+											[
+												7,
+												"d",
+												"vec2u"
+											],
+											[[
+												6,
+												[
+													7,
+													"d",
+													"u32"
+												],
+												["sampleX"]
+											], [
+												6,
+												[
+													7,
+													"d",
+													"u32"
+												],
+												["inputCyI"]
+											]]
+										],
+										[5, "0"]
+									]
+								]
+							],
+							[
+								2,
+								"sum",
+								"=",
+								[
+									6,
+									[
+										7,
+										"sum",
+										"add"
+									],
+									[[
+										6,
+										[
+											7,
+											"texel",
+											"mul"
+										],
+										[[
+											8,
+											[
+												7,
+												[
+													7,
+													"hLayout",
+													"$"
+												],
+												"weights"
+											],
+											[
+												1,
+												"off",
+												"+",
+												"HALF_KERNEL"
+											]
+										]]
+									]]
+								]
+							]
+						]]
+					],
+					[
+						6,
+						[
+							7,
+							"std",
+							"textureStore"
+						],
+						[
+							[
+								7,
+								[
+									7,
+									"hLayout",
+									"$"
+								],
+								"intermediate"
+							],
+							[
+								6,
+								[
+									7,
+									"d",
+									"vec2u"
+								],
+								["cx", "cy"]
+							],
+							"sum"
+						]
+					]
+				]],
+				"externalNames": [
+					"hLayout",
+					"d",
+					"computeWidth",
+					"computeHeight",
+					"std",
+					"HALF_KERNEL"
+				]
+			},
+			externals: () => ({
+				hLayout,
+				d: data_exports,
+				computeWidth,
+				computeHeight,
+				std: std_exports,
+				HALF_KERNEL
+			})
+		}) && $.f)({})).$name("gaussianBlurH"),
+		kernelV: src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+			"use gpu";
+			const av = vLayout.$.params.activeHalf;
+			const count = __tsover_add(__tsover_mul(av, 2), 1);
+			const cyi = i32(cy);
+			let sum = vec4f(0, 0, 0, 0);
+			for (let i = 0; i < count; i++) {
+				const off = __tsover_sub(i, av);
+				const sampleY = clamp(__tsover_add(cyi, off), 0, __tsover_sub(computeHeight, 1));
+				const texel = textureLoad(vLayout.$.src, vec2u(cx, u32(sampleY)));
+				sum = sum.add(texel.mul(vLayout.$.weights[__tsover_add(off, HALF_KERNEL)]));
+			}
+			textureStore(vLayout.$.output, vec2u(cx, cy), sum);
+		}), {
+			v: 1,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "cx"
+				}, {
+					"type": "i",
+					"name": "cy"
+				}],
+				"body": [0, [
+					[
+						13,
+						"av",
+						[
+							7,
+							[
+								7,
+								[
+									7,
+									"vLayout",
+									"$"
+								],
+								"params"
+							],
+							"activeHalf"
+						]
+					],
+					[
+						13,
+						"count",
+						[
+							1,
+							[
+								1,
+								"av",
+								"*",
+								[5, "2"]
+							],
+							"+",
+							[5, "1"]
+						]
+					],
+					[
+						13,
+						"cyi",
+						[
+							6,
+							[
+								7,
+								"d",
+								"i32"
+							],
+							["cy"]
+						]
+					],
+					[
+						12,
+						"sum",
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec4f"
+							],
+							[
+								[5, "0"],
+								[5, "0"],
+								[5, "0"],
+								[5, "0"]
+							]
+						]
+					],
+					[
+						14,
+						[
+							12,
+							"i",
+							[5, "0"]
+						],
+						[
+							1,
+							"i",
+							"<",
+							"count"
+						],
+						[
+							102,
+							"++",
+							"i"
+						],
+						[0, [
+							[
+								13,
+								"off",
+								[
+									1,
+									"i",
+									"-",
+									"av"
+								]
+							],
+							[
+								13,
+								"sampleY",
+								[
+									6,
+									[
+										7,
+										"std",
+										"clamp"
+									],
+									[
+										[
+											1,
+											"cyi",
+											"+",
+											"off"
+										],
+										[5, "0"],
+										[
+											1,
+											"computeHeight",
+											"-",
+											[5, "1"]
+										]
+									]
+								]
+							],
+							[
+								13,
+								"texel",
+								[
+									6,
+									[
+										7,
+										"std",
+										"textureLoad"
+									],
+									[[
+										7,
+										[
+											7,
+											"vLayout",
+											"$"
+										],
+										"src"
+									], [
+										6,
+										[
+											7,
+											"d",
+											"vec2u"
+										],
+										["cx", [
+											6,
+											[
+												7,
+												"d",
+												"u32"
+											],
+											["sampleY"]
+										]]
+									]]
+								]
+							],
+							[
+								2,
+								"sum",
+								"=",
+								[
+									6,
+									[
+										7,
+										"sum",
+										"add"
+									],
+									[[
+										6,
+										[
+											7,
+											"texel",
+											"mul"
+										],
+										[[
+											8,
+											[
+												7,
+												[
+													7,
+													"vLayout",
+													"$"
+												],
+												"weights"
+											],
+											[
+												1,
+												"off",
+												"+",
+												"HALF_KERNEL"
+											]
+										]]
+									]]
+								]
+							]
+						]]
+					],
+					[
+						6,
+						[
+							7,
+							"std",
+							"textureStore"
+						],
+						[
+							[
+								7,
+								[
+									7,
+									"vLayout",
+									"$"
+								],
+								"output"
+							],
+							[
+								6,
+								[
+									7,
+									"d",
+									"vec2u"
+								],
+								["cx", "cy"]
+							],
+							"sum"
+						]
+					]
+				]],
+				"externalNames": [
+					"vLayout",
+					"d",
+					"std",
+					"computeHeight",
+					"HALF_KERNEL"
+				]
+			},
+			externals: () => ({
+				vLayout,
+				d: data_exports,
+				std: std_exports,
+				computeHeight,
+				HALF_KERNEL
+			})
+		}) && $.f)({})).$name("gaussianBlurV"),
+		HParams,
+		VParams,
+		KERNEL_SIZE
+	};
+}
+function createGaussianBlurCompute(root, inputTexture, inputWidth, inputHeight, onCleanup, halfKernel = DEFAULT_HALF_KERNEL, computeWidth = DEFAULT_COMPUTE_WIDTH, computeHeight = 640) {
+	const HALF_KERNEL = halfKernel;
+	const graph = buildFixedBlurGraph(halfKernel, computeWidth, computeHeight);
+	const { hLayout, vLayout, kernelH, kernelV, KERNEL_SIZE } = graph;
+	const intermediateTex = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
+		size: [computeWidth, computeHeight],
+		format: INTERMEDIATE_FORMAT
+	}).$usage("storage"), "intermediateTex");
+	const outputTex = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
+		size: [computeWidth, computeHeight],
+		format: OUTPUT_FORMAT
+	}).$usage("storage", "sampled"), "outputTex");
+	const weightsHBuf = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createBuffer(arrayOf(f32, KERNEL_SIZE)).$usage("storage"), "weightsHBuf");
+	const weightsVBuf = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createBuffer(arrayOf(f32, KERNEL_SIZE)).$usage("storage"), "weightsVBuf");
+	const paramsH = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(graph.HParams), "paramsH");
+	const paramsV = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(graph.VParams), "paramsV");
+	onCleanup(() => {
+		intermediateTex.destroy();
+		outputTex.destroy();
+	});
+	const vBindGroup = root.createBindGroup(vLayout, {
+		src: intermediateTex,
+		output: outputTex,
+		weights: weightsVBuf,
+		params: paramsV.buffer
+	});
+	const hPipeline = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+		"use gpu";
+		kernelH(cx, cy);
+	}), {
+		v: 1,
+		name: void 0,
+		ast: {
+			"params": [{
+				"type": "i",
+				"name": "cx"
+			}, {
+				"type": "i",
+				"name": "cy"
+			}],
+			"body": [0, [[
+				6,
+				"kernelH",
+				["cx", "cy"]
+			]]],
+			"externalNames": ["kernelH"]
+		},
+		externals: () => ({ kernelH })
+	}) && $.f)({}), { size: [computeWidth, computeHeight] });
+	const computeSteps = [hPipeline, createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+		"use gpu";
+		kernelV(cx, cy);
+	}), {
+		v: 1,
+		name: void 0,
+		ast: {
+			"params": [{
+				"type": "i",
+				"name": "cx"
+			}, {
+				"type": "i",
+				"name": "cy"
+			}],
+			"body": [0, [[
+				6,
+				"kernelV",
+				["cx", "cy"]
+			]]],
+			"externalNames": ["kernelV"]
+		},
+		externals: () => ({ kernelV })
+	}) && $.f)({}), {
+		size: [computeWidth, computeHeight],
+		bindGroup: vBindGroup
+	})];
+	function setInputTexture(input) {
+		const hBindGroup = root.createBindGroup(hLayout, {
+			input,
+			intermediate: intermediateTex,
+			weights: weightsHBuf,
+			params: paramsH.buffer
+		});
+		computeSteps[0] = hPipeline.with(hBindGroup);
+	}
+	if (inputTexture != null) setInputTexture(inputTexture);
+	let scaleY = inputHeight / computeHeight;
+	let curInputWidth = inputWidth;
+	let curInputHeight = inputHeight;
+	let lastRadius = -1;
+	function updateWeights() {
+		const pixelRadius = lastRadius < 0 ? 4 : lastRadius;
+		const sigmaH = Math.max(pixelRadius * .5, .001);
+		const sigmaV = Math.max(sigmaH / scaleY, .001);
+		const h = buildTruncatedWeights(HALF_KERNEL, sigmaH);
+		const v = buildTruncatedWeights(HALF_KERNEL, sigmaV);
+		weightsHBuf.write(h.weights);
+		weightsVBuf.write(v.weights);
+		paramsH.write({
+			activeHalf: h.activeHalf,
+			inputWidth: curInputWidth,
+			inputHeight: curInputHeight
+		});
+		paramsV.write({ activeHalf: v.activeHalf });
+	}
+	function updateRadius(pixelRadius) {
+		if (Math.abs(pixelRadius - lastRadius) < .01) return;
+		lastRadius = pixelRadius;
+		updateWeights();
+	}
+	updateRadius(4);
+	return {
+		computeSteps,
+		outputTexture: outputTex,
+		updateRadius,
+		computeWidth,
+		computeHeight,
+		setInputTexture,
+		setInputDimensions: (newW, newH) => {
+			curInputWidth = newW;
+			curInputHeight = newH;
+			paramsH.patch({
+				inputWidth: newW,
+				inputHeight: newH
+			});
+			const newScaleY = newH / computeHeight;
+			if (Math.abs(newScaleY - scaleY) > .001) {
+				scaleY = newScaleY;
+				updateWeights();
+			}
+		}
+	};
+}
+function variableHParams() {
+	return struct({
+		inputWidth: f32,
+		inputHeight: f32
+	});
+}
+function variableVParams() {
+	return struct({ scaleY: f32 });
+}
+function buildVariableBlurGraph(halfKernel, computeWidth, computeHeight, jitterTaps) {
+	const KERNEL_SIZE = halfKernel * 2 + 1;
+	const HALF_KERNEL = halfKernel;
+	const invHalf = 1 / HALF_KERNEL;
+	const HParams = variableHParams();
+	const VParams = variableVParams();
+	const hLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
+		blurMap: { storageTexture: textureStorage2d(BLUR_MAP_FORMAT, "read-only") },
+		input: { texture: texture2d(f32) },
+		intermediate: { storageTexture: textureStorage2d(INTERMEDIATE_FORMAT, "write-only") },
+		weights: {
+			storage: arrayOf(f32, KERNEL_SIZE),
+			access: "readonly"
+		},
+		params: { uniform: HParams }
+	}), "hLayout");
+	const vLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
+		blurMap: { storageTexture: textureStorage2d(BLUR_MAP_FORMAT, "read-only") },
+		src: { storageTexture: textureStorage2d(INTERMEDIATE_FORMAT, "read-only") },
+		output: { storageTexture: textureStorage2d(OUTPUT_FORMAT, "write-only") },
+		weights: {
+			storage: arrayOf(f32, KERNEL_SIZE),
+			access: "readonly"
+		},
+		params: { uniform: VParams }
+	}), "vLayout");
+	return {
+		hLayout,
+		vLayout,
+		kernelH: src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+			"use gpu";
+			const p = hLayout.$.params;
+			const blurRadius = textureLoad(hLayout.$.blurMap, vec2u(cx, cy)).r;
+			const inputCx = __tsover_sub(__tsover_div(__tsover_mul(__tsover_add(f32(cx), .5), p.inputWidth), computeWidth), .5);
+			const inputCy = __tsover_sub(__tsover_div(__tsover_mul(__tsover_add(f32(cy), .5), p.inputHeight), computeHeight), .5);
+			const inputWm1 = i32(__tsover_sub(p.inputWidth, 1));
+			const inputHm1 = i32(__tsover_sub(p.inputHeight, 1));
+			const inputCyI = clamp(i32(round(inputCy)), 0, inputHm1);
+			if (blurRadius < PASSTHROUGH_THRESHOLD) {
+				const cxClamp = clamp(i32(round(inputCx)), 0, inputWm1);
+				const texel = textureLoad(hLayout.$.input, vec2u(u32(cxClamp), u32(inputCyI)), 0);
+				textureStore(hLayout.$.intermediate, vec2u(cx, cy), texel);
+			} else {
+				const jitterH = jitterTaps ? __tsover_sub(fract(__tsover_mul(52.9829189, fract(__tsover_add(__tsover_mul(f32(cx), .06711056), __tsover_mul(f32(cy), .00583715))))), .5) : f32(0);
+				let sum = vec4f(0, 0, 0, 0);
+				for (let i = -HALF_KERNEL; i <= HALF_KERNEL; i++) {
+					const offset = __tsover_mul(__tsover_mul(__tsover_add(f32(i), jitterH), invHalf), blurRadius);
+					const sampleX = clamp(i32(round(__tsover_add(inputCx, offset))), 0, inputWm1);
+					const texel = textureLoad(hLayout.$.input, vec2u(u32(sampleX), u32(inputCyI)), 0);
+					sum = sum.add(texel.mul(hLayout.$.weights[__tsover_add(i, HALF_KERNEL)]));
+				}
+				textureStore(hLayout.$.intermediate, vec2u(cx, cy), sum);
+			}
+		}), {
+			v: 1,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "cx"
+				}, {
+					"type": "i",
+					"name": "cy"
+				}],
+				"body": [0, [
+					[
+						13,
+						"p",
+						[
+							7,
+							[
+								7,
+								"hLayout",
+								"$"
+							],
+							"params"
+						]
+					],
+					[
+						13,
+						"blurRadius",
+						[
+							7,
+							[
+								6,
+								[
+									7,
+									"std",
+									"textureLoad"
+								],
+								[[
+									7,
+									[
+										7,
+										"hLayout",
+										"$"
+									],
+									"blurMap"
+								], [
+									6,
+									[
+										7,
+										"d",
+										"vec2u"
+									],
+									["cx", "cy"]
+								]]
+							],
+							"r"
+						]
+					],
+					[
+						13,
+						"inputCx",
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									[
+										1,
+										[
+											6,
+											[
+												7,
+												"d",
+												"f32"
+											],
+											["cx"]
+										],
+										"+",
+										[5, "0.5"]
+									],
+									"*",
+									[
+										7,
+										"p",
+										"inputWidth"
+									]
+								],
+								"/",
+								"computeWidth"
+							],
+							"-",
+							[5, "0.5"]
+						]
+					],
+					[
+						13,
+						"inputCy",
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									[
+										1,
+										[
+											6,
+											[
+												7,
+												"d",
+												"f32"
+											],
+											["cy"]
+										],
+										"+",
+										[5, "0.5"]
+									],
+									"*",
+									[
+										7,
+										"p",
+										"inputHeight"
+									]
+								],
+								"/",
+								"computeHeight"
+							],
+							"-",
+							[5, "0.5"]
+						]
+					],
+					[
+						13,
+						"inputWm1",
+						[
+							6,
+							[
+								7,
+								"d",
+								"i32"
+							],
+							[[
+								1,
+								[
+									7,
+									"p",
+									"inputWidth"
+								],
+								"-",
+								[5, "1"]
+							]]
+						]
+					],
+					[
+						13,
+						"inputHm1",
+						[
+							6,
+							[
+								7,
+								"d",
+								"i32"
+							],
+							[[
+								1,
+								[
+									7,
+									"p",
+									"inputHeight"
+								],
+								"-",
+								[5, "1"]
+							]]
+						]
+					],
+					[
+						13,
+						"inputCyI",
+						[
+							6,
+							[
+								7,
+								"std",
+								"clamp"
+							],
+							[
+								[
+									6,
+									[
+										7,
+										"d",
+										"i32"
+									],
+									[[
+										6,
+										[
+											7,
+											"std",
+											"round"
+										],
+										["inputCy"]
+									]]
+								],
+								[5, "0"],
+								"inputHm1"
+							]
+						]
+					],
+					[
+						11,
+						[
+							1,
+							"blurRadius",
+							"<",
+							"PASSTHROUGH_THRESHOLD"
+						],
+						[0, [
+							[
+								13,
+								"cxClamp",
+								[
+									6,
+									[
+										7,
+										"std",
+										"clamp"
+									],
+									[
+										[
+											6,
+											[
+												7,
+												"d",
+												"i32"
+											],
+											[[
+												6,
+												[
+													7,
+													"std",
+													"round"
+												],
+												["inputCx"]
+											]]
+										],
+										[5, "0"],
+										"inputWm1"
+									]
+								]
+							],
+							[
+								13,
+								"texel",
+								[
+									6,
+									[
+										7,
+										"std",
+										"textureLoad"
+									],
+									[
+										[
+											7,
+											[
+												7,
+												"hLayout",
+												"$"
+											],
+											"input"
+										],
+										[
+											6,
+											[
+												7,
+												"d",
+												"vec2u"
+											],
+											[[
+												6,
+												[
+													7,
+													"d",
+													"u32"
+												],
+												["cxClamp"]
+											], [
+												6,
+												[
+													7,
+													"d",
+													"u32"
+												],
+												["inputCyI"]
+											]]
+										],
+										[5, "0"]
+									]
+								]
+							],
+							[
+								6,
+								[
+									7,
+									"std",
+									"textureStore"
+								],
+								[
+									[
+										7,
+										[
+											7,
+											"hLayout",
+											"$"
+										],
+										"intermediate"
+									],
+									[
+										6,
+										[
+											7,
+											"d",
+											"vec2u"
+										],
+										["cx", "cy"]
+									],
+									"texel"
+								]
+							]
+						]],
+						[0, [
+							[
+								13,
+								"jitterH",
+								[
+									105,
+									"jitterTaps",
+									[
+										1,
+										[
+											6,
+											[
+												7,
+												"std",
+												"fract"
+											],
+											[[
+												1,
+												[5, "52.9829189"],
+												"*",
+												[
+													6,
+													[
+														7,
+														"std",
+														"fract"
+													],
+													[[
+														1,
+														[
+															1,
+															[
+																6,
+																[
+																	7,
+																	"d",
+																	"f32"
+																],
+																["cx"]
+															],
+															"*",
+															[5, "0.06711056"]
+														],
+														"+",
+														[
+															1,
+															[
+																6,
+																[
+																	7,
+																	"d",
+																	"f32"
+																],
+																["cy"]
+															],
+															"*",
+															[5, "0.00583715"]
+														]
+													]]
+												]
+											]]
+										],
+										"-",
+										[5, "0.5"]
+									],
+									[
+										6,
+										[
+											7,
+											"d",
+											"f32"
+										],
+										[[5, "0"]]
+									]
+								]
+							],
+							[
+								12,
+								"sum",
+								[
+									6,
+									[
+										7,
+										"d",
+										"vec4f"
+									],
+									[
+										[5, "0"],
+										[5, "0"],
+										[5, "0"],
+										[5, "0"]
+									]
+								]
+							],
+							[
+								14,
+								[
+									12,
+									"i",
+									[
+										4,
+										"-",
+										"HALF_KERNEL"
+									]
+								],
+								[
+									1,
+									"i",
+									"<=",
+									"HALF_KERNEL"
+								],
+								[
+									102,
+									"++",
+									"i"
+								],
+								[0, [
+									[
+										13,
+										"offset",
+										[
+											1,
+											[
+												1,
+												[
+													1,
+													[
+														6,
+														[
+															7,
+															"d",
+															"f32"
+														],
+														["i"]
+													],
+													"+",
+													"jitterH"
+												],
+												"*",
+												"invHalf"
+											],
+											"*",
+											"blurRadius"
+										]
+									],
+									[
+										13,
+										"sampleX",
+										[
+											6,
+											[
+												7,
+												"std",
+												"clamp"
+											],
+											[
+												[
+													6,
+													[
+														7,
+														"d",
+														"i32"
+													],
+													[[
+														6,
+														[
+															7,
+															"std",
+															"round"
+														],
+														[[
+															1,
+															"inputCx",
+															"+",
+															"offset"
+														]]
+													]]
+												],
+												[5, "0"],
+												"inputWm1"
+											]
+										]
+									],
+									[
+										13,
+										"texel",
+										[
+											6,
+											[
+												7,
+												"std",
+												"textureLoad"
+											],
+											[
+												[
+													7,
+													[
+														7,
+														"hLayout",
+														"$"
+													],
+													"input"
+												],
+												[
+													6,
+													[
+														7,
+														"d",
+														"vec2u"
+													],
+													[[
+														6,
+														[
+															7,
+															"d",
+															"u32"
+														],
+														["sampleX"]
+													], [
+														6,
+														[
+															7,
+															"d",
+															"u32"
+														],
+														["inputCyI"]
+													]]
+												],
+												[5, "0"]
+											]
+										]
+									],
+									[
+										2,
+										"sum",
+										"=",
+										[
+											6,
+											[
+												7,
+												"sum",
+												"add"
+											],
+											[[
+												6,
+												[
+													7,
+													"texel",
+													"mul"
+												],
+												[[
+													8,
+													[
+														7,
+														[
+															7,
+															"hLayout",
+															"$"
+														],
+														"weights"
+													],
+													[
+														1,
+														"i",
+														"+",
+														"HALF_KERNEL"
+													]
+												]]
+											]]
+										]
+									]
+								]]
+							],
+							[
+								6,
+								[
+									7,
+									"std",
+									"textureStore"
+								],
+								[
+									[
+										7,
+										[
+											7,
+											"hLayout",
+											"$"
+										],
+										"intermediate"
+									],
+									[
+										6,
+										[
+											7,
+											"d",
+											"vec2u"
+										],
+										["cx", "cy"]
+									],
+									"sum"
+								]
+							]
+						]]
+					]
+				]],
+				"externalNames": [
+					"hLayout",
+					"std",
+					"d",
+					"computeWidth",
+					"computeHeight",
+					"PASSTHROUGH_THRESHOLD",
+					"jitterTaps",
+					"HALF_KERNEL",
+					"invHalf"
+				]
+			},
+			externals: () => ({
+				hLayout,
+				std: std_exports,
+				d: data_exports,
+				computeWidth,
+				computeHeight,
+				PASSTHROUGH_THRESHOLD,
+				jitterTaps,
+				HALF_KERNEL,
+				invHalf
+			})
+		}) && $.f)({})).$name("variableBlurH"),
+		kernelV: src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+			"use gpu";
+			const blurRadius = textureLoad(vLayout.$.blurMap, vec2u(cx, cy)).r;
+			if (blurRadius < PASSTHROUGH_THRESHOLD) {
+				const texel = textureLoad(vLayout.$.src, vec2u(cx, cy));
+				textureStore(vLayout.$.output, vec2u(cx, cy), texel);
+			} else {
+				const yi = i32(cy);
+				const radiusComputeY = __tsover_div(blurRadius, vLayout.$.params.scaleY);
+				const jitterV = jitterTaps ? __tsover_sub(fract(__tsover_mul(52.9829189, fract(__tsover_add(__tsover_mul(f32(cx), .00583715), __tsover_mul(f32(cy), .06711056))))), .5) : f32(0);
+				let sum = vec4f(0, 0, 0, 0);
+				for (let i = -HALF_KERNEL; i <= HALF_KERNEL; i++) {
+					const offset = __tsover_mul(__tsover_mul(__tsover_add(f32(i), jitterV), invHalf), radiusComputeY);
+					const sampleY = clamp(__tsover_add(yi, i32(round(offset))), 0, __tsover_sub(computeHeight, 1));
+					const texel = textureLoad(vLayout.$.src, vec2u(cx, u32(sampleY)));
+					sum = sum.add(texel.mul(vLayout.$.weights[__tsover_add(i, HALF_KERNEL)]));
+				}
+				textureStore(vLayout.$.output, vec2u(cx, cy), sum);
+			}
+		}), {
+			v: 1,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "cx"
+				}, {
+					"type": "i",
+					"name": "cy"
+				}],
+				"body": [0, [[
+					13,
+					"blurRadius",
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								"std",
+								"textureLoad"
+							],
+							[[
+								7,
+								[
+									7,
+									"vLayout",
+									"$"
+								],
+								"blurMap"
+							], [
+								6,
+								[
+									7,
+									"d",
+									"vec2u"
+								],
+								["cx", "cy"]
+							]]
+						],
+						"r"
+					]
+				], [
+					11,
+					[
+						1,
+						"blurRadius",
+						"<",
+						"PASSTHROUGH_THRESHOLD"
+					],
+					[0, [[
+						13,
+						"texel",
+						[
+							6,
+							[
+								7,
+								"std",
+								"textureLoad"
+							],
+							[[
+								7,
+								[
+									7,
+									"vLayout",
+									"$"
+								],
+								"src"
+							], [
+								6,
+								[
+									7,
+									"d",
+									"vec2u"
+								],
+								["cx", "cy"]
+							]]
+						]
+					], [
+						6,
+						[
+							7,
+							"std",
+							"textureStore"
+						],
+						[
+							[
+								7,
+								[
+									7,
+									"vLayout",
+									"$"
+								],
+								"output"
+							],
+							[
+								6,
+								[
+									7,
+									"d",
+									"vec2u"
+								],
+								["cx", "cy"]
+							],
+							"texel"
+						]
+					]]],
+					[0, [
+						[
+							13,
+							"yi",
+							[
+								6,
+								[
+									7,
+									"d",
+									"i32"
+								],
+								["cy"]
+							]
+						],
+						[
+							13,
+							"radiusComputeY",
+							[
+								1,
+								"blurRadius",
+								"/",
+								[
+									7,
+									[
+										7,
+										[
+											7,
+											"vLayout",
+											"$"
+										],
+										"params"
+									],
+									"scaleY"
+								]
+							]
+						],
+						[
+							13,
+							"jitterV",
+							[
+								105,
+								"jitterTaps",
+								[
+									1,
+									[
+										6,
+										[
+											7,
+											"std",
+											"fract"
+										],
+										[[
+											1,
+											[5, "52.9829189"],
+											"*",
+											[
+												6,
+												[
+													7,
+													"std",
+													"fract"
+												],
+												[[
+													1,
+													[
+														1,
+														[
+															6,
+															[
+																7,
+																"d",
+																"f32"
+															],
+															["cx"]
+														],
+														"*",
+														[5, "0.00583715"]
+													],
+													"+",
+													[
+														1,
+														[
+															6,
+															[
+																7,
+																"d",
+																"f32"
+															],
+															["cy"]
+														],
+														"*",
+														[5, "0.06711056"]
+													]
+												]]
+											]
+										]]
+									],
+									"-",
+									[5, "0.5"]
+								],
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									[[5, "0"]]
+								]
+							]
+						],
+						[
+							12,
+							"sum",
+							[
+								6,
+								[
+									7,
+									"d",
+									"vec4f"
+								],
+								[
+									[5, "0"],
+									[5, "0"],
+									[5, "0"],
+									[5, "0"]
+								]
+							]
+						],
+						[
+							14,
+							[
+								12,
+								"i",
+								[
+									4,
+									"-",
+									"HALF_KERNEL"
+								]
+							],
+							[
+								1,
+								"i",
+								"<=",
+								"HALF_KERNEL"
+							],
+							[
+								102,
+								"++",
+								"i"
+							],
+							[0, [
+								[
+									13,
+									"offset",
+									[
+										1,
+										[
+											1,
+											[
+												1,
+												[
+													6,
+													[
+														7,
+														"d",
+														"f32"
+													],
+													["i"]
+												],
+												"+",
+												"jitterV"
+											],
+											"*",
+											"invHalf"
+										],
+										"*",
+										"radiusComputeY"
+									]
+								],
+								[
+									13,
+									"sampleY",
+									[
+										6,
+										[
+											7,
+											"std",
+											"clamp"
+										],
+										[
+											[
+												1,
+												"yi",
+												"+",
+												[
+													6,
+													[
+														7,
+														"d",
+														"i32"
+													],
+													[[
+														6,
+														[
+															7,
+															"std",
+															"round"
+														],
+														["offset"]
+													]]
+												]
+											],
+											[5, "0"],
+											[
+												1,
+												"computeHeight",
+												"-",
+												[5, "1"]
+											]
+										]
+									]
+								],
+								[
+									13,
+									"texel",
+									[
+										6,
+										[
+											7,
+											"std",
+											"textureLoad"
+										],
+										[[
+											7,
+											[
+												7,
+												"vLayout",
+												"$"
+											],
+											"src"
+										], [
+											6,
+											[
+												7,
+												"d",
+												"vec2u"
+											],
+											["cx", [
+												6,
+												[
+													7,
+													"d",
+													"u32"
+												],
+												["sampleY"]
+											]]
+										]]
+									]
+								],
+								[
+									2,
+									"sum",
+									"=",
+									[
+										6,
+										[
+											7,
+											"sum",
+											"add"
+										],
+										[[
+											6,
+											[
+												7,
+												"texel",
+												"mul"
+											],
+											[[
+												8,
+												[
+													7,
+													[
+														7,
+														"vLayout",
+														"$"
+													],
+													"weights"
+												],
+												[
+													1,
+													"i",
+													"+",
+													"HALF_KERNEL"
+												]
+											]]
+										]]
+									]
+								]
+							]]
+						],
+						[
+							6,
+							[
+								7,
+								"std",
+								"textureStore"
+							],
+							[
+								[
+									7,
+									[
+										7,
+										"vLayout",
+										"$"
+									],
+									"output"
+								],
+								[
+									6,
+									[
+										7,
+										"d",
+										"vec2u"
+									],
+									["cx", "cy"]
+								],
+								"sum"
+							]
+						]
+					]]
+				]]],
+				"externalNames": [
+					"std",
+					"vLayout",
+					"d",
+					"PASSTHROUGH_THRESHOLD",
+					"jitterTaps",
+					"HALF_KERNEL",
+					"invHalf",
+					"computeHeight"
+				]
+			},
+			externals: () => ({
+				std: std_exports,
+				vLayout,
+				d: data_exports,
+				PASSTHROUGH_THRESHOLD,
+				jitterTaps,
+				HALF_KERNEL,
+				invHalf,
+				computeHeight
+			})
+		}) && $.f)({})).$name("variableBlurV"),
+		HParams,
+		VParams,
+		KERNEL_SIZE
+	};
+}
+function createVariableGaussianBlurCompute(root, inputTexture, inputWidth, inputHeight, onCleanup, halfKernel = DEFAULT_HALF_KERNEL, computeWidth = DEFAULT_COMPUTE_WIDTH, computeHeight = 640, options) {
+	const HALF_KERNEL = halfKernel;
+	const graph = buildVariableBlurGraph(halfKernel, computeWidth, computeHeight, options?.jitterTaps === true);
+	const { hLayout, vLayout, kernelH, kernelV, KERNEL_SIZE } = graph;
+	const blurMapTex = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
+		size: [computeWidth, computeHeight],
+		format: BLUR_MAP_FORMAT
+	}).$usage("storage"), "blurMapTex");
+	const intermediateTex = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
+		size: [computeWidth, computeHeight],
+		format: INTERMEDIATE_FORMAT
+	}).$usage("storage"), "intermediateTex");
+	const outputTex = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
+		size: [computeWidth, computeHeight],
+		format: OUTPUT_FORMAT
+	}).$usage("storage", "sampled"), "outputTex");
+	const weightsBuf = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createBuffer(arrayOf(f32, KERNEL_SIZE)).$usage("storage"), "weightsBuf");
+	weightsBuf.write(buildFixedWeights(HALF_KERNEL));
+	const paramsH = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(graph.HParams), "paramsH");
+	const paramsV = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(graph.VParams), "paramsV");
+	paramsH.write({
+		inputWidth,
+		inputHeight
+	});
+	paramsV.write({ scaleY: inputHeight / computeHeight });
+	onCleanup(() => {
+		blurMapTex.destroy();
+		intermediateTex.destroy();
+		outputTex.destroy();
+	});
+	const vBindGroup = root.createBindGroup(vLayout, {
+		blurMap: blurMapTex,
+		src: intermediateTex,
+		output: outputTex,
+		weights: weightsBuf,
+		params: paramsV.buffer
+	});
+	const hPipeline = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+		"use gpu";
+		kernelH(cx, cy);
+	}), {
+		v: 1,
+		name: void 0,
+		ast: {
+			"params": [{
+				"type": "i",
+				"name": "cx"
+			}, {
+				"type": "i",
+				"name": "cy"
+			}],
+			"body": [0, [[
+				6,
+				"kernelH",
+				["cx", "cy"]
+			]]],
+			"externalNames": ["kernelH"]
+		},
+		externals: () => ({ kernelH })
+	}) && $.f)({}), { size: [computeWidth, computeHeight] });
+	const computeSteps = [hPipeline, createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+		"use gpu";
+		kernelV(cx, cy);
+	}), {
+		v: 1,
+		name: void 0,
+		ast: {
+			"params": [{
+				"type": "i",
+				"name": "cx"
+			}, {
+				"type": "i",
+				"name": "cy"
+			}],
+			"body": [0, [[
+				6,
+				"kernelV",
+				["cx", "cy"]
+			]]],
+			"externalNames": ["kernelV"]
+		},
+		externals: () => ({ kernelV })
+	}) && $.f)({}), {
+		size: [computeWidth, computeHeight],
+		bindGroup: vBindGroup
+	})];
+	function setInputTexture(input) {
+		const hBindGroup = root.createBindGroup(hLayout, {
+			blurMap: blurMapTex,
+			input,
+			intermediate: intermediateTex,
+			weights: weightsBuf,
+			params: paramsH.buffer
+		});
+		computeSteps[0] = hPipeline.with(hBindGroup);
+	}
+	if (inputTexture != null) setInputTexture(inputTexture);
+	return {
+		computeSteps,
+		outputTexture: outputTex,
+		blurMapTexture: blurMapTex,
+		computeWidth,
+		computeHeight,
+		setInputTexture,
+		setInputDimensions: (newW, newH) => {
+			paramsH.patch({
+				inputWidth: newW,
+				inputHeight: newH
+			});
+			paramsV.patch({ scaleY: newH / computeHeight });
+		}
+	};
+}
+export { createVariableGaussianBlurCompute as a, createGaussianBlurCompute as i, DEFAULT_COMPUTE_HEIGHT as n, DEFAULT_COMPUTE_WIDTH as r, BLUR_MAP_FORMAT as t };