shaders 3.1.463 → 3.2.464

package/dist/core/BokehBlur-BzPuSJaC.js

@@ -1,2807 +0,0 @@
-import { Ft as vec3f, Gt as textureStorage2d, Kt as arrayOf, Lt as vec4f, Mt as vec2f, Ot as smoothstep, P as unpremultiplyAlpha, Pt as vec2u, Tt as round, Wt as texture2d, _t as max, cn as i32, ct as clamp, d as ZERO, dt as dot, et as typegpu_default, ln as u32, m as call, qt as struct, sn as f32 } from "./edges-CV-BHMpI.js";
-import { I as textureLoad, M as createGuardedCompute, R as textureStore } from "./device-DKcu50_C.js";
-import { s as TWO_PI$1, t as DEG_TO_RAD$1 } from "./constants-BKlzQFdJ.js";
-import { a as REMAP_WINDOW_FIELDS, f as mapSourceScalar, i as MAP_SOURCE_DIM_FIELDS, n as DEFAULT_COMPUTE_HEIGHT, o as applyRemapWindow, r as DEFAULT_COMPUTE_WIDTH } from "./blur-CXouokcq.js";
-import { r as transformAngle } from "./transformations-u-UZrXjj.js";
-var GOLDEN_ANGLE = Math.PI * (3 - Math.sqrt(5));
-var TWO_PI = TWO_PI$1;
-var DEG_TO_RAD = DEG_TO_RAD$1;
-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$1, tap) => Math.max(max$1, 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 struct({
-		radius: f32,
-		highlightGain: f32,
-		highlightThreshold: f32,
-		rotCos: f32,
-		rotSin: f32,
-		chromaticFringe: f32,
-		inputWidth: f32,
-		inputHeight: f32
-	});
-}
-function bokehMapParams() {
-	return struct({
-		highlightGain: f32,
-		highlightThreshold: f32,
-		rotCos: f32,
-		rotSin: f32,
-		chromaticFringe: f32,
-		...MAP_SOURCE_DIM_FIELDS,
-		...REMAP_WINDOW_FIELDS
-	});
-}
-function buildBokehGraph(computeWidth, computeHeight, tapCount) {
-	const TAPS = tapCount;
-	const Params = bokehParams();
-	const TapArray = arrayOf(vec4f, TAPS);
-	const layout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.bindGroupLayout({
-		input: { texture: texture2d(f32) },
-		output: { storageTexture: textureStorage2d(OUTPUT_FORMAT, "write-only") },
-		params: { uniform: Params },
-		taps: { uniform: TapArray }
-	}), "layout");
-	return {
-		layout,
-		kernel: typegpu_default.fn([u32, 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(f32(cx), .5), p.inputWidth), computeWidth), .5);
-			const inputCy = __tsover_sub(__tsover_div(__tsover_mul(__tsover_add(f32(cy), .5), p.inputHeight), computeHeight), .5);
-			const inputWm1 = i32(__tsover_sub(p.inputWidth, 1));
-			const inputHm1 = i32(__tsover_sub(p.inputHeight, 1));
-			if (radius < PASSTHROUGH_RADIUS) {
-				const sx = clamp(i32(round(inputCx)), 0, inputWm1);
-				const sy = clamp(i32(round(inputCy)), 0, inputHm1);
-				const texel = textureLoad(layout.$.input, vec2u(u32(sx), u32(sy)), 0);
-				textureStore(layout.$.output, 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 = vec3f(0, 0, 0);
-				let alphaAccum = f32(0);
-				let wSum = 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 = vec2f(__tsover_mul(ox, radius), __tsover_mul(oy, radius));
-					const sx = clamp(i32(round(__tsover_add(inputCx, off.x))), 0, inputWm1);
-					const sy = clamp(i32(round(__tsover_add(inputCy, off.y))), 0, inputHm1);
-					const base = textureLoad(layout.$.input, vec2u(u32(sx), 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 = clamp(i32(round(__tsover_add(inputCx, offR.x))), 0, inputWm1);
-						const ry = clamp(i32(round(__tsover_add(inputCy, offR.y))), 0, inputHm1);
-						colR = textureLoad(layout.$.input, vec2u(u32(rx), u32(ry)), 0).x;
-						const offB = off.mul(__tsover_sub(1, __tsover_mul(fringe, .5)));
-						const bx = clamp(i32(round(__tsover_add(inputCx, offB.x))), 0, inputWm1);
-						const by = clamp(i32(round(__tsover_add(inputCy, offB.y))), 0, inputHm1);
-						colB = textureLoad(layout.$.input, vec2u(u32(bx), u32(by)), 0).z;
-					}
-					const col = vec3f(colR, base.y, colB);
-					const lum = dot(base.xyz, vec3f(.2126, .7152, .0722));
-					const hi = 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, max(wSum, 1e-4));
-				textureStore(layout.$.output, vec2u(cx, cy), vec4f(accum.mul(invW), __tsover_mul(alphaAccum, invW)));
-			}
-		}), {
-			v: 2,
-			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,
-											"d.f32",
-											["cx"]
-										],
-										"+",
-										[5, "0.5"]
-									],
-									"*",
-									[
-										7,
-										"p",
-										"inputWidth"
-									]
-								],
-								"/",
-								"computeWidth"
-							],
-							"-",
-							[5, "0.5"]
-						]
-					],
-					[
-						13,
-						"inputCy",
-						[
-							1,
-							[
-								1,
-								[
-									1,
-									[
-										1,
-										[
-											6,
-											"d.f32",
-											["cy"]
-										],
-										"+",
-										[5, "0.5"]
-									],
-									"*",
-									[
-										7,
-										"p",
-										"inputHeight"
-									]
-								],
-								"/",
-								"computeHeight"
-							],
-							"-",
-							[5, "0.5"]
-						]
-					],
-					[
-						13,
-						"inputWm1",
-						[
-							6,
-							"d.i32",
-							[[
-								1,
-								[
-									7,
-									"p",
-									"inputWidth"
-								],
-								"-",
-								[5, "1"]
-							]]
-						]
-					],
-					[
-						13,
-						"inputHm1",
-						[
-							6,
-							"d.i32",
-							[[
-								1,
-								[
-									7,
-									"p",
-									"inputHeight"
-								],
-								"-",
-								[5, "1"]
-							]]
-						]
-					],
-					[
-						11,
-						[
-							1,
-							"radius",
-							"<",
-							"PASSTHROUGH_RADIUS"
-						],
-						[0, [
-							[
-								13,
-								"sx",
-								[
-									6,
-									"std.clamp",
-									[
-										[
-											6,
-											"d.i32",
-											[[
-												6,
-												"std.round",
-												["inputCx"]
-											]]
-										],
-										[5, "0"],
-										"inputWm1"
-									]
-								]
-							],
-							[
-								13,
-								"sy",
-								[
-									6,
-									"std.clamp",
-									[
-										[
-											6,
-											"d.i32",
-											[[
-												6,
-												"std.round",
-												["inputCy"]
-											]]
-										],
-										[5, "0"],
-										"inputHm1"
-									]
-								]
-							],
-							[
-								13,
-								"texel",
-								[
-									6,
-									"std.textureLoad",
-									[
-										[
-											7,
-											[
-												7,
-												"layout",
-												"$"
-											],
-											"input"
-										],
-										[
-											6,
-											"d.vec2u",
-											[[
-												6,
-												"d.u32",
-												["sx"]
-											], [
-												6,
-												"d.u32",
-												["sy"]
-											]]
-										],
-										[5, "0"]
-									]
-								]
-							],
-							[
-								6,
-								"std.textureStore",
-								[
-									[
-										7,
-										[
-											7,
-											"layout",
-											"$"
-										],
-										"output"
-									],
-									[
-										6,
-										"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,
-									"d.vec3f",
-									[
-										[5, "0"],
-										[5, "0"],
-										[5, "0"]
-									]
-								]
-							],
-							[
-								12,
-								"alphaAccum",
-								[
-									6,
-									"d.f32",
-									[[5, "0"]]
-								]
-							],
-							[
-								12,
-								"wSum",
-								[
-									6,
-									"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,
-											"d.vec2f",
-											[[
-												1,
-												"ox",
-												"*",
-												"radius"
-											], [
-												1,
-												"oy",
-												"*",
-												"radius"
-											]]
-										]
-									],
-									[
-										13,
-										"sx",
-										[
-											6,
-											"std.clamp",
-											[
-												[
-													6,
-													"d.i32",
-													[[
-														6,
-														"std.round",
-														[[
-															1,
-															"inputCx",
-															"+",
-															[
-																7,
-																"off",
-																"x"
-															]
-														]]
-													]]
-												],
-												[5, "0"],
-												"inputWm1"
-											]
-										]
-									],
-									[
-										13,
-										"sy",
-										[
-											6,
-											"std.clamp",
-											[
-												[
-													6,
-													"d.i32",
-													[[
-														6,
-														"std.round",
-														[[
-															1,
-															"inputCy",
-															"+",
-															[
-																7,
-																"off",
-																"y"
-															]
-														]]
-													]]
-												],
-												[5, "0"],
-												"inputHm1"
-											]
-										]
-									],
-									[
-										13,
-										"base",
-										[
-											6,
-											"std.textureLoad",
-											[
-												[
-													7,
-													[
-														7,
-														"layout",
-														"$"
-													],
-													"input"
-												],
-												[
-													6,
-													"d.vec2u",
-													[[
-														6,
-														"d.u32",
-														["sx"]
-													], [
-														6,
-														"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,
-													"std.clamp",
-													[
-														[
-															6,
-															"d.i32",
-															[[
-																6,
-																"std.round",
-																[[
-																	1,
-																	"inputCx",
-																	"+",
-																	[
-																		7,
-																		"offR",
-																		"x"
-																	]
-																]]
-															]]
-														],
-														[5, "0"],
-														"inputWm1"
-													]
-												]
-											],
-											[
-												13,
-												"ry",
-												[
-													6,
-													"std.clamp",
-													[
-														[
-															6,
-															"d.i32",
-															[[
-																6,
-																"std.round",
-																[[
-																	1,
-																	"inputCy",
-																	"+",
-																	[
-																		7,
-																		"offR",
-																		"y"
-																	]
-																]]
-															]]
-														],
-														[5, "0"],
-														"inputHm1"
-													]
-												]
-											],
-											[
-												2,
-												"colR",
-												"=",
-												[
-													7,
-													[
-														6,
-														"std.textureLoad",
-														[
-															[
-																7,
-																[
-																	7,
-																	"layout",
-																	"$"
-																],
-																"input"
-															],
-															[
-																6,
-																"d.vec2u",
-																[[
-																	6,
-																	"d.u32",
-																	["rx"]
-																], [
-																	6,
-																	"d.u32",
-																	["ry"]
-																]]
-															],
-															[5, "0"]
-														]
-													],
-													"x"
-												]
-											],
-											[
-												13,
-												"offB",
-												[
-													6,
-													[
-														7,
-														"off",
-														"mul"
-													],
-													[[
-														1,
-														[5, "1"],
-														"-",
-														[
-															1,
-															"fringe",
-															"*",
-															[5, "0.5"]
-														]
-													]]
-												]
-											],
-											[
-												13,
-												"bx",
-												[
-													6,
-													"std.clamp",
-													[
-														[
-															6,
-															"d.i32",
-															[[
-																6,
-																"std.round",
-																[[
-																	1,
-																	"inputCx",
-																	"+",
-																	[
-																		7,
-																		"offB",
-																		"x"
-																	]
-																]]
-															]]
-														],
-														[5, "0"],
-														"inputWm1"
-													]
-												]
-											],
-											[
-												13,
-												"by",
-												[
-													6,
-													"std.clamp",
-													[
-														[
-															6,
-															"d.i32",
-															[[
-																6,
-																"std.round",
-																[[
-																	1,
-																	"inputCy",
-																	"+",
-																	[
-																		7,
-																		"offB",
-																		"y"
-																	]
-																]]
-															]]
-														],
-														[5, "0"],
-														"inputHm1"
-													]
-												]
-											],
-											[
-												2,
-												"colB",
-												"=",
-												[
-													7,
-													[
-														6,
-														"std.textureLoad",
-														[
-															[
-																7,
-																[
-																	7,
-																	"layout",
-																	"$"
-																],
-																"input"
-															],
-															[
-																6,
-																"d.vec2u",
-																[[
-																	6,
-																	"d.u32",
-																	["bx"]
-																], [
-																	6,
-																	"d.u32",
-																	["by"]
-																]]
-															],
-															[5, "0"]
-														]
-													],
-													"z"
-												]
-											]
-										]]
-									],
-									[
-										13,
-										"col",
-										[
-											6,
-											"d.vec3f",
-											[
-												"colR",
-												[
-													7,
-													"base",
-													"y"
-												],
-												"colB"
-											]
-										]
-									],
-									[
-										13,
-										"lum",
-										[
-											6,
-											"std.dot",
-											[[
-												7,
-												"base",
-												"xyz"
-											], [
-												6,
-												"d.vec3f",
-												[
-													[5, "0.2126"],
-													[5, "0.7152"],
-													[5, "0.0722"]
-												]
-											]]
-										]
-									],
-									[
-										13,
-										"hi",
-										[
-											6,
-											"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,
-										"std.max",
-										["wSum", [5, "0.0001"]]
-									]
-								]
-							],
-							[
-								6,
-								"std.textureStore",
-								[
-									[
-										7,
-										[
-											7,
-											"layout",
-											"$"
-										],
-										"output"
-									],
-									[
-										6,
-										"d.vec2u",
-										["cx", "cy"]
-									],
-									[
-										6,
-										"d.vec4f",
-										[[
-											6,
-											[
-												7,
-												"accum",
-												"mul"
-											],
-											["invW"]
-										], [
-											1,
-											"alphaAccum",
-											"*",
-											"invW"
-										]]
-									]
-								]
-							]
-						]]
-					]
-				]]
-			},
-			externals: {
-				"layout": () => layout,
-				"d.f32": () => f32,
-				"computeWidth": () => computeWidth,
-				"computeHeight": () => computeHeight,
-				"d.i32": () => i32,
-				"PASSTHROUGH_RADIUS": () => PASSTHROUGH_RADIUS,
-				"std.clamp": () => clamp,
-				"std.round": () => round,
-				"std.textureLoad": () => textureLoad,
-				"d.vec2u": () => vec2u,
-				"d.u32": () => u32,
-				"std.textureStore": () => textureStore,
-				"d.vec3f": () => vec3f,
-				"TAPS": () => TAPS,
-				"d.vec2f": () => vec2f,
-				"std.dot": () => dot,
-				"std.smoothstep": () => smoothstep,
-				"HIGHLIGHT_KNEE": () => HIGHLIGHT_KNEE,
-				"std.max": () => max,
-				"d.vec4f": () => vec4f
-			}
-		}) && $.f)({})).$name("bokehGather"),
-		Params,
-		TapArray
-	};
-}
-function buildBokehMapGraph(computeWidth, computeHeight, tapCount, channel) {
-	const TAPS = tapCount;
-	const Params = bokehMapParams();
-	const TapArray = arrayOf(vec4f, TAPS);
-	const channelScalar = mapSourceScalar(channel);
-	const layout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.bindGroupLayout({
-		input: { texture: texture2d(f32) },
-		source: { texture: texture2d(f32) },
-		output: { storageTexture: textureStorage2d(OUTPUT_FORMAT, "write-only") },
-		params: { uniform: Params },
-		taps: { uniform: TapArray }
-	}), "layout");
-	return {
-		layout,
-		kernel: typegpu_default.fn([u32, 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(f32(cx), .5), p.inputWidth), computeWidth), .5);
-			const inputCy = __tsover_sub(__tsover_div(__tsover_mul(__tsover_add(f32(cy), .5), p.inputHeight), computeHeight), .5);
-			const inputWm1 = i32(__tsover_sub(p.inputWidth, 1));
-			const inputHm1 = i32(__tsover_sub(p.inputHeight, 1));
-			const u = __tsover_div(__tsover_add(f32(cx), .5), computeWidth);
-			const v = __tsover_div(__tsover_add(f32(cy), .5), computeHeight);
-			const srcX = clamp(i32(round(__tsover_mul(u, p.inputWidth))), 0, inputWm1);
-			const srcY = clamp(i32(round(__tsover_mul(v, p.inputHeight))), 0, inputHm1);
-			const remapped = applyRemapWindow(channelScalar(textureLoad(layout.$.source, vec2u(u32(srcX), u32(srcY)), 0)), p.inputMin, p.inputMax, p.outputMin, p.outputMax, p.curve);
-			const radius = __tsover_mul(remapped, .8);
-			if (radius < PASSTHROUGH_RADIUS) {
-				const sx = clamp(i32(round(inputCx)), 0, inputWm1);
-				const sy = clamp(i32(round(inputCy)), 0, inputHm1);
-				const texel = textureLoad(layout.$.input, vec2u(u32(sx), u32(sy)), 0);
-				textureStore(layout.$.output, 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 = vec3f(0, 0, 0);
-				let alphaAccum = f32(0);
-				let wSum = 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 = vec2f(__tsover_mul(ox, radius), __tsover_mul(oy, radius));
-					const sx = clamp(i32(round(__tsover_add(inputCx, off.x))), 0, inputWm1);
-					const sy = clamp(i32(round(__tsover_add(inputCy, off.y))), 0, inputHm1);
-					const base = textureLoad(layout.$.input, vec2u(u32(sx), 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 = clamp(i32(round(__tsover_add(inputCx, offR.x))), 0, inputWm1);
-						const ry = clamp(i32(round(__tsover_add(inputCy, offR.y))), 0, inputHm1);
-						colR = textureLoad(layout.$.input, vec2u(u32(rx), u32(ry)), 0).x;
-						const offB = off.mul(__tsover_sub(1, __tsover_mul(fringe, .5)));
-						const bx = clamp(i32(round(__tsover_add(inputCx, offB.x))), 0, inputWm1);
-						const by = clamp(i32(round(__tsover_add(inputCy, offB.y))), 0, inputHm1);
-						colB = textureLoad(layout.$.input, vec2u(u32(bx), u32(by)), 0).z;
-					}
-					const col = vec3f(colR, base.y, colB);
-					const lum = dot(base.xyz, vec3f(.2126, .7152, .0722));
-					const hi = 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, max(wSum, 1e-4));
-				textureStore(layout.$.output, vec2u(cx, cy), vec4f(accum.mul(invW), __tsover_mul(alphaAccum, invW)));
-			}
-		}), {
-			v: 2,
-			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,
-											"d.f32",
-											["cx"]
-										],
-										"+",
-										[5, "0.5"]
-									],
-									"*",
-									[
-										7,
-										"p",
-										"inputWidth"
-									]
-								],
-								"/",
-								"computeWidth"
-							],
-							"-",
-							[5, "0.5"]
-						]
-					],
-					[
-						13,
-						"inputCy",
-						[
-							1,
-							[
-								1,
-								[
-									1,
-									[
-										1,
-										[
-											6,
-											"d.f32",
-											["cy"]
-										],
-										"+",
-										[5, "0.5"]
-									],
-									"*",
-									[
-										7,
-										"p",
-										"inputHeight"
-									]
-								],
-								"/",
-								"computeHeight"
-							],
-							"-",
-							[5, "0.5"]
-						]
-					],
-					[
-						13,
-						"inputWm1",
-						[
-							6,
-							"d.i32",
-							[[
-								1,
-								[
-									7,
-									"p",
-									"inputWidth"
-								],
-								"-",
-								[5, "1"]
-							]]
-						]
-					],
-					[
-						13,
-						"inputHm1",
-						[
-							6,
-							"d.i32",
-							[[
-								1,
-								[
-									7,
-									"p",
-									"inputHeight"
-								],
-								"-",
-								[5, "1"]
-							]]
-						]
-					],
-					[
-						13,
-						"u",
-						[
-							1,
-							[
-								1,
-								[
-									6,
-									"d.f32",
-									["cx"]
-								],
-								"+",
-								[5, "0.5"]
-							],
-							"/",
-							"computeWidth"
-						]
-					],
-					[
-						13,
-						"v",
-						[
-							1,
-							[
-								1,
-								[
-									6,
-									"d.f32",
-									["cy"]
-								],
-								"+",
-								[5, "0.5"]
-							],
-							"/",
-							"computeHeight"
-						]
-					],
-					[
-						13,
-						"srcX",
-						[
-							6,
-							"std.clamp",
-							[
-								[
-									6,
-									"d.i32",
-									[[
-										6,
-										"std.round",
-										[[
-											1,
-											"u",
-											"*",
-											[
-												7,
-												"p",
-												"inputWidth"
-											]
-										]]
-									]]
-								],
-								[5, "0"],
-								"inputWm1"
-							]
-						]
-					],
-					[
-						13,
-						"srcY",
-						[
-							6,
-							"std.clamp",
-							[
-								[
-									6,
-									"d.i32",
-									[[
-										6,
-										"std.round",
-										[[
-											1,
-											"v",
-											"*",
-											[
-												7,
-												"p",
-												"inputHeight"
-											]
-										]]
-									]]
-								],
-								[5, "0"],
-								"inputHm1"
-							]
-						]
-					],
-					[
-						13,
-						"mapSample",
-						[
-							6,
-							"std.textureLoad",
-							[
-								[
-									7,
-									[
-										7,
-										"layout",
-										"$"
-									],
-									"source"
-								],
-								[
-									6,
-									"d.vec2u",
-									[[
-										6,
-										"d.u32",
-										["srcX"]
-									], [
-										6,
-										"d.u32",
-										["srcY"]
-									]]
-								],
-								[5, "0"]
-							]
-						]
-					],
-					[
-						13,
-						"remapped",
-						[
-							6,
-							"blur.applyRemapWindow",
-							[
-								[
-									6,
-									"channelScalar",
-									["mapSample"]
-								],
-								[
-									7,
-									"p",
-									"inputMin"
-								],
-								[
-									7,
-									"p",
-									"inputMax"
-								],
-								[
-									7,
-									"p",
-									"outputMin"
-								],
-								[
-									7,
-									"p",
-									"outputMax"
-								],
-								[
-									7,
-									"p",
-									"curve"
-								]
-							]
-						]
-					],
-					[
-						13,
-						"radius",
-						[
-							1,
-							"remapped",
-							"*",
-							"RADIUS_SCALE"
-						]
-					],
-					[
-						11,
-						[
-							1,
-							"radius",
-							"<",
-							"PASSTHROUGH_RADIUS"
-						],
-						[0, [
-							[
-								13,
-								"sx",
-								[
-									6,
-									"std.clamp",
-									[
-										[
-											6,
-											"d.i32",
-											[[
-												6,
-												"std.round",
-												["inputCx"]
-											]]
-										],
-										[5, "0"],
-										"inputWm1"
-									]
-								]
-							],
-							[
-								13,
-								"sy",
-								[
-									6,
-									"std.clamp",
-									[
-										[
-											6,
-											"d.i32",
-											[[
-												6,
-												"std.round",
-												["inputCy"]
-											]]
-										],
-										[5, "0"],
-										"inputHm1"
-									]
-								]
-							],
-							[
-								13,
-								"texel",
-								[
-									6,
-									"std.textureLoad",
-									[
-										[
-											7,
-											[
-												7,
-												"layout",
-												"$"
-											],
-											"input"
-										],
-										[
-											6,
-											"d.vec2u",
-											[[
-												6,
-												"d.u32",
-												["sx"]
-											], [
-												6,
-												"d.u32",
-												["sy"]
-											]]
-										],
-										[5, "0"]
-									]
-								]
-							],
-							[
-								6,
-								"std.textureStore",
-								[
-									[
-										7,
-										[
-											7,
-											"layout",
-											"$"
-										],
-										"output"
-									],
-									[
-										6,
-										"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,
-									"d.vec3f",
-									[
-										[5, "0"],
-										[5, "0"],
-										[5, "0"]
-									]
-								]
-							],
-							[
-								12,
-								"alphaAccum",
-								[
-									6,
-									"d.f32",
-									[[5, "0"]]
-								]
-							],
-							[
-								12,
-								"wSum",
-								[
-									6,
-									"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,
-											"d.vec2f",
-											[[
-												1,
-												"ox",
-												"*",
-												"radius"
-											], [
-												1,
-												"oy",
-												"*",
-												"radius"
-											]]
-										]
-									],
-									[
-										13,
-										"sx",
-										[
-											6,
-											"std.clamp",
-											[
-												[
-													6,
-													"d.i32",
-													[[
-														6,
-														"std.round",
-														[[
-															1,
-															"inputCx",
-															"+",
-															[
-																7,
-																"off",
-																"x"
-															]
-														]]
-													]]
-												],
-												[5, "0"],
-												"inputWm1"
-											]
-										]
-									],
-									[
-										13,
-										"sy",
-										[
-											6,
-											"std.clamp",
-											[
-												[
-													6,
-													"d.i32",
-													[[
-														6,
-														"std.round",
-														[[
-															1,
-															"inputCy",
-															"+",
-															[
-																7,
-																"off",
-																"y"
-															]
-														]]
-													]]
-												],
-												[5, "0"],
-												"inputHm1"
-											]
-										]
-									],
-									[
-										13,
-										"base",
-										[
-											6,
-											"std.textureLoad",
-											[
-												[
-													7,
-													[
-														7,
-														"layout",
-														"$"
-													],
-													"input"
-												],
-												[
-													6,
-													"d.vec2u",
-													[[
-														6,
-														"d.u32",
-														["sx"]
-													], [
-														6,
-														"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,
-													"std.clamp",
-													[
-														[
-															6,
-															"d.i32",
-															[[
-																6,
-																"std.round",
-																[[
-																	1,
-																	"inputCx",
-																	"+",
-																	[
-																		7,
-																		"offR",
-																		"x"
-																	]
-																]]
-															]]
-														],
-														[5, "0"],
-														"inputWm1"
-													]
-												]
-											],
-											[
-												13,
-												"ry",
-												[
-													6,
-													"std.clamp",
-													[
-														[
-															6,
-															"d.i32",
-															[[
-																6,
-																"std.round",
-																[[
-																	1,
-																	"inputCy",
-																	"+",
-																	[
-																		7,
-																		"offR",
-																		"y"
-																	]
-																]]
-															]]
-														],
-														[5, "0"],
-														"inputHm1"
-													]
-												]
-											],
-											[
-												2,
-												"colR",
-												"=",
-												[
-													7,
-													[
-														6,
-														"std.textureLoad",
-														[
-															[
-																7,
-																[
-																	7,
-																	"layout",
-																	"$"
-																],
-																"input"
-															],
-															[
-																6,
-																"d.vec2u",
-																[[
-																	6,
-																	"d.u32",
-																	["rx"]
-																], [
-																	6,
-																	"d.u32",
-																	["ry"]
-																]]
-															],
-															[5, "0"]
-														]
-													],
-													"x"
-												]
-											],
-											[
-												13,
-												"offB",
-												[
-													6,
-													[
-														7,
-														"off",
-														"mul"
-													],
-													[[
-														1,
-														[5, "1"],
-														"-",
-														[
-															1,
-															"fringe",
-															"*",
-															[5, "0.5"]
-														]
-													]]
-												]
-											],
-											[
-												13,
-												"bx",
-												[
-													6,
-													"std.clamp",
-													[
-														[
-															6,
-															"d.i32",
-															[[
-																6,
-																"std.round",
-																[[
-																	1,
-																	"inputCx",
-																	"+",
-																	[
-																		7,
-																		"offB",
-																		"x"
-																	]
-																]]
-															]]
-														],
-														[5, "0"],
-														"inputWm1"
-													]
-												]
-											],
-											[
-												13,
-												"by",
-												[
-													6,
-													"std.clamp",
-													[
-														[
-															6,
-															"d.i32",
-															[[
-																6,
-																"std.round",
-																[[
-																	1,
-																	"inputCy",
-																	"+",
-																	[
-																		7,
-																		"offB",
-																		"y"
-																	]
-																]]
-															]]
-														],
-														[5, "0"],
-														"inputHm1"
-													]
-												]
-											],
-											[
-												2,
-												"colB",
-												"=",
-												[
-													7,
-													[
-														6,
-														"std.textureLoad",
-														[
-															[
-																7,
-																[
-																	7,
-																	"layout",
-																	"$"
-																],
-																"input"
-															],
-															[
-																6,
-																"d.vec2u",
-																[[
-																	6,
-																	"d.u32",
-																	["bx"]
-																], [
-																	6,
-																	"d.u32",
-																	["by"]
-																]]
-															],
-															[5, "0"]
-														]
-													],
-													"z"
-												]
-											]
-										]]
-									],
-									[
-										13,
-										"col",
-										[
-											6,
-											"d.vec3f",
-											[
-												"colR",
-												[
-													7,
-													"base",
-													"y"
-												],
-												"colB"
-											]
-										]
-									],
-									[
-										13,
-										"lum",
-										[
-											6,
-											"std.dot",
-											[[
-												7,
-												"base",
-												"xyz"
-											], [
-												6,
-												"d.vec3f",
-												[
-													[5, "0.2126"],
-													[5, "0.7152"],
-													[5, "0.0722"]
-												]
-											]]
-										]
-									],
-									[
-										13,
-										"hi",
-										[
-											6,
-											"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,
-										"std.max",
-										["wSum", [5, "0.0001"]]
-									]
-								]
-							],
-							[
-								6,
-								"std.textureStore",
-								[
-									[
-										7,
-										[
-											7,
-											"layout",
-											"$"
-										],
-										"output"
-									],
-									[
-										6,
-										"d.vec2u",
-										["cx", "cy"]
-									],
-									[
-										6,
-										"d.vec4f",
-										[[
-											6,
-											[
-												7,
-												"accum",
-												"mul"
-											],
-											["invW"]
-										], [
-											1,
-											"alphaAccum",
-											"*",
-											"invW"
-										]]
-									]
-								]
-							]
-						]]
-					]
-				]]
-			},
-			externals: {
-				"layout": () => layout,
-				"d.f32": () => f32,
-				"computeWidth": () => computeWidth,
-				"computeHeight": () => computeHeight,
-				"d.i32": () => i32,
-				"std.clamp": () => clamp,
-				"std.round": () => round,
-				"std.textureLoad": () => textureLoad,
-				"d.vec2u": () => vec2u,
-				"d.u32": () => u32,
-				"blur.applyRemapWindow": () => applyRemapWindow,
-				"channelScalar": () => channelScalar,
-				"RADIUS_SCALE": () => .8,
-				"PASSTHROUGH_RADIUS": () => PASSTHROUGH_RADIUS,
-				"std.textureStore": () => textureStore,
-				"d.vec3f": () => vec3f,
-				"TAPS": () => TAPS,
-				"d.vec2f": () => vec2f,
-				"std.dot": () => dot,
-				"std.smoothstep": () => smoothstep,
-				"HIGHLIGHT_KNEE": () => HIGHLIGHT_KNEE,
-				"std.max": () => max,
-				"d.vec4f": () => vec4f
-			}
-		}) && $.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) => 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: 2,
-				name: void 0,
-				ast: {
-					"params": [{
-						"type": "i",
-						"name": "cx"
-					}, {
-						"type": "i",
-						"name": "cy"
-					}],
-					"body": [0, [[
-						6,
-						"graph.kernel",
-						["cx", "cy"]
-					]]]
-				},
-				externals: { "graph.kernel": () => graph$1.kernel }
-			}) && $.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: 2,
-			name: void 0,
-			ast: {
-				"params": [{
-					"type": "i",
-					"name": "cx"
-				}, {
-					"type": "i",
-					"name": "cy"
-				}],
-				"body": [0, [[
-					6,
-					"graph.kernel",
-					["cx", "cy"]
-				]]]
-			},
-			externals: { "graph.kernel": () => graph.kernel }
-		}) && $.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 };