shaders 3.1.462 → 3.2.464

package/dist/core/shapePaints-G_Ap8xID.js

@@ -0,0 +1,4600 @@
+import { $n as vec4f, Bn as reflect, Cn as atan2, En as cos, Fn as min, Gn as sqrt, In as mix, Jn as vec2f, Ln as normalize, Nn as length, On as dot, Pn as max, Rn as pow, Tn as clamp, Un as sin, Wn as smoothstep, Xt as aspectOf, Zn as vec3f, bn as select, hr as f32, in as DEG_TO_RAD, jn as floor, kn as exp, ln as TAU, mn as typegpu_default, sr as struct, xn as abs } from "./lower-z2vuXP8M.js";
+import { t as luma601Dot } from "./tone-BA0D_veZ.js";
+import { a as chromaticRingBand, l as radialGaussianFalloff, t as angularCosineSpikes } from "./lightfields-BjzpZvFy.js";
+var EPS = 1e-5;
+const lineMask = typegpu_default.fn([
+	vec2f,
+	vec2f,
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, pointA, pointB, thickness, style, dashLength, gapLength, capStart, capEnd) => {
+	"use gpu";
+	const aspect = __tsover_div(viewport.x, viewport.y);
+	const px = __tsover_mul(uv.x, aspect);
+	const ax = __tsover_mul(pointA.x, aspect);
+	const ay = __tsover_sub(1, pointA.y);
+	const bx = __tsover_mul(pointB.x, aspect);
+	const by = __tsover_sub(1, pointB.y);
+	const pax = __tsover_sub(px, ax);
+	const pay = __tsover_sub(uv.y, ay);
+	const bax = __tsover_sub(bx, ax);
+	const bay = __tsover_sub(by, ay);
+	const len = max(length(vec2f(bax, bay)), f32(EPS));
+	const t = __tsover_div(__tsover_add(__tsover_mul(pax, bax), __tsover_mul(pay, bay)), len);
+	const overshoot = max(max(-t, __tsover_sub(t, len)), f32(0));
+	const h = clamp(__tsover_div(t, len), f32(0), f32(1));
+	const dSeg = length(vec2f(__tsover_sub(pax, __tsover_mul(bax, h)), __tsover_sub(pay, __tsover_mul(bay, h))));
+	const perp = sqrt(max(__tsover_sub(__tsover_mul(dSeg, dSeg), __tsover_mul(overshoot, overshoot)), f32(0)));
+	const halfT = __tsover_mul(thickness, .5);
+	const cSolid = __tsover_sub(t, __tsover_mul(len, .5));
+	const axSolid = __tsover_mul(len, .5);
+	const rawDash = max(dashLength, f32(EPS));
+	const rawPeriod = __tsover_add(rawDash, gapLength);
+	const nDash = max(floor(__tsover_add(__tsover_div(__tsover_add(len, gapLength), rawPeriod), .5)), f32(1));
+	const scale = __tsover_div(len, max(__tsover_add(__tsover_mul(nDash, rawDash), __tsover_mul(__tsover_sub(nDash, 1), gapLength)), f32(EPS)));
+	const dashL = __tsover_mul(rawDash, scale);
+	const period = __tsover_mul(rawPeriod, scale);
+	const kDash = clamp(floor(__tsover_div(t, period)), f32(0), __tsover_sub(nDash, 1));
+	const cDash = __tsover_sub(t, __tsover_add(__tsover_mul(kDash, period), __tsover_mul(dashL, .5)));
+	const axDashRound = max(__tsover_sub(__tsover_mul(dashL, .5), halfT), f32(0));
+	const axDashSquare = __tsover_mul(dashL, .5);
+	const rawDotPeriod = max(__tsover_add(thickness, gapLength), f32(EPS));
+	const nDot = max(floor(__tsover_add(__tsover_div(len, rawDotPeriod), .5)), f32(1));
+	const dotPeriod = __tsover_div(len, nDot);
+	const kDot = clamp(floor(__tsover_add(__tsover_div(t, dotPeriod), .5)), f32(0), nDot);
+	const cDot = __tsover_sub(t, __tsover_mul(kDot, dotPeriod));
+	const isPattern = style >= .5;
+	const isDotted = style >= 1.5;
+	const c = select(cSolid, select(cDash, cDot, isDotted), isPattern);
+	const axRound = select(axSolid, select(axDashRound, f32(0), isDotted), isPattern);
+	const axSquare = select(axSolid, select(axDashSquare, halfT, isDotted), isPattern);
+	const capHere = select(capStart, capEnd, c > 0);
+	const sdRound = __tsover_sub(length(vec2f(max(__tsover_sub(abs(c), axRound), f32(0)), perp)), halfT);
+	const qx = __tsover_sub(abs(c), axSquare);
+	const qy = __tsover_sub(perp, halfT);
+	const sd = select(__tsover_add(length(vec2f(max(qx, f32(0)), max(qy, f32(0)))), min(max(qx, qy), f32(0))), sdRound, capHere >= .5);
+	const feather = __tsover_div(1, viewport.y);
+	return __tsover_sub(1, smoothstep(-feather, feather, sd));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "viewport"
+			},
+			{
+				"type": "i",
+				"name": "pointA"
+			},
+			{
+				"type": "i",
+				"name": "pointB"
+			},
+			{
+				"type": "i",
+				"name": "thickness"
+			},
+			{
+				"type": "i",
+				"name": "style"
+			},
+			{
+				"type": "i",
+				"name": "dashLength"
+			},
+			{
+				"type": "i",
+				"name": "gapLength"
+			},
+			{
+				"type": "i",
+				"name": "capStart"
+			},
+			{
+				"type": "i",
+				"name": "capEnd"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"aspect",
+				[
+					1,
+					[
+						7,
+						"viewport",
+						"x"
+					],
+					"/",
+					[
+						7,
+						"viewport",
+						"y"
+					]
+				]
+			],
+			[
+				13,
+				"px",
+				[
+					1,
+					[
+						7,
+						"uv",
+						"x"
+					],
+					"*",
+					"aspect"
+				]
+			],
+			[
+				13,
+				"ax",
+				[
+					1,
+					[
+						7,
+						"pointA",
+						"x"
+					],
+					"*",
+					"aspect"
+				]
+			],
+			[
+				13,
+				"ay",
+				[
+					1,
+					[5, "1"],
+					"-",
+					[
+						7,
+						"pointA",
+						"y"
+					]
+				]
+			],
+			[
+				13,
+				"bx",
+				[
+					1,
+					[
+						7,
+						"pointB",
+						"x"
+					],
+					"*",
+					"aspect"
+				]
+			],
+			[
+				13,
+				"by",
+				[
+					1,
+					[5, "1"],
+					"-",
+					[
+						7,
+						"pointB",
+						"y"
+					]
+				]
+			],
+			[
+				13,
+				"pax",
+				[
+					1,
+					"px",
+					"-",
+					"ax"
+				]
+			],
+			[
+				13,
+				"pay",
+				[
+					1,
+					[
+						7,
+						"uv",
+						"y"
+					],
+					"-",
+					"ay"
+				]
+			],
+			[
+				13,
+				"bax",
+				[
+					1,
+					"bx",
+					"-",
+					"ax"
+				]
+			],
+			[
+				13,
+				"bay",
+				[
+					1,
+					"by",
+					"-",
+					"ay"
+				]
+			],
+			[
+				13,
+				"len",
+				[
+					6,
+					"std.max",
+					[[
+						6,
+						"std.length",
+						[[
+							6,
+							"d.vec2f",
+							["bax", "bay"]
+						]]
+					], [
+						6,
+						"d.f32",
+						["EPS"]
+					]]
+				]
+			],
+			[
+				13,
+				"t",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							"pax",
+							"*",
+							"bax"
+						],
+						"+",
+						[
+							1,
+							"pay",
+							"*",
+							"bay"
+						]
+					],
+					"/",
+					"len"
+				]
+			],
+			[
+				13,
+				"overshoot",
+				[
+					6,
+					"std.max",
+					[[
+						6,
+						"std.max",
+						[[
+							4,
+							"-",
+							"t"
+						], [
+							1,
+							"t",
+							"-",
+							"len"
+						]]
+					], [
+						6,
+						"d.f32",
+						[[5, "0"]]
+					]]
+				]
+			],
+			[
+				13,
+				"h",
+				[
+					6,
+					"std.clamp",
+					[
+						[
+							1,
+							"t",
+							"/",
+							"len"
+						],
+						[
+							6,
+							"d.f32",
+							[[5, "0"]]
+						],
+						[
+							6,
+							"d.f32",
+							[[5, "1"]]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"dSeg",
+				[
+					6,
+					"std.length",
+					[[
+						6,
+						"d.vec2f",
+						[[
+							1,
+							"pax",
+							"-",
+							[
+								1,
+								"bax",
+								"*",
+								"h"
+							]
+						], [
+							1,
+							"pay",
+							"-",
+							[
+								1,
+								"bay",
+								"*",
+								"h"
+							]
+						]]
+					]]
+				]
+			],
+			[
+				13,
+				"perp",
+				[
+					6,
+					"std.sqrt",
+					[[
+						6,
+						"std.max",
+						[[
+							1,
+							[
+								1,
+								"dSeg",
+								"*",
+								"dSeg"
+							],
+							"-",
+							[
+								1,
+								"overshoot",
+								"*",
+								"overshoot"
+							]
+						], [
+							6,
+							"d.f32",
+							[[5, "0"]]
+						]]
+					]]
+				]
+			],
+			[
+				13,
+				"halfT",
+				[
+					1,
+					"thickness",
+					"*",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"cSolid",
+				[
+					1,
+					"t",
+					"-",
+					[
+						1,
+						"len",
+						"*",
+						[5, "0.5"]
+					]
+				]
+			],
+			[
+				13,
+				"axSolid",
+				[
+					1,
+					"len",
+					"*",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"rawDash",
+				[
+					6,
+					"std.max",
+					["dashLength", [
+						6,
+						"d.f32",
+						["EPS"]
+					]]
+				]
+			],
+			[
+				13,
+				"rawPeriod",
+				[
+					1,
+					"rawDash",
+					"+",
+					"gapLength"
+				]
+			],
+			[
+				13,
+				"nDash",
+				[
+					6,
+					"std.max",
+					[[
+						6,
+						"std.floor",
+						[[
+							1,
+							[
+								1,
+								[
+									1,
+									"len",
+									"+",
+									"gapLength"
+								],
+								"/",
+								"rawPeriod"
+							],
+							"+",
+							[5, "0.5"]
+						]]
+					], [
+						6,
+						"d.f32",
+						[[5, "1"]]
+					]]
+				]
+			],
+			[
+				13,
+				"scale",
+				[
+					1,
+					"len",
+					"/",
+					[
+						6,
+						"std.max",
+						[[
+							1,
+							[
+								1,
+								"nDash",
+								"*",
+								"rawDash"
+							],
+							"+",
+							[
+								1,
+								[
+									1,
+									"nDash",
+									"-",
+									[5, "1"]
+								],
+								"*",
+								"gapLength"
+							]
+						], [
+							6,
+							"d.f32",
+							["EPS"]
+						]]
+					]
+				]
+			],
+			[
+				13,
+				"dashL",
+				[
+					1,
+					"rawDash",
+					"*",
+					"scale"
+				]
+			],
+			[
+				13,
+				"period",
+				[
+					1,
+					"rawPeriod",
+					"*",
+					"scale"
+				]
+			],
+			[
+				13,
+				"kDash",
+				[
+					6,
+					"std.clamp",
+					[
+						[
+							6,
+							"std.floor",
+							[[
+								1,
+								"t",
+								"/",
+								"period"
+							]]
+						],
+						[
+							6,
+							"d.f32",
+							[[5, "0"]]
+						],
+						[
+							1,
+							"nDash",
+							"-",
+							[5, "1"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"cDash",
+				[
+					1,
+					"t",
+					"-",
+					[
+						1,
+						[
+							1,
+							"kDash",
+							"*",
+							"period"
+						],
+						"+",
+						[
+							1,
+							"dashL",
+							"*",
+							[5, "0.5"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"axDashRound",
+				[
+					6,
+					"std.max",
+					[[
+						1,
+						[
+							1,
+							"dashL",
+							"*",
+							[5, "0.5"]
+						],
+						"-",
+						"halfT"
+					], [
+						6,
+						"d.f32",
+						[[5, "0"]]
+					]]
+				]
+			],
+			[
+				13,
+				"axDashSquare",
+				[
+					1,
+					"dashL",
+					"*",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"rawDotPeriod",
+				[
+					6,
+					"std.max",
+					[[
+						1,
+						"thickness",
+						"+",
+						"gapLength"
+					], [
+						6,
+						"d.f32",
+						["EPS"]
+					]]
+				]
+			],
+			[
+				13,
+				"nDot",
+				[
+					6,
+					"std.max",
+					[[
+						6,
+						"std.floor",
+						[[
+							1,
+							[
+								1,
+								"len",
+								"/",
+								"rawDotPeriod"
+							],
+							"+",
+							[5, "0.5"]
+						]]
+					], [
+						6,
+						"d.f32",
+						[[5, "1"]]
+					]]
+				]
+			],
+			[
+				13,
+				"dotPeriod",
+				[
+					1,
+					"len",
+					"/",
+					"nDot"
+				]
+			],
+			[
+				13,
+				"kDot",
+				[
+					6,
+					"std.clamp",
+					[
+						[
+							6,
+							"std.floor",
+							[[
+								1,
+								[
+									1,
+									"t",
+									"/",
+									"dotPeriod"
+								],
+								"+",
+								[5, "0.5"]
+							]]
+						],
+						[
+							6,
+							"d.f32",
+							[[5, "0"]]
+						],
+						"nDot"
+					]
+				]
+			],
+			[
+				13,
+				"cDot",
+				[
+					1,
+					"t",
+					"-",
+					[
+						1,
+						"kDot",
+						"*",
+						"dotPeriod"
+					]
+				]
+			],
+			[
+				13,
+				"isPattern",
+				[
+					1,
+					"style",
+					">=",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"isDotted",
+				[
+					1,
+					"style",
+					">=",
+					[5, "1.5"]
+				]
+			],
+			[
+				13,
+				"c",
+				[
+					6,
+					"std.select",
+					[
+						"cSolid",
+						[
+							6,
+							"std.select",
+							[
+								"cDash",
+								"cDot",
+								"isDotted"
+							]
+						],
+						"isPattern"
+					]
+				]
+			],
+			[
+				13,
+				"axRound",
+				[
+					6,
+					"std.select",
+					[
+						"axSolid",
+						[
+							6,
+							"std.select",
+							[
+								"axDashRound",
+								[
+									6,
+									"d.f32",
+									[[5, "0"]]
+								],
+								"isDotted"
+							]
+						],
+						"isPattern"
+					]
+				]
+			],
+			[
+				13,
+				"axSquare",
+				[
+					6,
+					"std.select",
+					[
+						"axSolid",
+						[
+							6,
+							"std.select",
+							[
+								"axDashSquare",
+								"halfT",
+								"isDotted"
+							]
+						],
+						"isPattern"
+					]
+				]
+			],
+			[
+				13,
+				"capHere",
+				[
+					6,
+					"std.select",
+					[
+						"capStart",
+						"capEnd",
+						[
+							1,
+							"c",
+							">",
+							[5, "0"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"sdRound",
+				[
+					1,
+					[
+						6,
+						"std.length",
+						[[
+							6,
+							"d.vec2f",
+							[[
+								6,
+								"std.max",
+								[[
+									1,
+									[
+										6,
+										"std.abs",
+										["c"]
+									],
+									"-",
+									"axRound"
+								], [
+									6,
+									"d.f32",
+									[[5, "0"]]
+								]]
+							], "perp"]
+						]]
+					],
+					"-",
+					"halfT"
+				]
+			],
+			[
+				13,
+				"qx",
+				[
+					1,
+					[
+						6,
+						"std.abs",
+						["c"]
+					],
+					"-",
+					"axSquare"
+				]
+			],
+			[
+				13,
+				"qy",
+				[
+					1,
+					"perp",
+					"-",
+					"halfT"
+				]
+			],
+			[
+				13,
+				"sdSquare",
+				[
+					1,
+					[
+						6,
+						"std.length",
+						[[
+							6,
+							"d.vec2f",
+							[[
+								6,
+								"std.max",
+								["qx", [
+									6,
+									"d.f32",
+									[[5, "0"]]
+								]]
+							], [
+								6,
+								"std.max",
+								["qy", [
+									6,
+									"d.f32",
+									[[5, "0"]]
+								]]
+							]]
+						]]
+					],
+					"+",
+					[
+						6,
+						"std.min",
+						[[
+							6,
+							"std.max",
+							["qx", "qy"]
+						], [
+							6,
+							"d.f32",
+							[[5, "0"]]
+						]]
+					]
+				]
+			],
+			[
+				13,
+				"sd",
+				[
+					6,
+					"std.select",
+					[
+						"sdSquare",
+						"sdRound",
+						[
+							1,
+							"capHere",
+							">=",
+							[5, "0.5"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"feather",
+				[
+					1,
+					[5, "1"],
+					"/",
+					[
+						7,
+						"viewport",
+						"y"
+					]
+				]
+			],
+			[10, [
+				1,
+				[5, "1"],
+				"-",
+				[
+					6,
+					"std.smoothstep",
+					[
+						[
+							4,
+							"-",
+							"feather"
+						],
+						"feather",
+						"sd"
+					]
+				]
+			]]
+		]]
+	},
+	externals: {
+		"std.max": () => max,
+		"std.length": () => length,
+		"d.vec2f": () => vec2f,
+		"d.f32": () => f32,
+		"EPS": () => EPS,
+		"std.clamp": () => clamp,
+		"std.sqrt": () => sqrt,
+		"std.floor": () => floor,
+		"std.select": () => select,
+		"std.abs": () => abs,
+		"std.min": () => min,
+		"std.smoothstep": () => smoothstep
+	}
+}) && $.f)({}));
+const sineWaveMask = typegpu_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, angle, position, frequency, amplitude, thickness, softness, animTime) => {
+	"use gpu";
+	const aspect = __tsover_div(viewport.x, viewport.y);
+	const aspectCorrectedX = __tsover_mul(uv.x, aspect);
+	const centerX = __tsover_mul(position.x, aspect);
+	const centerY = __tsover_sub(1, position.y);
+	const centeredX = __tsover_sub(aspectCorrectedX, centerX);
+	const centeredY = __tsover_sub(uv.y, centerY);
+	const angleRad = __tsover_mul(angle, DEG_TO_RAD);
+	const cosAngle = cos(angleRad);
+	const sinAngle = sin(angleRad);
+	const rotatedX = __tsover_sub(__tsover_mul(centeredX, cosAngle), __tsover_mul(centeredY, sinAngle));
+	const rotatedY = __tsover_add(__tsover_mul(centeredX, sinAngle), __tsover_mul(centeredY, cosAngle));
+	const waveInput = __tsover_add(__tsover_mul(__tsover_mul(rotatedX, frequency), TAU), animTime);
+	const sineWave = __tsover_mul(sin(waveInput), amplitude);
+	const distanceFromWave = abs(__tsover_sub(rotatedY, sineWave));
+	const halfThickness = __tsover_mul(thickness, .5);
+	const halfSoftness = __tsover_mul(softness, .5);
+	return __tsover_sub(1, smoothstep(__tsover_sub(halfThickness, halfSoftness), __tsover_add(halfThickness, halfSoftness), distanceFromWave));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "viewport"
+			},
+			{
+				"type": "i",
+				"name": "angle"
+			},
+			{
+				"type": "i",
+				"name": "position"
+			},
+			{
+				"type": "i",
+				"name": "frequency"
+			},
+			{
+				"type": "i",
+				"name": "amplitude"
+			},
+			{
+				"type": "i",
+				"name": "thickness"
+			},
+			{
+				"type": "i",
+				"name": "softness"
+			},
+			{
+				"type": "i",
+				"name": "animTime"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"aspect",
+				[
+					1,
+					[
+						7,
+						"viewport",
+						"x"
+					],
+					"/",
+					[
+						7,
+						"viewport",
+						"y"
+					]
+				]
+			],
+			[
+				13,
+				"aspectCorrectedX",
+				[
+					1,
+					[
+						7,
+						"uv",
+						"x"
+					],
+					"*",
+					"aspect"
+				]
+			],
+			[
+				13,
+				"centerX",
+				[
+					1,
+					[
+						7,
+						"position",
+						"x"
+					],
+					"*",
+					"aspect"
+				]
+			],
+			[
+				13,
+				"centerY",
+				[
+					1,
+					[5, "1"],
+					"-",
+					[
+						7,
+						"position",
+						"y"
+					]
+				]
+			],
+			[
+				13,
+				"centeredX",
+				[
+					1,
+					"aspectCorrectedX",
+					"-",
+					"centerX"
+				]
+			],
+			[
+				13,
+				"centeredY",
+				[
+					1,
+					[
+						7,
+						"uv",
+						"y"
+					],
+					"-",
+					"centerY"
+				]
+			],
+			[
+				13,
+				"angleRad",
+				[
+					1,
+					"angle",
+					"*",
+					"DEG_TO_RAD"
+				]
+			],
+			[
+				13,
+				"cosAngle",
+				[
+					6,
+					"std.cos",
+					["angleRad"]
+				]
+			],
+			[
+				13,
+				"sinAngle",
+				[
+					6,
+					"std.sin",
+					["angleRad"]
+				]
+			],
+			[
+				13,
+				"rotatedX",
+				[
+					1,
+					[
+						1,
+						"centeredX",
+						"*",
+						"cosAngle"
+					],
+					"-",
+					[
+						1,
+						"centeredY",
+						"*",
+						"sinAngle"
+					]
+				]
+			],
+			[
+				13,
+				"rotatedY",
+				[
+					1,
+					[
+						1,
+						"centeredX",
+						"*",
+						"sinAngle"
+					],
+					"+",
+					[
+						1,
+						"centeredY",
+						"*",
+						"cosAngle"
+					]
+				]
+			],
+			[
+				13,
+				"waveInput",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							"rotatedX",
+							"*",
+							"frequency"
+						],
+						"*",
+						"TAU"
+					],
+					"+",
+					"animTime"
+				]
+			],
+			[
+				13,
+				"sineWave",
+				[
+					1,
+					[
+						6,
+						"std.sin",
+						["waveInput"]
+					],
+					"*",
+					"amplitude"
+				]
+			],
+			[
+				13,
+				"distanceFromWave",
+				[
+					6,
+					"std.abs",
+					[[
+						1,
+						"rotatedY",
+						"-",
+						"sineWave"
+					]]
+				]
+			],
+			[
+				13,
+				"halfThickness",
+				[
+					1,
+					"thickness",
+					"*",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"halfSoftness",
+				[
+					1,
+					"softness",
+					"*",
+					[5, "0.5"]
+				]
+			],
+			[10, [
+				1,
+				[5, "1"],
+				"-",
+				[
+					6,
+					"std.smoothstep",
+					[
+						[
+							1,
+							"halfThickness",
+							"-",
+							"halfSoftness"
+						],
+						[
+							1,
+							"halfThickness",
+							"+",
+							"halfSoftness"
+						],
+						"distanceFromWave"
+					]
+				]
+			]]
+		]]
+	},
+	externals: {
+		"DEG_TO_RAD": () => DEG_TO_RAD,
+		"std.cos": () => cos,
+		"std.sin": () => sin,
+		"TAU": () => TAU,
+		"std.abs": () => abs,
+		"std.smoothstep": () => smoothstep
+	}
+}) && $.f)({}));
+const blobOrganicRadius = typegpu_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, size, deformation, animTime) => {
+	"use gpu";
+	const ns = f32(4);
+	const at = animTime;
+	const noise1 = __tsover_mul(__tsover_mul(__tsover_add(__tsover_mul(sin(__tsover_add(__tsover_mul(uv.x, __tsover_mul(ns, .8)), __tsover_mul(at, .8))), sin(__tsover_add(__tsover_mul(uv.y, __tsover_mul(ns, .7)), __tsover_mul(at, .6)))), sin(__tsover_sub(__tsover_mul(uv.x, __tsover_mul(ns, 1.2)), __tsover_add(__tsover_mul(uv.y, __tsover_mul(ns, .9)), __tsover_mul(at, .4))))), .15), deformation);
+	const noise2 = __tsover_mul(__tsover_mul(__tsover_mul(sin(__tsover_sub(__tsover_mul(uv.x, __tsover_mul(ns, 1.4)), __tsover_mul(at, .5))), sin(__tsover_add(__tsover_mul(uv.y, __tsover_mul(ns, 1.1)), __tsover_mul(at, .7)))), .12), deformation);
+	const noise3 = __tsover_mul(__tsover_mul(__tsover_add(sin(__tsover_add(__tsover_mul(uv.x, __tsover_mul(ns, 1.8)), __tsover_add(__tsover_mul(uv.y, __tsover_mul(ns, 1.6)), __tsover_mul(at, .3)))), sin(__tsover_sub(__tsover_mul(uv.x, __tsover_mul(ns, .6)), __tsover_mul(at, .9)))), .1), deformation);
+	const noise4 = __tsover_mul(__tsover_mul(__tsover_mul(sin(__tsover_add(__tsover_mul(uv.x, __tsover_mul(ns, 2.2)), __tsover_mul(at, .2))), sin(__tsover_sub(__tsover_mul(uv.y, __tsover_mul(ns, 1.9)), __tsover_mul(at, .8)))), .04), deformation);
+	return __tsover_add(size, __tsover_add(__tsover_add(__tsover_add(noise1, noise2), noise3), noise4));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "size"
+			},
+			{
+				"type": "i",
+				"name": "deformation"
+			},
+			{
+				"type": "i",
+				"name": "animTime"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"ns",
+				[
+					6,
+					"d.f32",
+					[[5, "4"]]
+				]
+			],
+			[
+				13,
+				"at",
+				"animTime"
+			],
+			[
+				13,
+				"noise1",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									6,
+									"std.sin",
+									[[
+										1,
+										[
+											1,
+											[
+												7,
+												"uv",
+												"x"
+											],
+											"*",
+											[
+												1,
+												"ns",
+												"*",
+												[5, "0.8"]
+											]
+										],
+										"+",
+										[
+											1,
+											"at",
+											"*",
+											[5, "0.8"]
+										]
+									]]
+								],
+								"*",
+								[
+									6,
+									"std.sin",
+									[[
+										1,
+										[
+											1,
+											[
+												7,
+												"uv",
+												"y"
+											],
+											"*",
+											[
+												1,
+												"ns",
+												"*",
+												[5, "0.7"]
+											]
+										],
+										"+",
+										[
+											1,
+											"at",
+											"*",
+											[5, "0.6"]
+										]
+									]]
+								]
+							],
+							"+",
+							[
+								6,
+								"std.sin",
+								[[
+									1,
+									[
+										1,
+										[
+											7,
+											"uv",
+											"x"
+										],
+										"*",
+										[
+											1,
+											"ns",
+											"*",
+											[5, "1.2"]
+										]
+									],
+									"-",
+									[
+										1,
+										[
+											1,
+											[
+												7,
+												"uv",
+												"y"
+											],
+											"*",
+											[
+												1,
+												"ns",
+												"*",
+												[5, "0.9"]
+											]
+										],
+										"+",
+										[
+											1,
+											"at",
+											"*",
+											[5, "0.4"]
+										]
+									]
+								]]
+							]
+						],
+						"*",
+						[5, "0.15"]
+					],
+					"*",
+					"deformation"
+				]
+			],
+			[
+				13,
+				"noise2",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								6,
+								"std.sin",
+								[[
+									1,
+									[
+										1,
+										[
+											7,
+											"uv",
+											"x"
+										],
+										"*",
+										[
+											1,
+											"ns",
+											"*",
+											[5, "1.4"]
+										]
+									],
+									"-",
+									[
+										1,
+										"at",
+										"*",
+										[5, "0.5"]
+									]
+								]]
+							],
+							"*",
+							[
+								6,
+								"std.sin",
+								[[
+									1,
+									[
+										1,
+										[
+											7,
+											"uv",
+											"y"
+										],
+										"*",
+										[
+											1,
+											"ns",
+											"*",
+											[5, "1.1"]
+										]
+									],
+									"+",
+									[
+										1,
+										"at",
+										"*",
+										[5, "0.7"]
+									]
+								]]
+							]
+						],
+						"*",
+						[5, "0.12"]
+					],
+					"*",
+					"deformation"
+				]
+			],
+			[
+				13,
+				"noise3",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								6,
+								"std.sin",
+								[[
+									1,
+									[
+										1,
+										[
+											7,
+											"uv",
+											"x"
+										],
+										"*",
+										[
+											1,
+											"ns",
+											"*",
+											[5, "1.8"]
+										]
+									],
+									"+",
+									[
+										1,
+										[
+											1,
+											[
+												7,
+												"uv",
+												"y"
+											],
+											"*",
+											[
+												1,
+												"ns",
+												"*",
+												[5, "1.6"]
+											]
+										],
+										"+",
+										[
+											1,
+											"at",
+											"*",
+											[5, "0.3"]
+										]
+									]
+								]]
+							],
+							"+",
+							[
+								6,
+								"std.sin",
+								[[
+									1,
+									[
+										1,
+										[
+											7,
+											"uv",
+											"x"
+										],
+										"*",
+										[
+											1,
+											"ns",
+											"*",
+											[5, "0.6"]
+										]
+									],
+									"-",
+									[
+										1,
+										"at",
+										"*",
+										[5, "0.9"]
+									]
+								]]
+							]
+						],
+						"*",
+						[5, "0.1"]
+					],
+					"*",
+					"deformation"
+				]
+			],
+			[
+				13,
+				"noise4",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								6,
+								"std.sin",
+								[[
+									1,
+									[
+										1,
+										[
+											7,
+											"uv",
+											"x"
+										],
+										"*",
+										[
+											1,
+											"ns",
+											"*",
+											[5, "2.2"]
+										]
+									],
+									"+",
+									[
+										1,
+										"at",
+										"*",
+										[5, "0.2"]
+									]
+								]]
+							],
+							"*",
+							[
+								6,
+								"std.sin",
+								[[
+									1,
+									[
+										1,
+										[
+											7,
+											"uv",
+											"y"
+										],
+										"*",
+										[
+											1,
+											"ns",
+											"*",
+											[5, "1.9"]
+										]
+									],
+									"-",
+									[
+										1,
+										"at",
+										"*",
+										[5, "0.8"]
+									]
+								]]
+							]
+						],
+						"*",
+						[5, "0.04"]
+					],
+					"*",
+					"deformation"
+				]
+			],
+			[10, [
+				1,
+				"size",
+				"+",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							"noise1",
+							"+",
+							"noise2"
+						],
+						"+",
+						"noise3"
+					],
+					"+",
+					"noise4"
+				]
+			]]
+		]]
+	},
+	externals: {
+		"d.f32": () => f32,
+		"std.sin": () => sin
+	}
+}) && $.f)({}));
+const blobField = typegpu_default.fn([
+	vec2f,
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((baseUV, viewport, center, size, deformation, softness, highlightIntensity, normLx, normLy, normLz, animTime) => {
+	"use gpu";
+	const edgeWidth = __tsover_mul(softness, .3);
+	const edgeCurve = __tsover_add(__tsover_mul(softness, 2), .5);
+	const aspect = __tsover_div(viewport.x, viewport.y);
+	const uv = vec2f(__tsover_sub(__tsover_mul(baseUV.x, aspect), __tsover_mul(center.x, aspect)), __tsover_sub(baseUV.y, __tsover_sub(1, center.y)));
+	const dist = length(uv);
+	const organicRadius = blobOrganicRadius(uv, size, deformation, animTime);
+	const blobMask = pow(__tsover_sub(1, smoothstep(__tsover_sub(organicRadius, edgeWidth), __tsover_add(organicRadius, edgeWidth), dist)), edgeCurve);
+	const normalTilt = smoothstep(0, organicRadius, dist);
+	const fakeZ = __tsover_sub(1, __tsover_mul(normalTilt, .1));
+	const tilted = __tsover_add(normalTilt, .2);
+	const surfaceNormal = normalize(vec3f(__tsover_mul(uv.x, tilted), __tsover_mul(uv.y, tilted), fakeZ));
+	const lightDir = vec3f(normLx, normLy, normLz);
+	const viewDir = vec3f(0, 0, 1);
+	const specular = pow(max(0, dot(reflect(lightDir.mul(-1), surfaceNormal), viewDir)), 32);
+	const curvatureBoost = __tsover_add(__tsover_mul(normalTilt, .5), .5);
+	const finalHighlight = __tsover_mul(__tsover_mul(__tsover_mul(specular, curvatureBoost), highlightIntensity), blobMask);
+	const posX = __tsover_mul(uv.x, 3);
+	const posY = __tsover_mul(uv.y, 3);
+	const colorNoise1 = __tsover_add(__tsover_mul(__tsover_add(__tsover_mul(sin(__tsover_add(posX, __tsover_mul(animTime, .4))), sin(__tsover_add(posY, __tsover_mul(animTime, .3)))), sin(__tsover_add(__tsover_add(__tsover_mul(posX, .7), __tsover_mul(posY, .8)), __tsover_mul(animTime, .2)))), .5), .5);
+	const colorNoise2 = __tsover_add(__tsover_mul(__tsover_add(__tsover_mul(sin(__tsover_sub(__tsover_mul(posX, 1.3), __tsover_mul(animTime, .5))), sin(__tsover_add(__tsover_mul(posY, 1.1), __tsover_mul(animTime, .6)))), sin(__tsover_sub(__tsover_mul(posX, .5), __tsover_sub(__tsover_mul(posY, .6), __tsover_mul(animTime, .3))))), .5), .5);
+	return vec3f(smoothstep(.1, .9, __tsover_add(__tsover_mul(colorNoise1, .6), __tsover_mul(colorNoise2, .4))), finalHighlight, blobMask);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "baseUV"
+			},
+			{
+				"type": "i",
+				"name": "viewport"
+			},
+			{
+				"type": "i",
+				"name": "center"
+			},
+			{
+				"type": "i",
+				"name": "size"
+			},
+			{
+				"type": "i",
+				"name": "deformation"
+			},
+			{
+				"type": "i",
+				"name": "softness"
+			},
+			{
+				"type": "i",
+				"name": "highlightIntensity"
+			},
+			{
+				"type": "i",
+				"name": "normLx"
+			},
+			{
+				"type": "i",
+				"name": "normLy"
+			},
+			{
+				"type": "i",
+				"name": "normLz"
+			},
+			{
+				"type": "i",
+				"name": "animTime"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"edgeWidth",
+				[
+					1,
+					"softness",
+					"*",
+					[5, "0.3"]
+				]
+			],
+			[
+				13,
+				"edgeCurve",
+				[
+					1,
+					[
+						1,
+						"softness",
+						"*",
+						[5, "2"]
+					],
+					"+",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"aspect",
+				[
+					1,
+					[
+						7,
+						"viewport",
+						"x"
+					],
+					"/",
+					[
+						7,
+						"viewport",
+						"y"
+					]
+				]
+			],
+			[
+				13,
+				"uv",
+				[
+					6,
+					"d.vec2f",
+					[[
+						1,
+						[
+							1,
+							[
+								7,
+								"baseUV",
+								"x"
+							],
+							"*",
+							"aspect"
+						],
+						"-",
+						[
+							1,
+							[
+								7,
+								"center",
+								"x"
+							],
+							"*",
+							"aspect"
+						]
+					], [
+						1,
+						[
+							7,
+							"baseUV",
+							"y"
+						],
+						"-",
+						[
+							1,
+							[5, "1"],
+							"-",
+							[
+								7,
+								"center",
+								"y"
+							]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"dist",
+				[
+					6,
+					"std.length",
+					["uv"]
+				]
+			],
+			[
+				13,
+				"organicRadius",
+				[
+					6,
+					"blobOrganicRadius",
+					[
+						"uv",
+						"size",
+						"deformation",
+						"animTime"
+					]
+				]
+			],
+			[
+				13,
+				"linearMask",
+				[
+					1,
+					[5, "1"],
+					"-",
+					[
+						6,
+						"std.smoothstep",
+						[
+							[
+								1,
+								"organicRadius",
+								"-",
+								"edgeWidth"
+							],
+							[
+								1,
+								"organicRadius",
+								"+",
+								"edgeWidth"
+							],
+							"dist"
+						]
+					]
+				]
+			],
+			[
+				13,
+				"blobMask",
+				[
+					6,
+					"std.pow",
+					["linearMask", "edgeCurve"]
+				]
+			],
+			[
+				13,
+				"normalTilt",
+				[
+					6,
+					"std.smoothstep",
+					[
+						[5, "0"],
+						"organicRadius",
+						"dist"
+					]
+				]
+			],
+			[
+				13,
+				"fakeZ",
+				[
+					1,
+					[5, "1"],
+					"-",
+					[
+						1,
+						"normalTilt",
+						"*",
+						[5, "0.1"]
+					]
+				]
+			],
+			[
+				13,
+				"tilted",
+				[
+					1,
+					"normalTilt",
+					"+",
+					[5, "0.2"]
+				]
+			],
+			[
+				13,
+				"surfaceNormal",
+				[
+					6,
+					"std.normalize",
+					[[
+						6,
+						"d.vec3f",
+						[
+							[
+								1,
+								[
+									7,
+									"uv",
+									"x"
+								],
+								"*",
+								"tilted"
+							],
+							[
+								1,
+								[
+									7,
+									"uv",
+									"y"
+								],
+								"*",
+								"tilted"
+							],
+							"fakeZ"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"lightDir",
+				[
+					6,
+					"d.vec3f",
+					[
+						"normLx",
+						"normLy",
+						"normLz"
+					]
+				]
+			],
+			[
+				13,
+				"viewDir",
+				[
+					6,
+					"d.vec3f",
+					[
+						[5, "0"],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"reflectDir",
+				[
+					6,
+					"std.reflect",
+					[[
+						6,
+						[
+							7,
+							"lightDir",
+							"mul"
+						],
+						[[
+							4,
+							"-",
+							[5, "1"]
+						]]
+					], "surfaceNormal"]
+				]
+			],
+			[
+				13,
+				"specDot",
+				[
+					6,
+					"std.max",
+					[[5, "0"], [
+						6,
+						"std.dot",
+						["reflectDir", "viewDir"]
+					]]
+				]
+			],
+			[
+				13,
+				"specular",
+				[
+					6,
+					"std.pow",
+					["specDot", [5, "32"]]
+				]
+			],
+			[
+				13,
+				"curvatureBoost",
+				[
+					1,
+					[
+						1,
+						"normalTilt",
+						"*",
+						[5, "0.5"]
+					],
+					"+",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"finalHighlight",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							"specular",
+							"*",
+							"curvatureBoost"
+						],
+						"*",
+						"highlightIntensity"
+					],
+					"*",
+					"blobMask"
+				]
+			],
+			[
+				13,
+				"posX",
+				[
+					1,
+					[
+						7,
+						"uv",
+						"x"
+					],
+					"*",
+					[5, "3"]
+				]
+			],
+			[
+				13,
+				"posY",
+				[
+					1,
+					[
+						7,
+						"uv",
+						"y"
+					],
+					"*",
+					[5, "3"]
+				]
+			],
+			[
+				13,
+				"colorNoise1",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									6,
+									"std.sin",
+									[[
+										1,
+										"posX",
+										"+",
+										[
+											1,
+											"animTime",
+											"*",
+											[5, "0.4"]
+										]
+									]]
+								],
+								"*",
+								[
+									6,
+									"std.sin",
+									[[
+										1,
+										"posY",
+										"+",
+										[
+											1,
+											"animTime",
+											"*",
+											[5, "0.3"]
+										]
+									]]
+								]
+							],
+							"+",
+							[
+								6,
+								"std.sin",
+								[[
+									1,
+									[
+										1,
+										[
+											1,
+											"posX",
+											"*",
+											[5, "0.7"]
+										],
+										"+",
+										[
+											1,
+											"posY",
+											"*",
+											[5, "0.8"]
+										]
+									],
+									"+",
+									[
+										1,
+										"animTime",
+										"*",
+										[5, "0.2"]
+									]
+								]]
+							]
+						],
+						"*",
+						[5, "0.5"]
+					],
+					"+",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"colorNoise2",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									6,
+									"std.sin",
+									[[
+										1,
+										[
+											1,
+											"posX",
+											"*",
+											[5, "1.3"]
+										],
+										"-",
+										[
+											1,
+											"animTime",
+											"*",
+											[5, "0.5"]
+										]
+									]]
+								],
+								"*",
+								[
+									6,
+									"std.sin",
+									[[
+										1,
+										[
+											1,
+											"posY",
+											"*",
+											[5, "1.1"]
+										],
+										"+",
+										[
+											1,
+											"animTime",
+											"*",
+											[5, "0.6"]
+										]
+									]]
+								]
+							],
+							"+",
+							[
+								6,
+								"std.sin",
+								[[
+									1,
+									[
+										1,
+										"posX",
+										"*",
+										[5, "0.5"]
+									],
+									"-",
+									[
+										1,
+										[
+											1,
+											"posY",
+											"*",
+											[5, "0.6"]
+										],
+										"-",
+										[
+											1,
+											"animTime",
+											"*",
+											[5, "0.3"]
+										]
+									]
+								]]
+							]
+						],
+						"*",
+						[5, "0.5"]
+					],
+					"+",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"combinedNoise",
+				[
+					1,
+					[
+						1,
+						"colorNoise1",
+						"*",
+						[5, "0.6"]
+					],
+					"+",
+					[
+						1,
+						"colorNoise2",
+						"*",
+						[5, "0.4"]
+					]
+				]
+			],
+			[
+				13,
+				"mixFactor",
+				[
+					6,
+					"std.smoothstep",
+					[
+						[5, "0.1"],
+						[5, "0.9"],
+						"combinedNoise"
+					]
+				]
+			],
+			[10, [
+				6,
+				"d.vec3f",
+				[
+					"mixFactor",
+					"finalHighlight",
+					"blobMask"
+				]
+			]]
+		]]
+	},
+	externals: {
+		"d.vec2f": () => vec2f,
+		"std.length": () => length,
+		"blobOrganicRadius": () => blobOrganicRadius,
+		"std.smoothstep": () => smoothstep,
+		"std.pow": () => pow,
+		"std.normalize": () => normalize,
+		"d.vec3f": () => vec3f,
+		"std.reflect": () => reflect,
+		"std.max": () => max,
+		"std.dot": () => dot,
+		"std.sin": () => sin
+	}
+}) && $.f)({}));
+const blobCompose = typegpu_default.fn([
+	vec4f,
+	vec4f,
+	f32,
+	f32,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((colorMix, highlightColor, finalHighlight, avgAlpha, blobMask) => {
+	"use gpu";
+	const highlightContribution = highlightColor.xyz.mul(finalHighlight);
+	return vec4f(colorMix.xyz.add(highlightContribution), __tsover_mul(avgAlpha, blobMask));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "colorMix"
+			},
+			{
+				"type": "i",
+				"name": "highlightColor"
+			},
+			{
+				"type": "i",
+				"name": "finalHighlight"
+			},
+			{
+				"type": "i",
+				"name": "avgAlpha"
+			},
+			{
+				"type": "i",
+				"name": "blobMask"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"highlightContribution",
+				[
+					6,
+					[
+						7,
+						[
+							7,
+							"highlightColor",
+							"xyz"
+						],
+						"mul"
+					],
+					["finalHighlight"]
+				]
+			],
+			[
+				13,
+				"rgb",
+				[
+					6,
+					[
+						7,
+						[
+							7,
+							"colorMix",
+							"xyz"
+						],
+						"add"
+					],
+					["highlightContribution"]
+				]
+			],
+			[10, [
+				6,
+				"d.vec4f",
+				["rgb", [
+					1,
+					"avgAlpha",
+					"*",
+					"blobMask"
+				]]
+			]]
+		]]
+	},
+	externals: { "d.vec4f": () => vec4f }
+}) && $.f)({}));
+var lensFlareSpectral = typegpu_default.fn([f32], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((t) => {
+	"use gpu";
+	return vec3f(__tsover_add(__tsover_mul(cos(__tsover_mul(TAU, t)), .5), .5), __tsover_add(__tsover_mul(cos(__tsover_mul(TAU, __tsover_sub(t, .333))), .5), .5), __tsover_add(__tsover_mul(cos(__tsover_mul(TAU, __tsover_sub(t, .666))), .5), .5));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "t"
+		}],
+		"body": [0, [[10, [
+			6,
+			"d.vec3f",
+			[
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							"std.cos",
+							[[
+								1,
+								"TAU_FULL",
+								"*",
+								"t"
+							]]
+						],
+						"*",
+						[5, "0.5"]
+					],
+					"+",
+					[5, "0.5"]
+				],
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							"std.cos",
+							[[
+								1,
+								"TAU_FULL",
+								"*",
+								[
+									1,
+									"t",
+									"-",
+									[5, "0.333"]
+								]
+							]]
+						],
+						"*",
+						[5, "0.5"]
+					],
+					"+",
+					[5, "0.5"]
+				],
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							"std.cos",
+							[[
+								1,
+								"TAU_FULL",
+								"*",
+								[
+									1,
+									"t",
+									"-",
+									[5, "0.666"]
+								]
+							]]
+						],
+						"*",
+						[5, "0.5"]
+					],
+					"+",
+					[5, "0.5"]
+				]
+			]
+		]]]]
+	},
+	externals: {
+		"d.vec3f": () => vec3f,
+		"std.cos": () => cos,
+		"TAU_FULL": () => TAU
+	}
+}) && $.f)({}));
+const FlareFrame = struct({
+	aspect: f32,
+	lightPos: vec2f,
+	flareAxis: vec2f,
+	masterFade: f32,
+	lightDist: f32,
+	lightAngle: f32
+}).$name("FlareFrame");
+const flareFrame = typegpu_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	vec2f,
+	f32,
+	f32
+], FlareFrame)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, t, lightPosRaw, intensity, edgeFade) => {
+	"use gpu";
+	const aspect = aspectOf(viewport);
+	const lightPos = vec2f(lightPosRaw.x, __tsover_sub(1, lightPosRaw.y));
+	const flareAxis = vec2f(__tsover_sub(.5, lightPos.x), __tsover_sub(.5, lightPos.y));
+	const shimmer = __tsover_add(__tsover_add(__tsover_add(__tsover_mul(sin(__tsover_mul(t, 3.7)), .04), __tsover_mul(sin(__tsover_mul(t, 7.3)), .03)), __tsover_mul(sin(__tsover_mul(t, 13.1)), .02)), .97);
+	const edgeDist = max(__tsover_mul(abs(__tsover_sub(lightPos.x, .5)), 2), __tsover_mul(abs(__tsover_sub(lightPos.y, .5)), 2));
+	const fadeStart = __tsover_sub(1, __tsover_mul(edgeFade, .5));
+	const edgeFadeV = mix(1, __tsover_sub(1, smoothstep(fadeStart, 1, edgeDist)), edgeFade);
+	const masterFade = __tsover_mul(__tsover_mul(intensity, edgeFadeV), shimmer);
+	const toLightAR = vec2f(__tsover_mul(__tsover_sub(uv.x, lightPos.x), aspect), __tsover_sub(uv.y, lightPos.y));
+	return FlareFrame({
+		aspect,
+		lightPos,
+		flareAxis,
+		masterFade,
+		lightDist: length(toLightAR),
+		lightAngle: atan2(toLightAR.y, toLightAR.x)
+	});
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "viewport"
+			},
+			{
+				"type": "i",
+				"name": "t"
+			},
+			{
+				"type": "i",
+				"name": "lightPosRaw"
+			},
+			{
+				"type": "i",
+				"name": "intensity"
+			},
+			{
+				"type": "i",
+				"name": "edgeFade"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"aspect",
+				[
+					6,
+					"geom.aspectOf",
+					["viewport"]
+				]
+			],
+			[
+				13,
+				"lightPos",
+				[
+					6,
+					"d.vec2f",
+					[[
+						7,
+						"lightPosRaw",
+						"x"
+					], [
+						1,
+						[5, "1"],
+						"-",
+						[
+							7,
+							"lightPosRaw",
+							"y"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"flareAxis",
+				[
+					6,
+					"d.vec2f",
+					[[
+						1,
+						[5, "0.5"],
+						"-",
+						[
+							7,
+							"lightPos",
+							"x"
+						]
+					], [
+						1,
+						[5, "0.5"],
+						"-",
+						[
+							7,
+							"lightPos",
+							"y"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"shimmer",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									6,
+									"std.sin",
+									[[
+										1,
+										"t",
+										"*",
+										[5, "3.7"]
+									]]
+								],
+								"*",
+								[5, "0.04"]
+							],
+							"+",
+							[
+								1,
+								[
+									6,
+									"std.sin",
+									[[
+										1,
+										"t",
+										"*",
+										[5, "7.3"]
+									]]
+								],
+								"*",
+								[5, "0.03"]
+							]
+						],
+						"+",
+						[
+							1,
+							[
+								6,
+								"std.sin",
+								[[
+									1,
+									"t",
+									"*",
+									[5, "13.1"]
+								]]
+							],
+							"*",
+							[5, "0.02"]
+						]
+					],
+					"+",
+					[5, "0.97"]
+				]
+			],
+			[
+				13,
+				"edgeDist",
+				[
+					6,
+					"std.max",
+					[[
+						1,
+						[
+							6,
+							"std.abs",
+							[[
+								1,
+								[
+									7,
+									"lightPos",
+									"x"
+								],
+								"-",
+								[5, "0.5"]
+							]]
+						],
+						"*",
+						[5, "2"]
+					], [
+						1,
+						[
+							6,
+							"std.abs",
+							[[
+								1,
+								[
+									7,
+									"lightPos",
+									"y"
+								],
+								"-",
+								[5, "0.5"]
+							]]
+						],
+						"*",
+						[5, "2"]
+					]]
+				]
+			],
+			[
+				13,
+				"fadeStart",
+				[
+					1,
+					[5, "1"],
+					"-",
+					[
+						1,
+						"edgeFade",
+						"*",
+						[5, "0.5"]
+					]
+				]
+			],
+			[
+				13,
+				"edgeFadeV",
+				[
+					6,
+					"std.mix",
+					[
+						[5, "1"],
+						[
+							1,
+							[5, "1"],
+							"-",
+							[
+								6,
+								"std.smoothstep",
+								[
+									"fadeStart",
+									[5, "1"],
+									"edgeDist"
+								]
+							]
+						],
+						"edgeFade"
+					]
+				]
+			],
+			[
+				13,
+				"masterFade",
+				[
+					1,
+					[
+						1,
+						"intensity",
+						"*",
+						"edgeFadeV"
+					],
+					"*",
+					"shimmer"
+				]
+			],
+			[
+				13,
+				"toLightAR",
+				[
+					6,
+					"d.vec2f",
+					[[
+						1,
+						[
+							1,
+							[
+								7,
+								"uv",
+								"x"
+							],
+							"-",
+							[
+								7,
+								"lightPos",
+								"x"
+							]
+						],
+						"*",
+						"aspect"
+					], [
+						1,
+						[
+							7,
+							"uv",
+							"y"
+						],
+						"-",
+						[
+							7,
+							"lightPos",
+							"y"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"lightDist",
+				[
+					6,
+					"std.length",
+					["toLightAR"]
+				]
+			],
+			[
+				13,
+				"lightAngle",
+				[
+					6,
+					"std.atan2",
+					[[
+						7,
+						"toLightAR",
+						"y"
+					], [
+						7,
+						"toLightAR",
+						"x"
+					]]
+				]
+			],
+			[10, [
+				6,
+				"FlareFrame",
+				[[104, {
+					"aspect": "aspect",
+					"lightPos": "lightPos",
+					"flareAxis": "flareAxis",
+					"masterFade": "masterFade",
+					"lightDist": "lightDist",
+					"lightAngle": "lightAngle"
+				}]]
+			]]
+		]]
+	},
+	externals: {
+		"geom.aspectOf": () => aspectOf,
+		"d.vec2f": () => vec2f,
+		"std.sin": () => sin,
+		"std.max": () => max,
+		"std.abs": () => abs,
+		"std.mix": () => mix,
+		"std.smoothstep": () => smoothstep,
+		"std.length": () => length,
+		"std.atan2": () => atan2,
+		"FlareFrame": () => FlareFrame
+	}
+}) && $.f)({}));
+const lensFlareGhost = typegpu_default.fn([
+	vec2f,
+	f32,
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	vec4f,
+	vec4f
+], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, lightPos, flareAxis, t, ghostSpread, ghostChroma, ghostInt, disc, tint) => {
+	"use gpu";
+	const offset = disc.x;
+	const size = disc.y;
+	const bright = disc.z;
+	const hollow = disc.w;
+	const r = tint.x;
+	const g = tint.y;
+	const b = tint.z;
+	const gPhase = tint.w;
+	const ghostPos = lightPos.add(flareAxis.mul(__tsover_mul(__tsover_mul(offset, ghostSpread), 2)));
+	const dist = length(vec2f(__tsover_mul(__tsover_sub(uv.x, ghostPos.x), aspect), __tsover_sub(uv.y, ghostPos.y)));
+	const sz = size;
+	const discShape = __tsover_sub(1, smoothstep(__tsover_mul(sz, .12), sz, dist));
+	const innerFade = __tsover_sub(1, smoothstep(__tsover_mul(sz, .05), __tsover_mul(sz, .45), dist));
+	const shape = __tsover_mul(discShape, __tsover_sub(1, __tsover_mul(innerFade, hollow)));
+	const gShimmer = __tsover_add(__tsover_add(__tsover_mul(sin(__tsover_add(__tsover_mul(t, 4.3), gPhase)), .08), __tsover_mul(sin(__tsover_add(__tsover_mul(t, 9.1), __tsover_mul(gPhase, 1.7))), .05)), .95);
+	const ring = chromaticRingBand(dist, __tsover_mul(sz, .78), __tsover_mul(__tsover_mul(sz, ghostChroma), .14), __tsover_mul(sz, .1));
+	const rRing = ring.x;
+	const gRing = ring.y;
+	const bRing = ring.z;
+	const brightness = __tsover_mul(__tsover_mul(bright, ghostInt), gShimmer);
+	return vec3f(__tsover_mul(__tsover_add(__tsover_mul(shape, r), __tsover_mul(rRing, ghostChroma)), brightness), __tsover_mul(__tsover_add(__tsover_mul(shape, g), __tsover_mul(gRing, ghostChroma)), brightness), __tsover_mul(__tsover_add(__tsover_mul(shape, b), __tsover_mul(bRing, ghostChroma)), brightness));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "aspect"
+			},
+			{
+				"type": "i",
+				"name": "lightPos"
+			},
+			{
+				"type": "i",
+				"name": "flareAxis"
+			},
+			{
+				"type": "i",
+				"name": "t"
+			},
+			{
+				"type": "i",
+				"name": "ghostSpread"
+			},
+			{
+				"type": "i",
+				"name": "ghostChroma"
+			},
+			{
+				"type": "i",
+				"name": "ghostInt"
+			},
+			{
+				"type": "i",
+				"name": "disc"
+			},
+			{
+				"type": "i",
+				"name": "tint"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"offset",
+				[
+					7,
+					"disc",
+					"x"
+				]
+			],
+			[
+				13,
+				"size",
+				[
+					7,
+					"disc",
+					"y"
+				]
+			],
+			[
+				13,
+				"bright",
+				[
+					7,
+					"disc",
+					"z"
+				]
+			],
+			[
+				13,
+				"hollow",
+				[
+					7,
+					"disc",
+					"w"
+				]
+			],
+			[
+				13,
+				"r",
+				[
+					7,
+					"tint",
+					"x"
+				]
+			],
+			[
+				13,
+				"g",
+				[
+					7,
+					"tint",
+					"y"
+				]
+			],
+			[
+				13,
+				"b",
+				[
+					7,
+					"tint",
+					"z"
+				]
+			],
+			[
+				13,
+				"gPhase",
+				[
+					7,
+					"tint",
+					"w"
+				]
+			],
+			[
+				13,
+				"ghostPos",
+				[
+					6,
+					[
+						7,
+						"lightPos",
+						"add"
+					],
+					[[
+						6,
+						[
+							7,
+							"flareAxis",
+							"mul"
+						],
+						[[
+							1,
+							[
+								1,
+								"offset",
+								"*",
+								"ghostSpread"
+							],
+							"*",
+							[5, "2"]
+						]]
+					]]
+				]
+			],
+			[
+				13,
+				"toGhost",
+				[
+					6,
+					"d.vec2f",
+					[[
+						1,
+						[
+							1,
+							[
+								7,
+								"uv",
+								"x"
+							],
+							"-",
+							[
+								7,
+								"ghostPos",
+								"x"
+							]
+						],
+						"*",
+						"aspect"
+					], [
+						1,
+						[
+							7,
+							"uv",
+							"y"
+						],
+						"-",
+						[
+							7,
+							"ghostPos",
+							"y"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"dist",
+				[
+					6,
+					"std.length",
+					["toGhost"]
+				]
+			],
+			[
+				13,
+				"sz",
+				"size"
+			],
+			[
+				13,
+				"discShape",
+				[
+					1,
+					[5, "1"],
+					"-",
+					[
+						6,
+						"std.smoothstep",
+						[
+							[
+								1,
+								"sz",
+								"*",
+								[5, "0.12"]
+							],
+							"sz",
+							"dist"
+						]
+					]
+				]
+			],
+			[
+				13,
+				"innerFade",
+				[
+					1,
+					[5, "1"],
+					"-",
+					[
+						6,
+						"std.smoothstep",
+						[
+							[
+								1,
+								"sz",
+								"*",
+								[5, "0.05"]
+							],
+							[
+								1,
+								"sz",
+								"*",
+								[5, "0.45"]
+							],
+							"dist"
+						]
+					]
+				]
+			],
+			[
+				13,
+				"shape",
+				[
+					1,
+					"discShape",
+					"*",
+					[
+						1,
+						[5, "1"],
+						"-",
+						[
+							1,
+							"innerFade",
+							"*",
+							"hollow"
+						]
+					]
+				]
+			],
+			[
+				13,
+				"gShimmer",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								6,
+								"std.sin",
+								[[
+									1,
+									[
+										1,
+										"t",
+										"*",
+										[5, "4.3"]
+									],
+									"+",
+									"gPhase"
+								]]
+							],
+							"*",
+							[5, "0.08"]
+						],
+						"+",
+						[
+							1,
+							[
+								6,
+								"std.sin",
+								[[
+									1,
+									[
+										1,
+										"t",
+										"*",
+										[5, "9.1"]
+									],
+									"+",
+									[
+										1,
+										"gPhase",
+										"*",
+										[5, "1.7"]
+									]
+								]]
+							],
+							"*",
+							[5, "0.05"]
+						]
+					],
+					"+",
+					[5, "0.95"]
+				]
+			],
+			[
+				13,
+				"ringCenter",
+				[
+					1,
+					"sz",
+					"*",
+					[5, "0.78"]
+				]
+			],
+			[
+				13,
+				"chromaSpread",
+				[
+					1,
+					[
+						1,
+						"sz",
+						"*",
+						"ghostChroma"
+					],
+					"*",
+					[5, "0.14"]
+				]
+			],
+			[
+				13,
+				"ringWidth",
+				[
+					1,
+					"sz",
+					"*",
+					[5, "0.1"]
+				]
+			],
+			[
+				13,
+				"ring",
+				[
+					6,
+					"lightfields.chromaticRingBand",
+					[
+						"dist",
+						"ringCenter",
+						"chromaSpread",
+						"ringWidth"
+					]
+				]
+			],
+			[
+				13,
+				"rRing",
+				[
+					7,
+					"ring",
+					"x"
+				]
+			],
+			[
+				13,
+				"gRing",
+				[
+					7,
+					"ring",
+					"y"
+				]
+			],
+			[
+				13,
+				"bRing",
+				[
+					7,
+					"ring",
+					"z"
+				]
+			],
+			[
+				13,
+				"brightness",
+				[
+					1,
+					[
+						1,
+						"bright",
+						"*",
+						"ghostInt"
+					],
+					"*",
+					"gShimmer"
+				]
+			],
+			[10, [
+				6,
+				"d.vec3f",
+				[
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								"shape",
+								"*",
+								"r"
+							],
+							"+",
+							[
+								1,
+								"rRing",
+								"*",
+								"ghostChroma"
+							]
+						],
+						"*",
+						"brightness"
+					],
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								"shape",
+								"*",
+								"g"
+							],
+							"+",
+							[
+								1,
+								"gRing",
+								"*",
+								"ghostChroma"
+							]
+						],
+						"*",
+						"brightness"
+					],
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								"shape",
+								"*",
+								"b"
+							],
+							"+",
+							[
+								1,
+								"bRing",
+								"*",
+								"ghostChroma"
+							]
+						],
+						"*",
+						"brightness"
+					]
+				]
+			]]
+		]]
+	},
+	externals: {
+		"d.vec2f": () => vec2f,
+		"std.length": () => length,
+		"std.smoothstep": () => smoothstep,
+		"std.sin": () => sin,
+		"lightfields.chromaticRingBand": () => chromaticRingBand,
+		"d.vec3f": () => vec3f
+	}
+}) && $.f)({}));
+const flareHalo = typegpu_default.fn([
+	vec2f,
+	f32,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, lightPos, t, haloInt, haloRad, haloChroma, haloSoft) => {
+	"use gpu";
+	const antiLight = vec2f(__tsover_sub(1, lightPos.x), __tsover_sub(1, lightPos.y));
+	const toAntiLight = vec2f(__tsover_mul(__tsover_sub(uv.x, antiLight.x), aspect), __tsover_sub(uv.y, antiLight.y));
+	const halo = chromaticRingBand(length(toAntiLight), haloRad, __tsover_mul(__tsover_mul(haloRad, haloChroma), .06), __tsover_add(__tsover_mul(haloSoft, .12), .005));
+	const haloAngle = atan2(toAntiLight.y, toAntiLight.x);
+	const haloAngVar = __tsover_add(__tsover_mul(sin(__tsover_add(__tsover_mul(haloAngle, 3), __tsover_mul(t, .5))), .12), .88);
+	return halo.mul(haloInt).mul(haloAngVar);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "aspect"
+			},
+			{
+				"type": "i",
+				"name": "lightPos"
+			},
+			{
+				"type": "i",
+				"name": "t"
+			},
+			{
+				"type": "i",
+				"name": "haloInt"
+			},
+			{
+				"type": "i",
+				"name": "haloRad"
+			},
+			{
+				"type": "i",
+				"name": "haloChroma"
+			},
+			{
+				"type": "i",
+				"name": "haloSoft"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"antiLight",
+				[
+					6,
+					"d.vec2f",
+					[[
+						1,
+						[5, "1"],
+						"-",
+						[
+							7,
+							"lightPos",
+							"x"
+						]
+					], [
+						1,
+						[5, "1"],
+						"-",
+						[
+							7,
+							"lightPos",
+							"y"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"toAntiLight",
+				[
+					6,
+					"d.vec2f",
+					[[
+						1,
+						[
+							1,
+							[
+								7,
+								"uv",
+								"x"
+							],
+							"-",
+							[
+								7,
+								"antiLight",
+								"x"
+							]
+						],
+						"*",
+						"aspect"
+					], [
+						1,
+						[
+							7,
+							"uv",
+							"y"
+						],
+						"-",
+						[
+							7,
+							"antiLight",
+							"y"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"antiLightDist",
+				[
+					6,
+					"std.length",
+					["toAntiLight"]
+				]
+			],
+			[
+				13,
+				"haloChromaSpread",
+				[
+					1,
+					[
+						1,
+						"haloRad",
+						"*",
+						"haloChroma"
+					],
+					"*",
+					[5, "0.06"]
+				]
+			],
+			[
+				13,
+				"haloWidth",
+				[
+					1,
+					[
+						1,
+						"haloSoft",
+						"*",
+						[5, "0.12"]
+					],
+					"+",
+					[5, "0.005"]
+				]
+			],
+			[
+				13,
+				"halo",
+				[
+					6,
+					"lightfields.chromaticRingBand",
+					[
+						"antiLightDist",
+						"haloRad",
+						"haloChromaSpread",
+						"haloWidth"
+					]
+				]
+			],
+			[
+				13,
+				"haloAngle",
+				[
+					6,
+					"std.atan2",
+					[[
+						7,
+						"toAntiLight",
+						"y"
+					], [
+						7,
+						"toAntiLight",
+						"x"
+					]]
+				]
+			],
+			[
+				13,
+				"haloAngVar",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							"std.sin",
+							[[
+								1,
+								[
+									1,
+									"haloAngle",
+									"*",
+									[5, "3"]
+								],
+								"+",
+								[
+									1,
+									"t",
+									"*",
+									[5, "0.5"]
+								]
+							]]
+						],
+						"*",
+						[5, "0.12"]
+					],
+					"+",
+					[5, "0.88"]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					[
+						6,
+						[
+							7,
+							"halo",
+							"mul"
+						],
+						["haloInt"]
+					],
+					"mul"
+				],
+				["haloAngVar"]
+			]]
+		]]
+	},
+	externals: {
+		"d.vec2f": () => vec2f,
+		"std.length": () => length,
+		"lightfields.chromaticRingBand": () => chromaticRingBand,
+		"std.atan2": () => atan2,
+		"std.sin": () => sin
+	}
+}) && $.f)({}));
+const flareStarburst = typegpu_default.fn([
+	f32,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((lightAngle, flareAxis, aspect, t, lightDist, starburstPts, starburstInt) => {
+	"use gpu";
+	const axisAng = atan2(flareAxis.y, __tsover_mul(flareAxis.x, aspect));
+	const rotation = __tsover_add(__tsover_mul(axisAng, .5), __tsover_mul(t, .06));
+	const spikeAngle = __tsover_add(lightAngle, rotation);
+	const primarySpikes = angularCosineSpikes(spikeAngle, __tsover_div(starburstPts, 2), 3.5);
+	const secondarySpikes = __tsover_mul(angularCosineSpikes(__tsover_add(spikeAngle, .25), __tsover_div(starburstPts, 2), 7), .4);
+	const radialFall = __tsover_div(1, __tsover_add(1, __tsover_mul(__tsover_mul(lightDist, lightDist), 60)));
+	const starSpectral = lensFlareSpectral(__tsover_add(__tsover_div(spikeAngle, TAU), .5));
+	return mix(vec3f(1, .97, .92), starSpectral, .12).mul(__tsover_mul(__tsover_mul(__tsover_add(primarySpikes, secondarySpikes), radialFall), starburstInt));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "lightAngle"
+			},
+			{
+				"type": "i",
+				"name": "flareAxis"
+			},
+			{
+				"type": "i",
+				"name": "aspect"
+			},
+			{
+				"type": "i",
+				"name": "t"
+			},
+			{
+				"type": "i",
+				"name": "lightDist"
+			},
+			{
+				"type": "i",
+				"name": "starburstPts"
+			},
+			{
+				"type": "i",
+				"name": "starburstInt"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"axisAng",
+				[
+					6,
+					"std.atan2",
+					[[
+						7,
+						"flareAxis",
+						"y"
+					], [
+						1,
+						[
+							7,
+							"flareAxis",
+							"x"
+						],
+						"*",
+						"aspect"
+					]]
+				]
+			],
+			[
+				13,
+				"rotation",
+				[
+					1,
+					[
+						1,
+						"axisAng",
+						"*",
+						[5, "0.5"]
+					],
+					"+",
+					[
+						1,
+						"t",
+						"*",
+						[5, "0.06"]
+					]
+				]
+			],
+			[
+				13,
+				"spikeAngle",
+				[
+					1,
+					"lightAngle",
+					"+",
+					"rotation"
+				]
+			],
+			[
+				13,
+				"primarySpikes",
+				[
+					6,
+					"lightfields.angularCosineSpikes",
+					[
+						"spikeAngle",
+						[
+							1,
+							"starburstPts",
+							"/",
+							[5, "2"]
+						],
+						[5, "3.5"]
+					]
+				]
+			],
+			[
+				13,
+				"secondarySpikes",
+				[
+					1,
+					[
+						6,
+						"lightfields.angularCosineSpikes",
+						[
+							[
+								1,
+								"spikeAngle",
+								"+",
+								[5, "0.25"]
+							],
+							[
+								1,
+								"starburstPts",
+								"/",
+								[5, "2"]
+							],
+							[5, "7"]
+						]
+					],
+					"*",
+					[5, "0.4"]
+				]
+			],
+			[
+				13,
+				"radialFall",
+				[
+					1,
+					[5, "1"],
+					"/",
+					[
+						1,
+						[5, "1"],
+						"+",
+						[
+							1,
+							[
+								1,
+								"lightDist",
+								"*",
+								"lightDist"
+							],
+							"*",
+							[5, "60"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"starSpectral",
+				[
+					6,
+					"lensFlareSpectral",
+					[[
+						1,
+						[
+							1,
+							"spikeAngle",
+							"/",
+							"TAU_FULL"
+						],
+						"+",
+						[5, "0.5"]
+					]]
+				]
+			],
+			[
+				13,
+				"starTint",
+				[
+					6,
+					"std.mix",
+					[
+						[
+							6,
+							"d.vec3f",
+							[
+								[5, "1"],
+								[5, "0.97"],
+								[5, "0.92"]
+							]
+						],
+						"starSpectral",
+						[5, "0.12"]
+					]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"starTint",
+					"mul"
+				],
+				[[
+					1,
+					[
+						1,
+						[
+							1,
+							"primarySpikes",
+							"+",
+							"secondarySpikes"
+						],
+						"*",
+						"radialFall"
+					],
+					"*",
+					"starburstInt"
+				]]
+			]]
+		]]
+	},
+	externals: {
+		"std.atan2": () => atan2,
+		"lightfields.angularCosineSpikes": () => angularCosineSpikes,
+		"lensFlareSpectral": () => lensFlareSpectral,
+		"TAU_FULL": () => TAU,
+		"std.mix": () => mix,
+		"d.vec3f": () => vec3f
+	}
+}) && $.f)({}));
+const flareStreak = typegpu_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32
+], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, lightPos, streakLen, streakInt) => {
+	"use gpu";
+	const dy = abs(__tsover_sub(uv.y, lightPos.y));
+	const dx = abs(__tsover_sub(uv.x, lightPos.x));
+	const vertFall = exp(__tsover_mul(__tsover_mul(-800, dy), dy));
+	const lenSq = __tsover_add(__tsover_mul(__tsover_mul(streakLen, streakLen), .25), .001);
+	const rStreak = exp(__tsover_div(__tsover_mul(__tsover_mul(-1, dx), dx), __tsover_mul(lenSq, .7)));
+	const gStreak = exp(__tsover_div(__tsover_mul(__tsover_mul(-1, dx), dx), lenSq));
+	const bStreak = exp(__tsover_div(__tsover_mul(__tsover_mul(-1, dx), dx), __tsover_mul(lenSq, 1.4)));
+	return vec3f(__tsover_mul(__tsover_mul(vertFall, rStreak), .5), __tsover_mul(__tsover_mul(vertFall, gStreak), .65), __tsover_mul(__tsover_mul(vertFall, bStreak), .9)).mul(streakInt);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "lightPos"
+			},
+			{
+				"type": "i",
+				"name": "streakLen"
+			},
+			{
+				"type": "i",
+				"name": "streakInt"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"dy",
+				[
+					6,
+					"std.abs",
+					[[
+						1,
+						[
+							7,
+							"uv",
+							"y"
+						],
+						"-",
+						[
+							7,
+							"lightPos",
+							"y"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"dx",
+				[
+					6,
+					"std.abs",
+					[[
+						1,
+						[
+							7,
+							"uv",
+							"x"
+						],
+						"-",
+						[
+							7,
+							"lightPos",
+							"x"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"vertFall",
+				[
+					6,
+					"std.exp",
+					[[
+						1,
+						[
+							1,
+							[
+								4,
+								"-",
+								[5, "800"]
+							],
+							"*",
+							"dy"
+						],
+						"*",
+						"dy"
+					]]
+				]
+			],
+			[
+				13,
+				"lenSq",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							"streakLen",
+							"*",
+							"streakLen"
+						],
+						"*",
+						[5, "0.25"]
+					],
+					"+",
+					[5, "0.001"]
+				]
+			],
+			[
+				13,
+				"rStreak",
+				[
+					6,
+					"std.exp",
+					[[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									4,
+									"-",
+									[5, "1"]
+								],
+								"*",
+								"dx"
+							],
+							"*",
+							"dx"
+						],
+						"/",
+						[
+							1,
+							"lenSq",
+							"*",
+							[5, "0.7"]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"gStreak",
+				[
+					6,
+					"std.exp",
+					[[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									4,
+									"-",
+									[5, "1"]
+								],
+								"*",
+								"dx"
+							],
+							"*",
+							"dx"
+						],
+						"/",
+						"lenSq"
+					]]
+				]
+			],
+			[
+				13,
+				"bStreak",
+				[
+					6,
+					"std.exp",
+					[[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									4,
+									"-",
+									[5, "1"]
+								],
+								"*",
+								"dx"
+							],
+							"*",
+							"dx"
+						],
+						"/",
+						[
+							1,
+							"lenSq",
+							"*",
+							[5, "1.4"]
+						]
+					]]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					[
+						6,
+						"d.vec3f",
+						[
+							[
+								1,
+								[
+									1,
+									"vertFall",
+									"*",
+									"rStreak"
+								],
+								"*",
+								[5, "0.5"]
+							],
+							[
+								1,
+								[
+									1,
+									"vertFall",
+									"*",
+									"gStreak"
+								],
+								"*",
+								[5, "0.65"]
+							],
+							[
+								1,
+								[
+									1,
+									"vertFall",
+									"*",
+									"bStreak"
+								],
+								"*",
+								[5, "0.9"]
+							]
+						]
+					],
+					"mul"
+				],
+				["streakInt"]
+			]]
+		]]
+	},
+	externals: {
+		"std.abs": () => abs,
+		"std.exp": () => exp,
+		"d.vec3f": () => vec3f
+	}
+}) && $.f)({}));
+const flareGlare = typegpu_default.fn([
+	f32,
+	f32,
+	f32
+], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((lightDist, glareSz, glareInt) => {
+	"use gpu";
+	const glareFalloff = radialGaussianFalloff(lightDist, __tsover_div(1, __tsover_add(__tsover_mul(glareSz, glareSz), .01)));
+	return vec3f(1, .98, .95).mul(__tsover_mul(glareFalloff, glareInt));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "lightDist"
+			},
+			{
+				"type": "i",
+				"name": "glareSz"
+			},
+			{
+				"type": "i",
+				"name": "glareInt"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"glareSharpness",
+				[
+					1,
+					[5, "1"],
+					"/",
+					[
+						1,
+						[
+							1,
+							"glareSz",
+							"*",
+							"glareSz"
+						],
+						"+",
+						[5, "0.01"]
+					]
+				]
+			],
+			[
+				13,
+				"glareFalloff",
+				[
+					6,
+					"lightfields.radialGaussianFalloff",
+					["lightDist", "glareSharpness"]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					[
+						6,
+						"d.vec3f",
+						[
+							[5, "1"],
+							[5, "0.98"],
+							[5, "0.95"]
+						]
+					],
+					"mul"
+				],
+				[[
+					1,
+					"glareFalloff",
+					"*",
+					"glareInt"
+				]]
+			]]
+		]]
+	},
+	externals: {
+		"lightfields.radialGaussianFalloff": () => radialGaussianFalloff,
+		"d.vec3f": () => vec3f
+	}
+}) && $.f)({}));
+const flareCore = typegpu_default.fn([f32, f32], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((lightDist, intensity) => {
+	"use gpu";
+	const coreSoft = exp(__tsover_mul(__tsover_mul(-500, lightDist), lightDist));
+	const coreSharp = __tsover_sub(1, smoothstep(0, .025, lightDist));
+	return vec3f(1, .98, .96).mul(__tsover_mul(__tsover_add(coreSoft, __tsover_mul(coreSharp, 1.5)), intensity));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "lightDist"
+		}, {
+			"type": "i",
+			"name": "intensity"
+		}],
+		"body": [0, [
+			[
+				13,
+				"coreSoft",
+				[
+					6,
+					"std.exp",
+					[[
+						1,
+						[
+							1,
+							[
+								4,
+								"-",
+								[5, "500"]
+							],
+							"*",
+							"lightDist"
+						],
+						"*",
+						"lightDist"
+					]]
+				]
+			],
+			[
+				13,
+				"coreSharp",
+				[
+					1,
+					[5, "1"],
+					"-",
+					[
+						6,
+						"std.smoothstep",
+						[
+							[5, "0"],
+							[5, "0.025"],
+							"lightDist"
+						]
+					]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					[
+						6,
+						"d.vec3f",
+						[
+							[5, "1"],
+							[5, "0.98"],
+							[5, "0.96"]
+						]
+					],
+					"mul"
+				],
+				[[
+					1,
+					[
+						1,
+						"coreSoft",
+						"+",
+						[
+							1,
+							"coreSharp",
+							"*",
+							[5, "1.5"]
+						]
+					],
+					"*",
+					"intensity"
+				]]
+			]]
+		]]
+	},
+	externals: {
+		"std.exp": () => exp,
+		"std.smoothstep": () => smoothstep,
+		"d.vec3f": () => vec3f
+	}
+}) && $.f)({}));
+const flareComposite = typegpu_default.fn([vec3f, f32], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((flareTotal, masterFade) => {
+	"use gpu";
+	const finalColor = flareTotal.mul(masterFade);
+	return vec4f(finalColor, clamp(__tsover_mul(luma601Dot(finalColor), 2), 0, 1));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "flareTotal"
+		}, {
+			"type": "i",
+			"name": "masterFade"
+		}],
+		"body": [0, [
+			[
+				13,
+				"finalColor",
+				[
+					6,
+					[
+						7,
+						"flareTotal",
+						"mul"
+					],
+					["masterFade"]
+				]
+			],
+			[
+				13,
+				"flareAlpha",
+				[
+					6,
+					"std.clamp",
+					[
+						[
+							1,
+							[
+								6,
+								"tone.luma601Dot",
+								["finalColor"]
+							],
+							"*",
+							[5, "2"]
+						],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[10, [
+				6,
+				"d.vec4f",
+				["finalColor", "flareAlpha"]
+			]]
+		]]
+	},
+	externals: {
+		"std.clamp": () => clamp,
+		"tone.luma601Dot": () => luma601Dot,
+		"d.vec4f": () => vec4f
+	}
+}) && $.f)({}));
+export { flareFrame as a, flareStarburst as c, lineMask as d, sineWaveMask as f, flareCore as i, flareStreak as l, blobField as n, flareGlare as o, flareComposite as r, flareHalo as s, blobCompose as t, lensFlareGhost as u };