shaders 2.5.134 → 3.0.436

package/dist/core/Glow-CfBRrrll.js

@@ -0,0 +1,2052 @@
+import { At as call, B as createGuardedCompute, F as DEFAULT_COMPUTE_WIDTH, L as createVariableGaussianBlurCompute, N as BLUR_MAP_FORMAT, Ot as ZERO, P as DEFAULT_COMPUTE_HEIGHT, R as std, Wt as unpremultiplyAlpha, n as tgpu, on as d } from "./coords-BxHv8WrA.js";
+var BRIGHT_FORMAT = "rgba16float";
+const glowCompose = tgpu.fn([
+	d.vec4f,
+	d.vec4f,
+	d.f32
+], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((original, bloom, intensity) => {
+	"use gpu";
+	const finalColor = original.xyz.add(bloom.xyz.mul(intensity));
+	const glowAlpha = std.clamp(__tsover_mul(bloom.w, intensity), 0, 1);
+	const finalAlpha = __tsover_add(original.w, __tsover_mul(glowAlpha, __tsover_sub(1, original.w)));
+	return d.vec4f(finalColor, finalAlpha);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "original"
+			},
+			{
+				"type": "i",
+				"name": "bloom"
+			},
+			{
+				"type": "i",
+				"name": "intensity"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"finalColor",
+				[
+					6,
+					[
+						7,
+						[
+							7,
+							"original",
+							"xyz"
+						],
+						"add"
+					],
+					[[
+						6,
+						[
+							7,
+							[
+								7,
+								"bloom",
+								"xyz"
+							],
+							"mul"
+						],
+						["intensity"]
+					]]
+				]
+			],
+			[
+				13,
+				"glowAlpha",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								7,
+								"bloom",
+								"w"
+							],
+							"*",
+							"intensity"
+						],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"finalAlpha",
+				[
+					1,
+					[
+						7,
+						"original",
+						"w"
+					],
+					"+",
+					[
+						1,
+						"glowAlpha",
+						"*",
+						[
+							1,
+							[5, "1"],
+							"-",
+							[
+								7,
+								"original",
+								"w"
+							]
+						]
+					]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"d",
+					"vec4f"
+				],
+				["finalColor", "finalAlpha"]
+			]]
+		]],
+		"externalNames": ["std", "d"]
+	},
+	externals: () => ({
+		std,
+		d
+	})
+}) && $.f)({})).$name("glowCompose");
+function glowPrepassParams() {
+	return d.struct({
+		threshold: d.f32,
+		size: d.f32,
+		inputWidth: d.f32,
+		inputHeight: d.f32
+	});
+}
+function glowPrepassMapParams() {
+	return d.struct({
+		threshold: d.f32,
+		inputWidth: d.f32,
+		inputHeight: d.f32,
+		inputMin: d.f32,
+		inputMax: d.f32,
+		outputMin: d.f32,
+		outputMax: d.f32,
+		curve: d.f32
+	});
+}
+function buildGlowPrepassGraph(computeWidth, computeHeight) {
+	const Params = glowPrepassParams();
+	const layout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+		childTexture: { texture: d.texture2d(d.f32) },
+		brightMap: { storageTexture: d.textureStorage2d(BRIGHT_FORMAT, "write-only") },
+		blurMap: { storageTexture: d.textureStorage2d(BLUR_MAP_FORMAT, "write-only") },
+		params: { uniform: Params }
+	}), "layout");
+	return {
+		layout,
+		kernel: tgpu.fn([d.u32, d.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 inputWm1 = d.i32(__tsover_sub(iw, 1));
+			const inputHm1 = d.i32(__tsover_sub(ih, 1));
+			let sample = d.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(d.f32(cx), __tsover_div(__tsover_add(d.f32(tx), .5), 4)), computeWidth);
+				const sv = __tsover_div(__tsover_add(d.f32(cy), __tsover_div(__tsover_add(d.f32(ty), .5), 4)), computeHeight);
+				const sx = std.clamp(d.i32(__tsover_mul(su, iw)), 0, inputWm1);
+				const sy = std.clamp(d.i32(__tsover_mul(sv, ih)), 0, inputHm1);
+				sample = sample.add(std.textureLoad(layout.$.childTexture, d.vec2u(d.u32(sx), d.u32(sy)), 0));
+			}
+			sample = sample.mul(.0625);
+			const threshold = p.threshold;
+			const knee = __tsover_add(__tsover_mul(threshold, .5), 1e-4);
+			const lum = std.dot(sample.xyz, d.vec3f(.2126, .7152, .0722));
+			const soft = std.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(std.max(softCurve, __tsover_sub(lum, threshold)), std.max(lum, 1e-4));
+			std.textureStore(layout.$.brightMap, d.vec2u(cx, cy), d.vec4f(sample.xyz.mul(mask), __tsover_mul(sample.w, mask)));
+			std.textureStore(layout.$.blurMap, d.vec2u(cx, cy), d.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,
+						"iw",
+						[
+							7,
+							"p",
+							"inputWidth"
+						]
+					],
+					[
+						13,
+						"ih",
+						[
+							7,
+							"p",
+							"inputHeight"
+						]
+					],
+					[
+						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"]
+											]
+										],
+										"/",
+										"computeWidth"
+									]
+								],
+								[
+									13,
+									"sv",
+									[
+										1,
+										[
+											1,
+											[
+												6,
+												[
+													7,
+													"d",
+													"f32"
+												],
+												["cy"]
+											],
+											"+",
+											[
+												1,
+												[
+													1,
+													[
+														6,
+														[
+															7,
+															"d",
+															"f32"
+														],
+														["ty"]
+													],
+													"+",
+													[5, "0.5"]
+												],
+												"/",
+												[5, "4"]
+											]
+										],
+										"/",
+										"computeHeight"
+									]
+								],
+								[
+									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"
+											],
+											[
+												[
+													7,
+													[
+														7,
+														"layout",
+														"$"
+													],
+													"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,
+						"threshold",
+						[
+							7,
+							"p",
+							"threshold"
+						]
+					],
+					[
+						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"]]
+							]
+						]
+					],
+					[
+						6,
+						[
+							7,
+							"std",
+							"textureStore"
+						],
+						[
+							[
+								7,
+								[
+									7,
+									"layout",
+									"$"
+								],
+								"brightMap"
+							],
+							[
+								6,
+								[
+									7,
+									"d",
+									"vec2u"
+								],
+								["cx", "cy"]
+							],
+							[
+								6,
+								[
+									7,
+									"d",
+									"vec4f"
+								],
+								[[
+									6,
+									[
+										7,
+										[
+											7,
+											"sample",
+											"xyz"
+										],
+										"mul"
+									],
+									["mask"]
+								], [
+									1,
+									[
+										7,
+										"sample",
+										"w"
+									],
+									"*",
+									"mask"
+								]]
+							]
+						]
+					],
+					[
+						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",
+					"d",
+					"computeWidth",
+					"computeHeight",
+					"std"
+				]
+			},
+			externals: () => ({
+				layout,
+				d,
+				computeWidth,
+				computeHeight,
+				std
+			})
+		}) && $.f)({})).$name("glowExtractAndFill"),
+		Params
+	};
+}
+function buildGlowPrepassMapGraph(computeWidth, computeHeight, channel) {
+	const Params = glowPrepassMapParams();
+	const layout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+		childTexture: { texture: d.texture2d(d.f32) },
+		source: { texture: d.texture2d(d.f32) },
+		brightMap: { storageTexture: d.textureStorage2d(BRIGHT_FORMAT, "write-only") },
+		blurMap: { storageTexture: d.textureStorage2d(BLUR_MAP_FORMAT, "write-only") },
+		params: { uniform: Params }
+	}), "layout");
+	return {
+		layout,
+		kernel: tgpu.fn([d.u32, d.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 inputWm1 = d.i32(__tsover_sub(iw, 1));
+			const inputHm1 = d.i32(__tsover_sub(ih, 1));
+			let sample = d.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(d.f32(cx), __tsover_div(__tsover_add(d.f32(tx), .5), 4)), computeWidth);
+				const sv = __tsover_div(__tsover_add(d.f32(cy), __tsover_div(__tsover_add(d.f32(ty), .5), 4)), computeHeight);
+				const sx = std.clamp(d.i32(__tsover_mul(su, iw)), 0, inputWm1);
+				const sy = std.clamp(d.i32(__tsover_mul(sv, ih)), 0, inputHm1);
+				sample = sample.add(std.textureLoad(layout.$.childTexture, d.vec2u(d.u32(sx), d.u32(sy)), 0));
+			}
+			sample = sample.mul(.0625);
+			const threshold = p.threshold;
+			const knee = __tsover_add(__tsover_mul(threshold, .5), 1e-4);
+			const lum = std.dot(sample.xyz, d.vec3f(.2126, .7152, .0722));
+			const soft = std.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(std.max(softCurve, __tsover_sub(lum, threshold)), std.max(lum, 1e-4));
+			std.textureStore(layout.$.brightMap, d.vec2u(cx, cy), d.vec4f(sample.xyz.mul(mask), __tsover_mul(sample.w, mask)));
+			const u = __tsover_div(__tsover_add(d.f32(cx), .5), computeWidth);
+			const v = __tsover_div(__tsover_add(d.f32(cy), .5), computeHeight);
+			const srcX = std.clamp(d.i32(std.round(__tsover_mul(u, iw))), 0, inputWm1);
+			const srcY = std.clamp(d.i32(std.round(__tsover_mul(v, ih))), 0, inputHm1);
+			const mapSample = std.textureLoad(layout.$.source, d.vec2u(d.u32(srcX), d.u32(srcY)), 0);
+			const raw = channel === "alpha" ? mapSample.w : channel === "alphaInverted" ? __tsover_sub(1, mapSample.w) : channel === "luminanceInverted" ? __tsover_sub(1, std.dot(mapSample.xyz, d.vec3f(.2126, .7152, .0722))) : std.dot(mapSample.xyz, d.vec3f(.2126, .7152, .0722));
+			const inputRange = std.max(__tsover_sub(p.inputMax, p.inputMin), 1e-4);
+			const normalised = std.clamp(__tsover_div(__tsover_sub(raw, p.inputMin), inputRange), 0, 1);
+			const exponent = std.pow(2, __tsover_mul(-p.curve, 2));
+			const eased = std.pow(normalised, exponent);
+			const radius = std.mix(p.outputMin, p.outputMax, eased);
+			std.textureStore(layout.$.blurMap, d.vec2u(cx, cy), d.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,
+						"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"]
+											]
+										],
+										"/",
+										"computeWidth"
+									]
+								],
+								[
+									13,
+									"sv",
+									[
+										1,
+										[
+											1,
+											[
+												6,
+												[
+													7,
+													"d",
+													"f32"
+												],
+												["cy"]
+											],
+											"+",
+											[
+												1,
+												[
+													1,
+													[
+														6,
+														[
+															7,
+															"d",
+															"f32"
+														],
+														["ty"]
+													],
+													"+",
+													[5, "0.5"]
+												],
+												"/",
+												[5, "4"]
+											]
+										],
+										"/",
+										"computeHeight"
+									]
+								],
+								[
+									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"
+											],
+											[
+												[
+													7,
+													[
+														7,
+														"layout",
+														"$"
+													],
+													"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,
+						"threshold",
+						[
+							7,
+							"p",
+							"threshold"
+						]
+					],
+					[
+						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"]]
+							]
+						]
+					],
+					[
+						6,
+						[
+							7,
+							"std",
+							"textureStore"
+						],
+						[
+							[
+								7,
+								[
+									7,
+									"layout",
+									"$"
+								],
+								"brightMap"
+							],
+							[
+								6,
+								[
+									7,
+									"d",
+									"vec2u"
+								],
+								["cx", "cy"]
+							],
+							[
+								6,
+								[
+									7,
+									"d",
+									"vec4f"
+								],
+								[[
+									6,
+									[
+										7,
+										[
+											7,
+											"sample",
+											"xyz"
+										],
+										"mul"
+									],
+									["mask"]
+								], [
+									1,
+									[
+										7,
+										"sample",
+										"w"
+									],
+									"*",
+									"mask"
+								]]
+							]
+						]
+					],
+					[
+						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"],
+								"inputWm1"
+							]
+						]
+					],
+					[
+						13,
+						"srcY",
+						[
+							6,
+							[
+								7,
+								"std",
+								"clamp"
+							],
+							[
+								[
+									6,
+									[
+										7,
+										"d",
+										"i32"
+									],
+									[[
+										6,
+										[
+											7,
+											"std",
+											"round"
+										],
+										[[
+											1,
+											"v",
+											"*",
+											"ih"
+										]]
+									]]
+								],
+								[5, "0"],
+								"inputHm1"
+							]
+						]
+					],
+					[
+						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,
+						"raw",
+						[
+							105,
+							[
+								1,
+								"channel",
+								"===",
+								[103, "alpha"]
+							],
+							[
+								7,
+								"mapSample",
+								"w"
+							],
+							[
+								105,
+								[
+									1,
+									"channel",
+									"===",
+									[103, "alphaInverted"]
+								],
+								[
+									1,
+									[5, "1"],
+									"-",
+									[
+										7,
+										"mapSample",
+										"w"
+									]
+								],
+								[
+									105,
+									[
+										1,
+										"channel",
+										"===",
+										[103, "luminanceInverted"]
+									],
+									[
+										1,
+										[5, "1"],
+										"-",
+										[
+											6,
+											[
+												7,
+												"std",
+												"dot"
+											],
+											[[
+												7,
+												"mapSample",
+												"xyz"
+											], [
+												6,
+												[
+													7,
+													"d",
+													"vec3f"
+												],
+												[
+													[5, "0.2126"],
+													[5, "0.7152"],
+													[5, "0.0722"]
+												]
+											]]
+										]
+									],
+									[
+										6,
+										[
+											7,
+											"std",
+											"dot"
+										],
+										[[
+											7,
+											"mapSample",
+											"xyz"
+										], [
+											6,
+											[
+												7,
+												"d",
+												"vec3f"
+											],
+											[
+												[5, "0.2126"],
+												[5, "0.7152"],
+												[5, "0.0722"]
+											]
+										]]
+									]
+								]
+							]
+						]
+					],
+					[
+						13,
+						"inputRange",
+						[
+							6,
+							[
+								7,
+								"std",
+								"max"
+							],
+							[[
+								1,
+								[
+									7,
+									"p",
+									"inputMax"
+								],
+								"-",
+								[
+									7,
+									"p",
+									"inputMin"
+								]
+							], [5, "0.0001"]]
+						]
+					],
+					[
+						13,
+						"normalised",
+						[
+							6,
+							[
+								7,
+								"std",
+								"clamp"
+							],
+							[
+								[
+									1,
+									[
+										1,
+										"raw",
+										"-",
+										[
+											7,
+											"p",
+											"inputMin"
+										]
+									],
+									"/",
+									"inputRange"
+								],
+								[5, "0"],
+								[5, "1"]
+							]
+						]
+					],
+					[
+						13,
+						"exponent",
+						[
+							6,
+							[
+								7,
+								"std",
+								"pow"
+							],
+							[[5, "2"], [
+								1,
+								[
+									4,
+									"-",
+									[
+										7,
+										"p",
+										"curve"
+									]
+								],
+								"*",
+								[5, "2"]
+							]]
+						]
+					],
+					[
+						13,
+						"eased",
+						[
+							6,
+							[
+								7,
+								"std",
+								"pow"
+							],
+							["normalised", "exponent"]
+						]
+					],
+					[
+						13,
+						"radius",
+						[
+							6,
+							[
+								7,
+								"std",
+								"mix"
+							],
+							[
+								[
+									7,
+									"p",
+									"outputMin"
+								],
+								[
+									7,
+									"p",
+									"outputMax"
+								],
+								"eased"
+							]
+						]
+					],
+					[
+						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",
+					"d",
+					"computeWidth",
+					"computeHeight",
+					"std",
+					"channel"
+				]
+			},
+			externals: () => ({
+				layout,
+				d,
+				computeWidth,
+				computeHeight,
+				std,
+				channel
+			})
+		}) && $.f)({})).$name("glowExtractAndFillVariable"),
+		Params
+	};
+}
+const componentDefinition = {
+	name: "Glow",
+	boundingBoxDeclaration: { aspectRatio: null },
+	category: "Stylize",
+	description: "Soft glow effect with adjustable intensity",
+	requiresRTT: true,
+	requiresChild: true,
+	props: {
+		intensity: {
+			default: 1,
+			description: "Glow intensity (brightness of the glow effect)",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 50,
+				step: .5,
+				label: "Intensity",
+				group: "Effect"
+			}
+		},
+		threshold: {
+			default: .5,
+			description: "Brightness threshold for glow extraction (lower = more glow)",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Threshold",
+				group: "Effect"
+			}
+		},
+		size: {
+			default: 25,
+			description: "Glow spread in pixels (clean up to ~72px, mild banding above)",
+			compileTimeWhen: (prev, next) => prev === 0 !== (next === 0),
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 100,
+				step: 1,
+				label: "Glow Size",
+				group: "Effect"
+			}
+		}
+	},
+	compute: (params) => {
+		const { childNode, gpu, convertToTexture, registerComputeTexture, getCpuValue, getMapInfo, onCleanup, onResize, dimensions } = params;
+		if (!childNode) return null;
+		const root = gpu?.root;
+		if (!root) return null;
+		const mapInfo = getMapInfo("size");
+		if (!mapInfo && (getCpuValue("size") ?? 0) === 0) return null;
+		const childTexture = convertToTexture(childNode);
+		let curWidth = Math.max(1, Math.round(dimensions.width));
+		let curHeight = Math.max(1, Math.round(dimensions.height));
+		const LONG_EDGE = Math.max(DEFAULT_COMPUTE_WIDTH, 640);
+		const aspect = curHeight > 0 ? curWidth / curHeight : 1;
+		const computeWidth = Math.max(8, aspect >= 1 ? LONG_EDGE : Math.round(LONG_EDGE * aspect));
+		const computeHeight = Math.max(8, aspect >= 1 ? Math.round(LONG_EDGE / aspect) : LONG_EDGE);
+		const brightBuffer = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
+			size: [computeWidth, computeHeight],
+			format: BRIGHT_FORMAT
+		}).$usage("storage", "sampled"), "brightBuffer");
+		onCleanup(() => brightBuffer.destroy());
+		const variable = createVariableGaussianBlurCompute(root, brightBuffer, computeWidth, computeHeight, onCleanup, void 0, computeWidth, computeHeight, { jitterTaps: true });
+		const blurredTexture = registerComputeTexture(variable.outputTexture);
+		onResize(({ width, height }) => {
+			curWidth = Math.max(1, Math.round(width));
+			curHeight = Math.max(1, Math.round(height));
+		});
+		if (mapInfo) {
+			const graph$1 = buildGlowPrepassMapGraph(computeWidth, computeHeight, mapInfo.channel);
+			const prepassParams$1 = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(graph$1.Params), "prepassParams");
+			let prepassStep$1 = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+				"use gpu";
+				graph$1.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: graph$1 })
+			}) && $.f)({}), { size: [computeWidth, computeHeight] });
+			return {
+				outputs: {
+					childTexture,
+					blurredTexture
+				},
+				bindInputs: (resolve) => {
+					const src = resolve(childTexture.key);
+					const mapSrc = resolve(mapInfo.sourceTexture.key);
+					if (!src || !mapSrc) return;
+					const bindGroup = root.createBindGroup(graph$1.layout, {
+						childTexture: src.texture,
+						source: mapSrc.texture,
+						brightMap: brightBuffer,
+						blurMap: variable.blurMapTexture,
+						params: prepassParams$1.buffer
+					});
+					prepassStep$1 = prepassStep$1.with(bindGroup);
+				},
+				getComputeNodes: () => {
+					const threshold = getCpuValue("threshold") ?? .5;
+					const w = mapInfo.window();
+					prepassParams$1.write({
+						threshold,
+						inputWidth: curWidth,
+						inputHeight: curHeight,
+						inputMin: w.inputMin,
+						inputMax: w.inputMax,
+						outputMin: w.outputMin,
+						outputMax: w.outputMax,
+						curve: w.curve
+					});
+					return [prepassStep$1, ...variable.computeSteps];
+				}
+			};
+		}
+		const graph = buildGlowPrepassGraph(computeWidth, computeHeight);
+		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: [computeWidth, computeHeight] });
+		return {
+			outputs: {
+				childTexture,
+				blurredTexture
+			},
+			bindInputs: (resolve) => {
+				const src = resolve(childTexture.key);
+				if (!src) return;
+				const bindGroup = root.createBindGroup(graph.layout, {
+					childTexture: src.texture,
+					brightMap: brightBuffer,
+					blurMap: variable.blurMapTexture,
+					params: prepassParams.buffer
+				});
+				prepassStep = prepassStep.with(bindGroup);
+			},
+			getComputeNodes: () => {
+				const threshold = getCpuValue("threshold") ?? .5;
+				const size = getCpuValue("size") ?? 25;
+				prepassParams.write({
+					threshold,
+					size,
+					inputWidth: curWidth,
+					inputHeight: curHeight
+				});
+				return [prepassStep, ...variable.computeSteps];
+			}
+		};
+	},
+	fragment: ({ childNode, computeOutputs, uniforms, ctx, convertToTexture }) => {
+		if (!childNode) return ZERO;
+		const bloom = computeOutputs?.blurredTexture;
+		const original = computeOutputs?.childTexture;
+		if (!bloom || !original) return call(unpremultiplyAlpha, "unpremultiplyAlpha", [convertToTexture(childNode).sample(ctx.uv)]);
+		return call(unpremultiplyAlpha, "unpremultiplyAlpha", [call(glowCompose, "glowCompose", [
+			original.sample(ctx.uv),
+			bloom.sample(ctx.uv),
+			uniforms.intensity
+		])]);
+	}
+};
+var Glow_default = componentDefinition;
+export { glowCompose as a, componentDefinition as i, buildGlowPrepassGraph as n, buildGlowPrepassMapGraph as r, Glow_default as t };