shaders 3.0.442 → 3.0.443

package/dist/core/BokehBlur-yYb03spN.js

@@ -0,0 +1,3509 @@
+import { Bt as call, G as DEFAULT_COMPUTE_WIDTH, J as std, Rt as ZERO, W as DEFAULT_COMPUTE_HEIGHT, X as createGuardedCompute, bn as d, n as tgpu, rn as unpremultiplyAlpha } from "./coords-0A7CojvN.js";
+import { r as transformAngle } from "./transformations-P50Uo_Ju.js";
+var GOLDEN_ANGLE = Math.PI * (3 - Math.sqrt(5));
+var TWO_PI = Math.PI * 2;
+var DEG_TO_RAD = Math.PI / 180;
+const RADIUS_SCALE = .8;
+const radiusToPixels = (radius) => radius * RADIUS_SCALE;
+var HIGHLIGHT_KNEE = .35;
+var EDGE_BOOST = .6;
+var EDGE_POWER = 8;
+var RIM_BAND = .25;
+var PASSTHROUGH_RADIUS = .5;
+var OUTPUT_FORMAT = "rgba16float";
+const TAP_COUNT = 100;
+const BOKEH_SHAPES = [
+	"blades",
+	"circle",
+	"star",
+	"heart",
+	"flower",
+	"cross",
+	"ring"
+];
+var resolvePoints = (bladeCount) => {
+	const n = Math.round(bladeCount);
+	return n >= 3 ? n : 5;
+};
+const bokehPolygonRadius = (theta, sides) => {
+	if (sides < 3) return 1;
+	const a = TWO_PI / sides;
+	const m = theta - a * Math.floor(theta / a + .5);
+	return Math.cos(a * .5) / Math.cos(m);
+};
+var SQRT2_OVER_4 = Math.SQRT2 / 4;
+var sdfHeart = (dx, dy) => {
+	const S = 1 / .75;
+	const px = Math.abs(dx) / S;
+	const py = -dy / S + .6;
+	if (px + py > 1) {
+		const ax = px - .25;
+		const ay = py - .75;
+		return (Math.hypot(ax, ay) - SQRT2_OVER_4) * S;
+	}
+	const b1y = py - 1;
+	const dot1 = px * px + b1y * b1y;
+	const m = Math.max(px + py, 0) * .5;
+	const b2x = px - m;
+	const b2y = py - m;
+	return Math.sqrt(Math.min(dot1, b2x * b2x + b2y * b2y)) * Math.sign(px - py) * S;
+};
+var sdfStar = (dx, dy, sides, innerRatio) => {
+	const len = Math.hypot(dx, dy);
+	const angle = Math.atan2(dy, dx);
+	const sector = TWO_PI / sides;
+	const bn = angle - Math.floor(angle / sector + .5) * sector;
+	const fpx = Math.abs(len * Math.sin(bn));
+	const fpy = len * Math.cos(bn);
+	const an = Math.PI / sides;
+	const ex = innerRatio * Math.sin(an);
+	const ey = innerRatio * Math.cos(an) - 1;
+	const qx = fpx;
+	const qy = fpy - 1;
+	const t = Math.min(Math.max((qx * ex + qy * ey) / (ex * ex + ey * ey), 0), 1);
+	const nx = fpx - ex * t;
+	const ny = fpy - (1 + ey * t);
+	return Math.hypot(nx, ny) * Math.sign(ex * qy - ey * qx);
+};
+var sdfFlower = (dx, dy, sides, innerRatio) => {
+	const angle = Math.atan2(dy, dx);
+	const len = Math.hypot(dx, dy);
+	const tAngle = angle * sides / TWO_PI;
+	const tFrac = tAngle - Math.floor(tAngle);
+	const t = Math.abs(tFrac * 2 - 1);
+	return len - (innerRatio + (1 - innerRatio) * t);
+};
+var CROSS_SIZE = .92;
+var CROSS_THICKNESS = .3;
+var CROSS_ROUNDING = .08;
+var sdfCross = (dx, dy) => {
+	const px = Math.abs(dx);
+	const py = Math.abs(dy);
+	const dHoriz = Math.max(px - CROSS_SIZE, py - CROSS_THICKNESS);
+	const dVert = Math.max(py - CROSS_SIZE, px - CROSS_THICKNESS);
+	return Math.min(dHoriz, dVert) - CROSS_ROUNDING;
+};
+var RING_CENTERLINE = .72;
+var RING_HALF_WIDTH = .28;
+var sdfRing = (dx, dy) => Math.abs(Math.hypot(dx, dy) - RING_CENTERLINE) - RING_HALF_WIDTH;
+var halton = (index, base) => {
+	let f = 1;
+	let r = 0;
+	let i = index;
+	while (i > 0) {
+		f /= base;
+		r += f * (i % base);
+		i = Math.floor(i / base);
+	}
+	return r;
+};
+var toTipUp = (x, y) => [-y, x];
+function generateBokehTaps(shape, bladeCount, tapCount) {
+	const taps = [];
+	if (shape !== "star" && shape !== "heart" && shape !== "flower" && shape !== "cross" && shape !== "ring") {
+		const sides = shape === "circle" ? 0 : bladeCount;
+		for (let i = 0; i < tapCount; i++) {
+			const t = (i + .5) / tapCount;
+			const rNorm = Math.sqrt(t);
+			const theta = i * GOLDEN_ANGLE;
+			const r = rNorm * bokehPolygonRadius(theta, sides);
+			taps.push({
+				x: -Math.cos(theta) * r,
+				y: -Math.sin(theta) * r,
+				rim: 1 + EDGE_BOOST * Math.pow(rNorm, EDGE_POWER)
+			});
+		}
+		return taps;
+	}
+	const points = resolvePoints(bladeCount);
+	const sdf = shape === "star" ? (x, y) => {
+		const [rx, ry] = toTipUp(x, y);
+		return sdfStar(rx, ry, points, .5);
+	} : shape === "flower" ? (x, y) => {
+		const [rx, ry] = toTipUp(x, y);
+		return sdfFlower(rx, ry, points, .55);
+	} : shape === "heart" ? sdfHeart : shape === "cross" ? sdfCross : sdfRing;
+	const MAX_CANDIDATES = 2e4;
+	for (let idx = 1; taps.length < tapCount && idx <= MAX_CANDIDATES; idx++) {
+		const x = halton(idx, 2) * 2 - 1;
+		const y = halton(idx, 3) * 2 - 1;
+		const dist = sdf(x, y);
+		if (dist > 0) continue;
+		const prox = Math.min(Math.max(1 + dist / RIM_BAND, 0), 1);
+		taps.push({
+			x: -x,
+			y: -y,
+			rim: 1 + EDGE_BOOST * prox * prox
+		});
+	}
+	if (taps.length === 0) return generateBokehTaps("circle", 0, tapCount);
+	for (let i = 0; taps.length < tapCount; i++) taps.push(taps[i % taps.length]);
+	const maxLen = taps.reduce((max, tap) => Math.max(max, Math.hypot(tap.x, tap.y)), 0);
+	if (maxLen > 1) {
+		const inv = 1 / maxLen;
+		for (const tap of taps) {
+			tap.x *= inv;
+			tap.y *= inv;
+		}
+	}
+	return taps;
+}
+function bokehParams() {
+	return d.struct({
+		radius: d.f32,
+		highlightGain: d.f32,
+		highlightThreshold: d.f32,
+		rotCos: d.f32,
+		rotSin: d.f32,
+		chromaticFringe: d.f32,
+		inputWidth: d.f32,
+		inputHeight: d.f32
+	});
+}
+function bokehMapParams() {
+	return d.struct({
+		highlightGain: d.f32,
+		highlightThreshold: d.f32,
+		rotCos: d.f32,
+		rotSin: d.f32,
+		chromaticFringe: d.f32,
+		inputWidth: d.f32,
+		inputHeight: d.f32,
+		inputMin: d.f32,
+		inputMax: d.f32,
+		outputMin: d.f32,
+		outputMax: d.f32,
+		curve: d.f32
+	});
+}
+function buildBokehGraph(computeWidth, computeHeight, tapCount) {
+	const TAPS = tapCount;
+	const Params = bokehParams();
+	const TapArray = d.arrayOf(d.vec4f, TAPS);
+	const layout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+		input: { texture: d.texture2d(d.f32) },
+		output: { storageTexture: d.textureStorage2d(OUTPUT_FORMAT, "write-only") },
+		params: { uniform: Params },
+		taps: { uniform: TapArray }
+	}), "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 radius = p.radius;
+			const inputCx = __tsover_sub(__tsover_div(__tsover_mul(__tsover_add(d.f32(cx), .5), p.inputWidth), computeWidth), .5);
+			const inputCy = __tsover_sub(__tsover_div(__tsover_mul(__tsover_add(d.f32(cy), .5), p.inputHeight), computeHeight), .5);
+			const inputWm1 = d.i32(__tsover_sub(p.inputWidth, 1));
+			const inputHm1 = d.i32(__tsover_sub(p.inputHeight, 1));
+			if (radius < PASSTHROUGH_RADIUS) {
+				const sx = std.clamp(d.i32(std.round(inputCx)), 0, inputWm1);
+				const sy = std.clamp(d.i32(std.round(inputCy)), 0, inputHm1);
+				const texel = std.textureLoad(layout.$.input, d.vec2u(d.u32(sx), d.u32(sy)), 0);
+				std.textureStore(layout.$.output, d.vec2u(cx, cy), texel);
+			} else {
+				const gain = p.highlightGain;
+				const threshold = p.highlightThreshold;
+				const fringe = p.chromaticFringe;
+				const rotC = p.rotCos;
+				const rotS = p.rotSin;
+				let accum = d.vec3f(0, 0, 0);
+				let alphaAccum = d.f32(0);
+				let wSum = d.f32(0);
+				for (let i = 0; i < TAPS; i++) {
+					const tap = layout.$.taps[i];
+					const ox = __tsover_sub(__tsover_mul(tap.x, rotC), __tsover_mul(tap.y, rotS));
+					const oy = __tsover_add(__tsover_mul(tap.x, rotS), __tsover_mul(tap.y, rotC));
+					const off = d.vec2f(__tsover_mul(ox, radius), __tsover_mul(oy, radius));
+					const sx = std.clamp(d.i32(std.round(__tsover_add(inputCx, off.x))), 0, inputWm1);
+					const sy = std.clamp(d.i32(std.round(__tsover_add(inputCy, off.y))), 0, inputHm1);
+					const base = std.textureLoad(layout.$.input, d.vec2u(d.u32(sx), d.u32(sy)), 0);
+					let colR = base.x;
+					let colB = base.z;
+					if (fringe > .001) {
+						const offR = off.mul(__tsover_add(1, __tsover_mul(fringe, .5)));
+						const rx = std.clamp(d.i32(std.round(__tsover_add(inputCx, offR.x))), 0, inputWm1);
+						const ry = std.clamp(d.i32(std.round(__tsover_add(inputCy, offR.y))), 0, inputHm1);
+						colR = std.textureLoad(layout.$.input, d.vec2u(d.u32(rx), d.u32(ry)), 0).x;
+						const offB = off.mul(__tsover_sub(1, __tsover_mul(fringe, .5)));
+						const bx = std.clamp(d.i32(std.round(__tsover_add(inputCx, offB.x))), 0, inputWm1);
+						const by = std.clamp(d.i32(std.round(__tsover_add(inputCy, offB.y))), 0, inputHm1);
+						colB = std.textureLoad(layout.$.input, d.vec2u(d.u32(bx), d.u32(by)), 0).z;
+					}
+					const col = d.vec3f(colR, base.y, colB);
+					const lum = std.dot(base.xyz, d.vec3f(.2126, .7152, .0722));
+					const hi = std.smoothstep(threshold, __tsover_add(threshold, HIGHLIGHT_KNEE), lum);
+					const w = __tsover_mul(__tsover_add(1, __tsover_mul(__tsover_mul(gain, hi), hi)), tap.z);
+					accum = accum.add(col.mul(w));
+					alphaAccum = __tsover_add(alphaAccum, __tsover_mul(base.w, w));
+					wSum = __tsover_add(wSum, w);
+				}
+				const invW = __tsover_div(1, std.max(wSum, 1e-4));
+				std.textureStore(layout.$.output, d.vec2u(cx, cy), d.vec4f(accum.mul(invW), __tsover_mul(alphaAccum, invW)));
+			}
+		}), {
+			v: 1,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "cx"
+				}, {
+					"type": "i",
+					"name": "cy"
+				}],
+				"body": [0, [
+					[
+						13,
+						"p",
+						[
+							7,
+							[
+								7,
+								"layout",
+								"$"
+							],
+							"params"
+						]
+					],
+					[
+						13,
+						"radius",
+						[
+							7,
+							"p",
+							"radius"
+						]
+					],
+					[
+						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"]
+							]]
+						]
+					],
+					[
+						11,
+						[
+							1,
+							"radius",
+							"<",
+							"PASSTHROUGH_RADIUS"
+						],
+						[0, [
+							[
+								13,
+								"sx",
+								[
+									6,
+									[
+										7,
+										"std",
+										"clamp"
+									],
+									[
+										[
+											6,
+											[
+												7,
+												"d",
+												"i32"
+											],
+											[[
+												6,
+												[
+													7,
+													"std",
+													"round"
+												],
+												["inputCx"]
+											]]
+										],
+										[5, "0"],
+										"inputWm1"
+									]
+								]
+							],
+							[
+								13,
+								"sy",
+								[
+									6,
+									[
+										7,
+										"std",
+										"clamp"
+									],
+									[
+										[
+											6,
+											[
+												7,
+												"d",
+												"i32"
+											],
+											[[
+												6,
+												[
+													7,
+													"std",
+													"round"
+												],
+												["inputCy"]
+											]]
+										],
+										[5, "0"],
+										"inputHm1"
+									]
+								]
+							],
+							[
+								13,
+								"texel",
+								[
+									6,
+									[
+										7,
+										"std",
+										"textureLoad"
+									],
+									[
+										[
+											7,
+											[
+												7,
+												"layout",
+												"$"
+											],
+											"input"
+										],
+										[
+											6,
+											[
+												7,
+												"d",
+												"vec2u"
+											],
+											[[
+												6,
+												[
+													7,
+													"d",
+													"u32"
+												],
+												["sx"]
+											], [
+												6,
+												[
+													7,
+													"d",
+													"u32"
+												],
+												["sy"]
+											]]
+										],
+										[5, "0"]
+									]
+								]
+							],
+							[
+								6,
+								[
+									7,
+									"std",
+									"textureStore"
+								],
+								[
+									[
+										7,
+										[
+											7,
+											"layout",
+											"$"
+										],
+										"output"
+									],
+									[
+										6,
+										[
+											7,
+											"d",
+											"vec2u"
+										],
+										["cx", "cy"]
+									],
+									"texel"
+								]
+							]
+						]],
+						[0, [
+							[
+								13,
+								"gain",
+								[
+									7,
+									"p",
+									"highlightGain"
+								]
+							],
+							[
+								13,
+								"threshold",
+								[
+									7,
+									"p",
+									"highlightThreshold"
+								]
+							],
+							[
+								13,
+								"fringe",
+								[
+									7,
+									"p",
+									"chromaticFringe"
+								]
+							],
+							[
+								13,
+								"rotC",
+								[
+									7,
+									"p",
+									"rotCos"
+								]
+							],
+							[
+								13,
+								"rotS",
+								[
+									7,
+									"p",
+									"rotSin"
+								]
+							],
+							[
+								12,
+								"accum",
+								[
+									6,
+									[
+										7,
+										"d",
+										"vec3f"
+									],
+									[
+										[5, "0"],
+										[5, "0"],
+										[5, "0"]
+									]
+								]
+							],
+							[
+								12,
+								"alphaAccum",
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									[[5, "0"]]
+								]
+							],
+							[
+								12,
+								"wSum",
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									[[5, "0"]]
+								]
+							],
+							[
+								14,
+								[
+									12,
+									"i",
+									[5, "0"]
+								],
+								[
+									1,
+									"i",
+									"<",
+									"TAPS"
+								],
+								[
+									102,
+									"++",
+									"i"
+								],
+								[0, [
+									[
+										13,
+										"tap",
+										[
+											8,
+											[
+												7,
+												[
+													7,
+													"layout",
+													"$"
+												],
+												"taps"
+											],
+											"i"
+										]
+									],
+									[
+										13,
+										"ox",
+										[
+											1,
+											[
+												1,
+												[
+													7,
+													"tap",
+													"x"
+												],
+												"*",
+												"rotC"
+											],
+											"-",
+											[
+												1,
+												[
+													7,
+													"tap",
+													"y"
+												],
+												"*",
+												"rotS"
+											]
+										]
+									],
+									[
+										13,
+										"oy",
+										[
+											1,
+											[
+												1,
+												[
+													7,
+													"tap",
+													"x"
+												],
+												"*",
+												"rotS"
+											],
+											"+",
+											[
+												1,
+												[
+													7,
+													"tap",
+													"y"
+												],
+												"*",
+												"rotC"
+											]
+										]
+									],
+									[
+										13,
+										"off",
+										[
+											6,
+											[
+												7,
+												"d",
+												"vec2f"
+											],
+											[[
+												1,
+												"ox",
+												"*",
+												"radius"
+											], [
+												1,
+												"oy",
+												"*",
+												"radius"
+											]]
+										]
+									],
+									[
+										13,
+										"sx",
+										[
+											6,
+											[
+												7,
+												"std",
+												"clamp"
+											],
+											[
+												[
+													6,
+													[
+														7,
+														"d",
+														"i32"
+													],
+													[[
+														6,
+														[
+															7,
+															"std",
+															"round"
+														],
+														[[
+															1,
+															"inputCx",
+															"+",
+															[
+																7,
+																"off",
+																"x"
+															]
+														]]
+													]]
+												],
+												[5, "0"],
+												"inputWm1"
+											]
+										]
+									],
+									[
+										13,
+										"sy",
+										[
+											6,
+											[
+												7,
+												"std",
+												"clamp"
+											],
+											[
+												[
+													6,
+													[
+														7,
+														"d",
+														"i32"
+													],
+													[[
+														6,
+														[
+															7,
+															"std",
+															"round"
+														],
+														[[
+															1,
+															"inputCy",
+															"+",
+															[
+																7,
+																"off",
+																"y"
+															]
+														]]
+													]]
+												],
+												[5, "0"],
+												"inputHm1"
+											]
+										]
+									],
+									[
+										13,
+										"base",
+										[
+											6,
+											[
+												7,
+												"std",
+												"textureLoad"
+											],
+											[
+												[
+													7,
+													[
+														7,
+														"layout",
+														"$"
+													],
+													"input"
+												],
+												[
+													6,
+													[
+														7,
+														"d",
+														"vec2u"
+													],
+													[[
+														6,
+														[
+															7,
+															"d",
+															"u32"
+														],
+														["sx"]
+													], [
+														6,
+														[
+															7,
+															"d",
+															"u32"
+														],
+														["sy"]
+													]]
+												],
+												[5, "0"]
+											]
+										]
+									],
+									[
+										12,
+										"colR",
+										[
+											7,
+											"base",
+											"x"
+										]
+									],
+									[
+										12,
+										"colB",
+										[
+											7,
+											"base",
+											"z"
+										]
+									],
+									[
+										11,
+										[
+											1,
+											"fringe",
+											">",
+											[5, "0.001"]
+										],
+										[0, [
+											[
+												13,
+												"offR",
+												[
+													6,
+													[
+														7,
+														"off",
+														"mul"
+													],
+													[[
+														1,
+														[5, "1"],
+														"+",
+														[
+															1,
+															"fringe",
+															"*",
+															[5, "0.5"]
+														]
+													]]
+												]
+											],
+											[
+												13,
+												"rx",
+												[
+													6,
+													[
+														7,
+														"std",
+														"clamp"
+													],
+													[
+														[
+															6,
+															[
+																7,
+																"d",
+																"i32"
+															],
+															[[
+																6,
+																[
+																	7,
+																	"std",
+																	"round"
+																],
+																[[
+																	1,
+																	"inputCx",
+																	"+",
+																	[
+																		7,
+																		"offR",
+																		"x"
+																	]
+																]]
+															]]
+														],
+														[5, "0"],
+														"inputWm1"
+													]
+												]
+											],
+											[
+												13,
+												"ry",
+												[
+													6,
+													[
+														7,
+														"std",
+														"clamp"
+													],
+													[
+														[
+															6,
+															[
+																7,
+																"d",
+																"i32"
+															],
+															[[
+																6,
+																[
+																	7,
+																	"std",
+																	"round"
+																],
+																[[
+																	1,
+																	"inputCy",
+																	"+",
+																	[
+																		7,
+																		"offR",
+																		"y"
+																	]
+																]]
+															]]
+														],
+														[5, "0"],
+														"inputHm1"
+													]
+												]
+											],
+											[
+												2,
+												"colR",
+												"=",
+												[
+													7,
+													[
+														6,
+														[
+															7,
+															"std",
+															"textureLoad"
+														],
+														[
+															[
+																7,
+																[
+																	7,
+																	"layout",
+																	"$"
+																],
+																"input"
+															],
+															[
+																6,
+																[
+																	7,
+																	"d",
+																	"vec2u"
+																],
+																[[
+																	6,
+																	[
+																		7,
+																		"d",
+																		"u32"
+																	],
+																	["rx"]
+																], [
+																	6,
+																	[
+																		7,
+																		"d",
+																		"u32"
+																	],
+																	["ry"]
+																]]
+															],
+															[5, "0"]
+														]
+													],
+													"x"
+												]
+											],
+											[
+												13,
+												"offB",
+												[
+													6,
+													[
+														7,
+														"off",
+														"mul"
+													],
+													[[
+														1,
+														[5, "1"],
+														"-",
+														[
+															1,
+															"fringe",
+															"*",
+															[5, "0.5"]
+														]
+													]]
+												]
+											],
+											[
+												13,
+												"bx",
+												[
+													6,
+													[
+														7,
+														"std",
+														"clamp"
+													],
+													[
+														[
+															6,
+															[
+																7,
+																"d",
+																"i32"
+															],
+															[[
+																6,
+																[
+																	7,
+																	"std",
+																	"round"
+																],
+																[[
+																	1,
+																	"inputCx",
+																	"+",
+																	[
+																		7,
+																		"offB",
+																		"x"
+																	]
+																]]
+															]]
+														],
+														[5, "0"],
+														"inputWm1"
+													]
+												]
+											],
+											[
+												13,
+												"by",
+												[
+													6,
+													[
+														7,
+														"std",
+														"clamp"
+													],
+													[
+														[
+															6,
+															[
+																7,
+																"d",
+																"i32"
+															],
+															[[
+																6,
+																[
+																	7,
+																	"std",
+																	"round"
+																],
+																[[
+																	1,
+																	"inputCy",
+																	"+",
+																	[
+																		7,
+																		"offB",
+																		"y"
+																	]
+																]]
+															]]
+														],
+														[5, "0"],
+														"inputHm1"
+													]
+												]
+											],
+											[
+												2,
+												"colB",
+												"=",
+												[
+													7,
+													[
+														6,
+														[
+															7,
+															"std",
+															"textureLoad"
+														],
+														[
+															[
+																7,
+																[
+																	7,
+																	"layout",
+																	"$"
+																],
+																"input"
+															],
+															[
+																6,
+																[
+																	7,
+																	"d",
+																	"vec2u"
+																],
+																[[
+																	6,
+																	[
+																		7,
+																		"d",
+																		"u32"
+																	],
+																	["bx"]
+																], [
+																	6,
+																	[
+																		7,
+																		"d",
+																		"u32"
+																	],
+																	["by"]
+																]]
+															],
+															[5, "0"]
+														]
+													],
+													"z"
+												]
+											]
+										]]
+									],
+									[
+										13,
+										"col",
+										[
+											6,
+											[
+												7,
+												"d",
+												"vec3f"
+											],
+											[
+												"colR",
+												[
+													7,
+													"base",
+													"y"
+												],
+												"colB"
+											]
+										]
+									],
+									[
+										13,
+										"lum",
+										[
+											6,
+											[
+												7,
+												"std",
+												"dot"
+											],
+											[[
+												7,
+												"base",
+												"xyz"
+											], [
+												6,
+												[
+													7,
+													"d",
+													"vec3f"
+												],
+												[
+													[5, "0.2126"],
+													[5, "0.7152"],
+													[5, "0.0722"]
+												]
+											]]
+										]
+									],
+									[
+										13,
+										"hi",
+										[
+											6,
+											[
+												7,
+												"std",
+												"smoothstep"
+											],
+											[
+												"threshold",
+												[
+													1,
+													"threshold",
+													"+",
+													"HIGHLIGHT_KNEE"
+												],
+												"lum"
+											]
+										]
+									],
+									[
+										13,
+										"w",
+										[
+											1,
+											[
+												1,
+												[5, "1"],
+												"+",
+												[
+													1,
+													[
+														1,
+														"gain",
+														"*",
+														"hi"
+													],
+													"*",
+													"hi"
+												]
+											],
+											"*",
+											[
+												7,
+												"tap",
+												"z"
+											]
+										]
+									],
+									[
+										2,
+										"accum",
+										"=",
+										[
+											6,
+											[
+												7,
+												"accum",
+												"add"
+											],
+											[[
+												6,
+												[
+													7,
+													"col",
+													"mul"
+												],
+												["w"]
+											]]
+										]
+									],
+									[
+										2,
+										"alphaAccum",
+										"=",
+										[
+											1,
+											"alphaAccum",
+											"+",
+											[
+												1,
+												[
+													7,
+													"base",
+													"w"
+												],
+												"*",
+												"w"
+											]
+										]
+									],
+									[
+										2,
+										"wSum",
+										"=",
+										[
+											1,
+											"wSum",
+											"+",
+											"w"
+										]
+									]
+								]]
+							],
+							[
+								13,
+								"invW",
+								[
+									1,
+									[5, "1"],
+									"/",
+									[
+										6,
+										[
+											7,
+											"std",
+											"max"
+										],
+										["wSum", [5, "0.0001"]]
+									]
+								]
+							],
+							[
+								6,
+								[
+									7,
+									"std",
+									"textureStore"
+								],
+								[
+									[
+										7,
+										[
+											7,
+											"layout",
+											"$"
+										],
+										"output"
+									],
+									[
+										6,
+										[
+											7,
+											"d",
+											"vec2u"
+										],
+										["cx", "cy"]
+									],
+									[
+										6,
+										[
+											7,
+											"d",
+											"vec4f"
+										],
+										[[
+											6,
+											[
+												7,
+												"accum",
+												"mul"
+											],
+											["invW"]
+										], [
+											1,
+											"alphaAccum",
+											"*",
+											"invW"
+										]]
+									]
+								]
+							]
+						]]
+					]
+				]],
+				"externalNames": [
+					"layout",
+					"d",
+					"computeWidth",
+					"computeHeight",
+					"PASSTHROUGH_RADIUS",
+					"std",
+					"TAPS",
+					"HIGHLIGHT_KNEE"
+				]
+			},
+			externals: () => ({
+				layout,
+				d,
+				computeWidth,
+				computeHeight,
+				PASSTHROUGH_RADIUS,
+				std,
+				TAPS,
+				HIGHLIGHT_KNEE
+			})
+		}) && $.f)({})).$name("bokehGather"),
+		Params,
+		TapArray
+	};
+}
+function buildBokehMapGraph(computeWidth, computeHeight, tapCount, channel) {
+	const TAPS = tapCount;
+	const Params = bokehMapParams();
+	const TapArray = d.arrayOf(d.vec4f, TAPS);
+	const layout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+		input: { texture: d.texture2d(d.f32) },
+		source: { texture: d.texture2d(d.f32) },
+		output: { storageTexture: d.textureStorage2d(OUTPUT_FORMAT, "write-only") },
+		params: { uniform: Params },
+		taps: { uniform: TapArray }
+	}), "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 inputCx = __tsover_sub(__tsover_div(__tsover_mul(__tsover_add(d.f32(cx), .5), p.inputWidth), computeWidth), .5);
+			const inputCy = __tsover_sub(__tsover_div(__tsover_mul(__tsover_add(d.f32(cy), .5), p.inputHeight), computeHeight), .5);
+			const inputWm1 = d.i32(__tsover_sub(p.inputWidth, 1));
+			const inputHm1 = d.i32(__tsover_sub(p.inputHeight, 1));
+			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, p.inputWidth))), 0, inputWm1);
+			const srcY = std.clamp(d.i32(std.round(__tsover_mul(v, p.inputHeight))), 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 = __tsover_mul(std.mix(p.outputMin, p.outputMax, eased), .8);
+			if (radius < PASSTHROUGH_RADIUS) {
+				const sx = std.clamp(d.i32(std.round(inputCx)), 0, inputWm1);
+				const sy = std.clamp(d.i32(std.round(inputCy)), 0, inputHm1);
+				const texel = std.textureLoad(layout.$.input, d.vec2u(d.u32(sx), d.u32(sy)), 0);
+				std.textureStore(layout.$.output, d.vec2u(cx, cy), texel);
+			} else {
+				const gain = p.highlightGain;
+				const threshold = p.highlightThreshold;
+				const fringe = p.chromaticFringe;
+				const rotC = p.rotCos;
+				const rotS = p.rotSin;
+				let accum = d.vec3f(0, 0, 0);
+				let alphaAccum = d.f32(0);
+				let wSum = d.f32(0);
+				for (let i = 0; i < TAPS; i++) {
+					const tap = layout.$.taps[i];
+					const ox = __tsover_sub(__tsover_mul(tap.x, rotC), __tsover_mul(tap.y, rotS));
+					const oy = __tsover_add(__tsover_mul(tap.x, rotS), __tsover_mul(tap.y, rotC));
+					const off = d.vec2f(__tsover_mul(ox, radius), __tsover_mul(oy, radius));
+					const sx = std.clamp(d.i32(std.round(__tsover_add(inputCx, off.x))), 0, inputWm1);
+					const sy = std.clamp(d.i32(std.round(__tsover_add(inputCy, off.y))), 0, inputHm1);
+					const base = std.textureLoad(layout.$.input, d.vec2u(d.u32(sx), d.u32(sy)), 0);
+					let colR = base.x;
+					let colB = base.z;
+					if (fringe > .001) {
+						const offR = off.mul(__tsover_add(1, __tsover_mul(fringe, .5)));
+						const rx = std.clamp(d.i32(std.round(__tsover_add(inputCx, offR.x))), 0, inputWm1);
+						const ry = std.clamp(d.i32(std.round(__tsover_add(inputCy, offR.y))), 0, inputHm1);
+						colR = std.textureLoad(layout.$.input, d.vec2u(d.u32(rx), d.u32(ry)), 0).x;
+						const offB = off.mul(__tsover_sub(1, __tsover_mul(fringe, .5)));
+						const bx = std.clamp(d.i32(std.round(__tsover_add(inputCx, offB.x))), 0, inputWm1);
+						const by = std.clamp(d.i32(std.round(__tsover_add(inputCy, offB.y))), 0, inputHm1);
+						colB = std.textureLoad(layout.$.input, d.vec2u(d.u32(bx), d.u32(by)), 0).z;
+					}
+					const col = d.vec3f(colR, base.y, colB);
+					const lum = std.dot(base.xyz, d.vec3f(.2126, .7152, .0722));
+					const hi = std.smoothstep(threshold, __tsover_add(threshold, HIGHLIGHT_KNEE), lum);
+					const w = __tsover_mul(__tsover_add(1, __tsover_mul(__tsover_mul(gain, hi), hi)), tap.z);
+					accum = accum.add(col.mul(w));
+					alphaAccum = __tsover_add(alphaAccum, __tsover_mul(base.w, w));
+					wSum = __tsover_add(wSum, w);
+				}
+				const invW = __tsover_div(1, std.max(wSum, 1e-4));
+				std.textureStore(layout.$.output, d.vec2u(cx, cy), d.vec4f(accum.mul(invW), __tsover_mul(alphaAccum, invW)));
+			}
+		}), {
+			v: 1,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "cx"
+				}, {
+					"type": "i",
+					"name": "cy"
+				}],
+				"body": [0, [
+					[
+						13,
+						"p",
+						[
+							7,
+							[
+								7,
+								"layout",
+								"$"
+							],
+							"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,
+						"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",
+											"*",
+											[
+												7,
+												"p",
+												"inputWidth"
+											]
+										]]
+									]]
+								],
+								[5, "0"],
+								"inputWm1"
+							]
+						]
+					],
+					[
+						13,
+						"srcY",
+						[
+							6,
+							[
+								7,
+								"std",
+								"clamp"
+							],
+							[
+								[
+									6,
+									[
+										7,
+										"d",
+										"i32"
+									],
+									[[
+										6,
+										[
+											7,
+											"std",
+											"round"
+										],
+										[[
+											1,
+											"v",
+											"*",
+											[
+												7,
+												"p",
+												"inputHeight"
+											]
+										]]
+									]]
+								],
+								[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",
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"std",
+									"mix"
+								],
+								[
+									[
+										7,
+										"p",
+										"outputMin"
+									],
+									[
+										7,
+										"p",
+										"outputMax"
+									],
+									"eased"
+								]
+							],
+							"*",
+							"RADIUS_SCALE"
+						]
+					],
+					[
+						11,
+						[
+							1,
+							"radius",
+							"<",
+							"PASSTHROUGH_RADIUS"
+						],
+						[0, [
+							[
+								13,
+								"sx",
+								[
+									6,
+									[
+										7,
+										"std",
+										"clamp"
+									],
+									[
+										[
+											6,
+											[
+												7,
+												"d",
+												"i32"
+											],
+											[[
+												6,
+												[
+													7,
+													"std",
+													"round"
+												],
+												["inputCx"]
+											]]
+										],
+										[5, "0"],
+										"inputWm1"
+									]
+								]
+							],
+							[
+								13,
+								"sy",
+								[
+									6,
+									[
+										7,
+										"std",
+										"clamp"
+									],
+									[
+										[
+											6,
+											[
+												7,
+												"d",
+												"i32"
+											],
+											[[
+												6,
+												[
+													7,
+													"std",
+													"round"
+												],
+												["inputCy"]
+											]]
+										],
+										[5, "0"],
+										"inputHm1"
+									]
+								]
+							],
+							[
+								13,
+								"texel",
+								[
+									6,
+									[
+										7,
+										"std",
+										"textureLoad"
+									],
+									[
+										[
+											7,
+											[
+												7,
+												"layout",
+												"$"
+											],
+											"input"
+										],
+										[
+											6,
+											[
+												7,
+												"d",
+												"vec2u"
+											],
+											[[
+												6,
+												[
+													7,
+													"d",
+													"u32"
+												],
+												["sx"]
+											], [
+												6,
+												[
+													7,
+													"d",
+													"u32"
+												],
+												["sy"]
+											]]
+										],
+										[5, "0"]
+									]
+								]
+							],
+							[
+								6,
+								[
+									7,
+									"std",
+									"textureStore"
+								],
+								[
+									[
+										7,
+										[
+											7,
+											"layout",
+											"$"
+										],
+										"output"
+									],
+									[
+										6,
+										[
+											7,
+											"d",
+											"vec2u"
+										],
+										["cx", "cy"]
+									],
+									"texel"
+								]
+							]
+						]],
+						[0, [
+							[
+								13,
+								"gain",
+								[
+									7,
+									"p",
+									"highlightGain"
+								]
+							],
+							[
+								13,
+								"threshold",
+								[
+									7,
+									"p",
+									"highlightThreshold"
+								]
+							],
+							[
+								13,
+								"fringe",
+								[
+									7,
+									"p",
+									"chromaticFringe"
+								]
+							],
+							[
+								13,
+								"rotC",
+								[
+									7,
+									"p",
+									"rotCos"
+								]
+							],
+							[
+								13,
+								"rotS",
+								[
+									7,
+									"p",
+									"rotSin"
+								]
+							],
+							[
+								12,
+								"accum",
+								[
+									6,
+									[
+										7,
+										"d",
+										"vec3f"
+									],
+									[
+										[5, "0"],
+										[5, "0"],
+										[5, "0"]
+									]
+								]
+							],
+							[
+								12,
+								"alphaAccum",
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									[[5, "0"]]
+								]
+							],
+							[
+								12,
+								"wSum",
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									[[5, "0"]]
+								]
+							],
+							[
+								14,
+								[
+									12,
+									"i",
+									[5, "0"]
+								],
+								[
+									1,
+									"i",
+									"<",
+									"TAPS"
+								],
+								[
+									102,
+									"++",
+									"i"
+								],
+								[0, [
+									[
+										13,
+										"tap",
+										[
+											8,
+											[
+												7,
+												[
+													7,
+													"layout",
+													"$"
+												],
+												"taps"
+											],
+											"i"
+										]
+									],
+									[
+										13,
+										"ox",
+										[
+											1,
+											[
+												1,
+												[
+													7,
+													"tap",
+													"x"
+												],
+												"*",
+												"rotC"
+											],
+											"-",
+											[
+												1,
+												[
+													7,
+													"tap",
+													"y"
+												],
+												"*",
+												"rotS"
+											]
+										]
+									],
+									[
+										13,
+										"oy",
+										[
+											1,
+											[
+												1,
+												[
+													7,
+													"tap",
+													"x"
+												],
+												"*",
+												"rotS"
+											],
+											"+",
+											[
+												1,
+												[
+													7,
+													"tap",
+													"y"
+												],
+												"*",
+												"rotC"
+											]
+										]
+									],
+									[
+										13,
+										"off",
+										[
+											6,
+											[
+												7,
+												"d",
+												"vec2f"
+											],
+											[[
+												1,
+												"ox",
+												"*",
+												"radius"
+											], [
+												1,
+												"oy",
+												"*",
+												"radius"
+											]]
+										]
+									],
+									[
+										13,
+										"sx",
+										[
+											6,
+											[
+												7,
+												"std",
+												"clamp"
+											],
+											[
+												[
+													6,
+													[
+														7,
+														"d",
+														"i32"
+													],
+													[[
+														6,
+														[
+															7,
+															"std",
+															"round"
+														],
+														[[
+															1,
+															"inputCx",
+															"+",
+															[
+																7,
+																"off",
+																"x"
+															]
+														]]
+													]]
+												],
+												[5, "0"],
+												"inputWm1"
+											]
+										]
+									],
+									[
+										13,
+										"sy",
+										[
+											6,
+											[
+												7,
+												"std",
+												"clamp"
+											],
+											[
+												[
+													6,
+													[
+														7,
+														"d",
+														"i32"
+													],
+													[[
+														6,
+														[
+															7,
+															"std",
+															"round"
+														],
+														[[
+															1,
+															"inputCy",
+															"+",
+															[
+																7,
+																"off",
+																"y"
+															]
+														]]
+													]]
+												],
+												[5, "0"],
+												"inputHm1"
+											]
+										]
+									],
+									[
+										13,
+										"base",
+										[
+											6,
+											[
+												7,
+												"std",
+												"textureLoad"
+											],
+											[
+												[
+													7,
+													[
+														7,
+														"layout",
+														"$"
+													],
+													"input"
+												],
+												[
+													6,
+													[
+														7,
+														"d",
+														"vec2u"
+													],
+													[[
+														6,
+														[
+															7,
+															"d",
+															"u32"
+														],
+														["sx"]
+													], [
+														6,
+														[
+															7,
+															"d",
+															"u32"
+														],
+														["sy"]
+													]]
+												],
+												[5, "0"]
+											]
+										]
+									],
+									[
+										12,
+										"colR",
+										[
+											7,
+											"base",
+											"x"
+										]
+									],
+									[
+										12,
+										"colB",
+										[
+											7,
+											"base",
+											"z"
+										]
+									],
+									[
+										11,
+										[
+											1,
+											"fringe",
+											">",
+											[5, "0.001"]
+										],
+										[0, [
+											[
+												13,
+												"offR",
+												[
+													6,
+													[
+														7,
+														"off",
+														"mul"
+													],
+													[[
+														1,
+														[5, "1"],
+														"+",
+														[
+															1,
+															"fringe",
+															"*",
+															[5, "0.5"]
+														]
+													]]
+												]
+											],
+											[
+												13,
+												"rx",
+												[
+													6,
+													[
+														7,
+														"std",
+														"clamp"
+													],
+													[
+														[
+															6,
+															[
+																7,
+																"d",
+																"i32"
+															],
+															[[
+																6,
+																[
+																	7,
+																	"std",
+																	"round"
+																],
+																[[
+																	1,
+																	"inputCx",
+																	"+",
+																	[
+																		7,
+																		"offR",
+																		"x"
+																	]
+																]]
+															]]
+														],
+														[5, "0"],
+														"inputWm1"
+													]
+												]
+											],
+											[
+												13,
+												"ry",
+												[
+													6,
+													[
+														7,
+														"std",
+														"clamp"
+													],
+													[
+														[
+															6,
+															[
+																7,
+																"d",
+																"i32"
+															],
+															[[
+																6,
+																[
+																	7,
+																	"std",
+																	"round"
+																],
+																[[
+																	1,
+																	"inputCy",
+																	"+",
+																	[
+																		7,
+																		"offR",
+																		"y"
+																	]
+																]]
+															]]
+														],
+														[5, "0"],
+														"inputHm1"
+													]
+												]
+											],
+											[
+												2,
+												"colR",
+												"=",
+												[
+													7,
+													[
+														6,
+														[
+															7,
+															"std",
+															"textureLoad"
+														],
+														[
+															[
+																7,
+																[
+																	7,
+																	"layout",
+																	"$"
+																],
+																"input"
+															],
+															[
+																6,
+																[
+																	7,
+																	"d",
+																	"vec2u"
+																],
+																[[
+																	6,
+																	[
+																		7,
+																		"d",
+																		"u32"
+																	],
+																	["rx"]
+																], [
+																	6,
+																	[
+																		7,
+																		"d",
+																		"u32"
+																	],
+																	["ry"]
+																]]
+															],
+															[5, "0"]
+														]
+													],
+													"x"
+												]
+											],
+											[
+												13,
+												"offB",
+												[
+													6,
+													[
+														7,
+														"off",
+														"mul"
+													],
+													[[
+														1,
+														[5, "1"],
+														"-",
+														[
+															1,
+															"fringe",
+															"*",
+															[5, "0.5"]
+														]
+													]]
+												]
+											],
+											[
+												13,
+												"bx",
+												[
+													6,
+													[
+														7,
+														"std",
+														"clamp"
+													],
+													[
+														[
+															6,
+															[
+																7,
+																"d",
+																"i32"
+															],
+															[[
+																6,
+																[
+																	7,
+																	"std",
+																	"round"
+																],
+																[[
+																	1,
+																	"inputCx",
+																	"+",
+																	[
+																		7,
+																		"offB",
+																		"x"
+																	]
+																]]
+															]]
+														],
+														[5, "0"],
+														"inputWm1"
+													]
+												]
+											],
+											[
+												13,
+												"by",
+												[
+													6,
+													[
+														7,
+														"std",
+														"clamp"
+													],
+													[
+														[
+															6,
+															[
+																7,
+																"d",
+																"i32"
+															],
+															[[
+																6,
+																[
+																	7,
+																	"std",
+																	"round"
+																],
+																[[
+																	1,
+																	"inputCy",
+																	"+",
+																	[
+																		7,
+																		"offB",
+																		"y"
+																	]
+																]]
+															]]
+														],
+														[5, "0"],
+														"inputHm1"
+													]
+												]
+											],
+											[
+												2,
+												"colB",
+												"=",
+												[
+													7,
+													[
+														6,
+														[
+															7,
+															"std",
+															"textureLoad"
+														],
+														[
+															[
+																7,
+																[
+																	7,
+																	"layout",
+																	"$"
+																],
+																"input"
+															],
+															[
+																6,
+																[
+																	7,
+																	"d",
+																	"vec2u"
+																],
+																[[
+																	6,
+																	[
+																		7,
+																		"d",
+																		"u32"
+																	],
+																	["bx"]
+																], [
+																	6,
+																	[
+																		7,
+																		"d",
+																		"u32"
+																	],
+																	["by"]
+																]]
+															],
+															[5, "0"]
+														]
+													],
+													"z"
+												]
+											]
+										]]
+									],
+									[
+										13,
+										"col",
+										[
+											6,
+											[
+												7,
+												"d",
+												"vec3f"
+											],
+											[
+												"colR",
+												[
+													7,
+													"base",
+													"y"
+												],
+												"colB"
+											]
+										]
+									],
+									[
+										13,
+										"lum",
+										[
+											6,
+											[
+												7,
+												"std",
+												"dot"
+											],
+											[[
+												7,
+												"base",
+												"xyz"
+											], [
+												6,
+												[
+													7,
+													"d",
+													"vec3f"
+												],
+												[
+													[5, "0.2126"],
+													[5, "0.7152"],
+													[5, "0.0722"]
+												]
+											]]
+										]
+									],
+									[
+										13,
+										"hi",
+										[
+											6,
+											[
+												7,
+												"std",
+												"smoothstep"
+											],
+											[
+												"threshold",
+												[
+													1,
+													"threshold",
+													"+",
+													"HIGHLIGHT_KNEE"
+												],
+												"lum"
+											]
+										]
+									],
+									[
+										13,
+										"w",
+										[
+											1,
+											[
+												1,
+												[5, "1"],
+												"+",
+												[
+													1,
+													[
+														1,
+														"gain",
+														"*",
+														"hi"
+													],
+													"*",
+													"hi"
+												]
+											],
+											"*",
+											[
+												7,
+												"tap",
+												"z"
+											]
+										]
+									],
+									[
+										2,
+										"accum",
+										"=",
+										[
+											6,
+											[
+												7,
+												"accum",
+												"add"
+											],
+											[[
+												6,
+												[
+													7,
+													"col",
+													"mul"
+												],
+												["w"]
+											]]
+										]
+									],
+									[
+										2,
+										"alphaAccum",
+										"=",
+										[
+											1,
+											"alphaAccum",
+											"+",
+											[
+												1,
+												[
+													7,
+													"base",
+													"w"
+												],
+												"*",
+												"w"
+											]
+										]
+									],
+									[
+										2,
+										"wSum",
+										"=",
+										[
+											1,
+											"wSum",
+											"+",
+											"w"
+										]
+									]
+								]]
+							],
+							[
+								13,
+								"invW",
+								[
+									1,
+									[5, "1"],
+									"/",
+									[
+										6,
+										[
+											7,
+											"std",
+											"max"
+										],
+										["wSum", [5, "0.0001"]]
+									]
+								]
+							],
+							[
+								6,
+								[
+									7,
+									"std",
+									"textureStore"
+								],
+								[
+									[
+										7,
+										[
+											7,
+											"layout",
+											"$"
+										],
+										"output"
+									],
+									[
+										6,
+										[
+											7,
+											"d",
+											"vec2u"
+										],
+										["cx", "cy"]
+									],
+									[
+										6,
+										[
+											7,
+											"d",
+											"vec4f"
+										],
+										[[
+											6,
+											[
+												7,
+												"accum",
+												"mul"
+											],
+											["invW"]
+										], [
+											1,
+											"alphaAccum",
+											"*",
+											"invW"
+										]]
+									]
+								]
+							]
+						]]
+					]
+				]],
+				"externalNames": [
+					"layout",
+					"d",
+					"computeWidth",
+					"computeHeight",
+					"std",
+					"channel",
+					"RADIUS_SCALE",
+					"PASSTHROUGH_RADIUS",
+					"TAPS",
+					"HIGHLIGHT_KNEE"
+				]
+			},
+			externals: () => ({
+				layout,
+				d,
+				computeWidth,
+				computeHeight,
+				std,
+				channel,
+				RADIUS_SCALE: .8,
+				PASSTHROUGH_RADIUS,
+				TAPS,
+				HIGHLIGHT_KNEE
+			})
+		}) && $.f)({})).$name("bokehGatherVariable"),
+		Params,
+		TapArray
+	};
+}
+const componentDefinition = {
+	name: "BokehBlur",
+	boundingBoxDeclaration: { aspectRatio: null },
+	category: "Blurs",
+	description: "Photographic lens blur where bright highlights bloom into aperture-shaped discs",
+	requiresRTT: true,
+	requiresChild: true,
+	props: {
+		radius: {
+			default: 50,
+			description: "Defocus amount — how far the lens blur spreads",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 100,
+				step: 1,
+				label: "Radius",
+				group: "Effect"
+			}
+		},
+		highlightGain: {
+			default: 4,
+			description: "How strongly bright highlights bloom into discs",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 10,
+				step: .1,
+				label: "Highlight Bloom",
+				group: "Highlights"
+			}
+		},
+		highlightThreshold: {
+			default: .6,
+			description: "Brightness above which a highlight forms a disc",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Highlight Threshold",
+				group: "Highlights"
+			}
+		},
+		bladeShape: {
+			default: "blades",
+			description: "Aperture shape the highlights bloom into — bladed iris or a novelty cut-out (heart, star, …)",
+			ui: {
+				type: "select",
+				options: [
+					{
+						label: "Blades",
+						value: "blades"
+					},
+					{
+						label: "Circle",
+						value: "circle"
+					},
+					{
+						label: "Star",
+						value: "star"
+					},
+					{
+						label: "Heart",
+						value: "heart"
+					},
+					{
+						label: "Flower",
+						value: "flower"
+					},
+					{
+						label: "Cross",
+						value: "cross"
+					},
+					{
+						label: "Ring",
+						value: "ring"
+					}
+				],
+				label: "Blade Shape",
+				group: "Aperture"
+			}
+		},
+		bladeCount: {
+			default: 6,
+			description: "Blade or point count for the Blades, Star and Flower shapes — 0–2 blades is a circular iris",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 9,
+				step: 1,
+				label: "Aperture Blades",
+				group: "Aperture"
+			}
+		},
+		bladeRotation: {
+			default: 0,
+			transform: transformAngle,
+			description: "Rotation of the aperture shape (in degrees)",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Blade Rotation",
+				group: "Aperture"
+			}
+		},
+		chromaticFringe: {
+			default: .2,
+			description: "Lens colour fringing on the disc edges",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Chromatic Fringe",
+				group: "Aperture"
+			}
+		}
+	},
+	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 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 outputTex = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
+			size: [computeWidth, computeHeight],
+			format: OUTPUT_FORMAT
+		}).$usage("storage", "sampled"), "outputTex");
+		onCleanup(() => outputTex.destroy());
+		const blurredTexture = registerComputeTexture(outputTex);
+		onResize(({ width, height }) => {
+			curWidth = Math.max(1, Math.round(width));
+			curHeight = Math.max(1, Math.round(height));
+		});
+		const readLook = () => {
+			const rot = (getCpuValue("bladeRotation") ?? 0) * DEG_TO_RAD;
+			return {
+				highlightGain: getCpuValue("highlightGain") ?? 4,
+				highlightThreshold: getCpuValue("highlightThreshold") ?? .6,
+				rotCos: Math.cos(rot),
+				rotSin: Math.sin(rot),
+				chromaticFringe: getCpuValue("chromaticFringe") ?? .2
+			};
+		};
+		const makeTapWriter = (tapsUniform$1) => {
+			let key = "";
+			return () => {
+				const shape = getCpuValue("bladeShape") ?? "blades";
+				const count = getCpuValue("bladeCount") ?? 6;
+				const next = `${shape}|${count}`;
+				if (next === key) return;
+				key = next;
+				tapsUniform$1.write(generateBokehTaps(shape, count, 100).map((tap) => d.vec4f(tap.x, tap.y, tap.rim, 0)));
+			};
+		};
+		const mapInfo = getMapInfo("radius");
+		if (mapInfo) {
+			const graph$1 = buildBokehMapGraph(computeWidth, computeHeight, 100, mapInfo.channel);
+			const kernelParams$1 = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(graph$1.Params), "kernelParams");
+			const tapsUniform$1 = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(graph$1.TapArray), "tapsUniform");
+			const ensureTaps$1 = makeTapWriter(tapsUniform$1);
+			let bokehPass$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: { 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, {
+						input: src.texture,
+						source: mapSrc.texture,
+						output: outputTex,
+						params: kernelParams$1.buffer,
+						taps: tapsUniform$1.buffer
+					});
+					bokehPass$1 = bokehPass$1.with(bindGroup);
+				},
+				getComputeNodes: () => {
+					ensureTaps$1();
+					const w = mapInfo.window();
+					kernelParams$1.write({
+						...readLook(),
+						inputWidth: curWidth,
+						inputHeight: curHeight,
+						inputMin: w.inputMin,
+						inputMax: w.inputMax,
+						outputMin: w.outputMin,
+						outputMax: w.outputMax,
+						curve: w.curve
+					});
+					return [bokehPass$1];
+				}
+			};
+		}
+		const graph = buildBokehGraph(computeWidth, computeHeight, 100);
+		const kernelParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(graph.Params), "kernelParams");
+		const tapsUniform = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(graph.TapArray), "tapsUniform");
+		const ensureTaps = makeTapWriter(tapsUniform);
+		let bokehPass = 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: { blurredTexture },
+			bindInputs: (resolve) => {
+				const src = resolve(childTexture.key);
+				if (!src) return;
+				const bindGroup = root.createBindGroup(graph.layout, {
+					input: src.texture,
+					output: outputTex,
+					params: kernelParams.buffer,
+					taps: tapsUniform.buffer
+				});
+				bokehPass = bokehPass.with(bindGroup);
+			},
+			getComputeNodes: () => {
+				ensureTaps();
+				const radius = getCpuValue("radius") ?? 50;
+				kernelParams.write({
+					radius: radiusToPixels(radius),
+					...readLook(),
+					inputWidth: curWidth,
+					inputHeight: curHeight
+				});
+				return [bokehPass];
+			}
+		};
+	},
+	fragment: ({ childNode, computeOutputs, ctx, convertToTexture }) => {
+		if (!childNode) return ZERO;
+		const blurred = computeOutputs?.blurredTexture;
+		if (!blurred) return call(unpremultiplyAlpha, "unpremultiplyAlpha", [convertToTexture(childNode).sample(ctx.uv)]);
+		return call(unpremultiplyAlpha, "unpremultiplyAlpha", [blurred.sample(ctx.uv)]);
+	}
+};
+var BokehBlur_default = componentDefinition;
+export { bokehPolygonRadius as a, componentDefinition as c, TAP_COUNT as i, generateBokehTaps as l, BokehBlur_default as n, buildBokehGraph as o, RADIUS_SCALE as r, buildBokehMapGraph as s, BOKEH_SHAPES as t, radiusToPixels as u };