shaders 3.1.463 → 3.2.465

package/dist/core/{LensFlare-MGtdMge_.js → shapePaints-CRpPT5Z5.js}

@@ -1,140 +1,23 @@
-import { Dt as sin, Ft as vec3f, Lt as vec4f, Mt as vec2f, Ot as smoothstep, _t as max, b as vec4, ct as clamp, et as typegpu_default, ft as exp, gt as length, it as abs, lt as cos, m as call, ot as atan2, sn as f32, yt as mix } from "./edges-CV-BHMpI.js";
-import { o as TAU$1 } from "./constants-BKlzQFdJ.js";
-import { t as luma601Dot } from "./tone-Bm6RiwOF.js";
-import { t as aspectOf } from "./geom-BS390xIn.js";
-import { a as chromaticRingBand, s as radialGaussianFalloff, t as angularCosineSpikes } from "./lightfields-C49QCtGR.js";
-import { t as animatedTime } from "./porters-j7yWJYy2.js";
-import { c as transformPosition } from "./transformations-u-UZrXjj.js";
-var TAU = TAU$1;
-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",
-								"*",
-								"t"
-							]]
-						],
-						"*",
-						[5, "0.5"]
-					],
-					"+",
-					[5, "0.5"]
-				],
-				[
-					1,
-					[
-						1,
-						[
-							6,
-							"std.cos",
-							[[
-								1,
-								"TAU",
-								"*",
-								[
-									1,
-									"t",
-									"-",
-									[5, "0.333"]
-								]
-							]]
-						],
-						"*",
-						[5, "0.5"]
-					],
-					"+",
-					[5, "0.5"]
-				],
-				[
-					1,
-					[
-						1,
-						[
-							6,
-							"std.cos",
-							[[
-								1,
-								"TAU",
-								"*",
-								[
-									1,
-									"t",
-									"-",
-									[5, "0.666"]
-								]
-							]]
-						],
-						"*",
-						[5, "0.5"]
-					],
-					"+",
-					[5, "0.5"]
-				]
-			]
-		]]]]
-	},
-	externals: {
-		"d.vec3f": () => vec3f,
-		"std.cos": () => cos,
-		"TAU": () => TAU
-	}
-}) && $.f)({}));
-var lensFlareGhost = typegpu_default.fn([
-	vec2f,
-	f32,
+import { $n as clamp, An as DEG_TO_RAD, Br as f32, Jn as select, Nr as struct, Pn as TAU, Qt as aspectCorrectedUV, Tr as vec4f, Xt as aspectCenteredDelta, Yn as abs, Zn as atan2, Zt as aspectCentrePosition, _r as smoothstep, an as rotate2, ar as floor, cr as max, en as aspectOf, er as cos, gr as sin, lr as min, rr as exp, sr as length, ur as mix, vr as sqrt, wr as vec3f, xr as vec2f, zn as typegpu_default } from "./lower-DSk_KxOY.js";
+import { t as luma601Dot } from "./tone-Ax72n2WU.js";
+import { a as chromaticRingBand, l as radialGaussianFalloff, t as angularCosineSpikes } from "./lightfields-D5lW4WSp.js";
+var EPS = 1e-5;
+const segmentArcPerp = typegpu_default.fn([
 	vec2f,
 	vec2f,
-	f32,
-	vec3f,
-	vec4f,
-	vec4f
-], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, lightPos, flareAxis, t, shared, disc, tint) => {
+	vec2f
+], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p, a, b) => {
 	"use gpu";
-	const ghostSpread = shared.x;
-	const ghostChroma = shared.y;
-	const ghostInt = shared.z;
-	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));
+	const pax = __tsover_sub(p.x, a.x);
+	const pay = __tsover_sub(p.y, a.y);
+	const bax = __tsover_sub(b.x, a.x);
+	const bay = __tsover_sub(b.y, a.y);
+	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))));
+	return vec3f(t, sqrt(max(__tsover_sub(__tsover_mul(dSeg, dSeg), __tsover_mul(overshoot, overshoot)), f32(0))), len);
 }), {
 	v: 2,
 	name: void 0,
@@ -142,838 +25,1185 @@ var lensFlareGhost = typegpu_default.fn([
 		"params": [
 			{
 				"type": "i",
-				"name": "uv"
-			},
-			{
-				"type": "i",
-				"name": "aspect"
-			},
-			{
-				"type": "i",
-				"name": "lightPos"
-			},
-			{
-				"type": "i",
-				"name": "flareAxis"
-			},
-			{
-				"type": "i",
-				"name": "t"
-			},
-			{
-				"type": "i",
-				"name": "shared"
+				"name": "p"
 			},
 			{
 				"type": "i",
-				"name": "disc"
+				"name": "a"
 			},
 			{
 				"type": "i",
-				"name": "tint"
+				"name": "b"
 			}
 		],
 		"body": [0, [
 			[
 				13,
-				"ghostSpread",
-				[
-					7,
-					"shared",
-					"x"
-				]
-			],
-			[
-				13,
-				"ghostChroma",
+				"pax",
 				[
-					7,
-					"shared",
-					"y"
+					1,
+					[
+						7,
+						"p",
+						"x"
+					],
+					"-",
+					[
+						7,
+						"a",
+						"x"
+					]
 				]
 			],
 			[
 				13,
-				"ghostInt",
+				"pay",
 				[
-					7,
-					"shared",
-					"z"
+					1,
+					[
+						7,
+						"p",
+						"y"
+					],
+					"-",
+					[
+						7,
+						"a",
+						"y"
+					]
 				]
 			],
 			[
 				13,
-				"offset",
+				"bax",
 				[
-					7,
-					"disc",
-					"x"
+					1,
+					[
+						7,
+						"b",
+						"x"
+					],
+					"-",
+					[
+						7,
+						"a",
+						"x"
+					]
 				]
 			],
 			[
 				13,
-				"size",
+				"bay",
 				[
-					7,
-					"disc",
-					"y"
+					1,
+					[
+						7,
+						"b",
+						"y"
+					],
+					"-",
+					[
+						7,
+						"a",
+						"y"
+					]
 				]
 			],
 			[
 				13,
-				"bright",
+				"len",
 				[
-					7,
-					"disc",
-					"z"
+					6,
+					"std.max",
+					[[
+						6,
+						"std.length",
+						[[
+							6,
+							"d.vec2f",
+							["bax", "bay"]
+						]]
+					], [
+						6,
+						"d.f32",
+						["EPS"]
+					]]
 				]
 			],
 			[
 				13,
-				"hollow",
+				"t",
 				[
-					7,
-					"disc",
-					"w"
+					1,
+					[
+						1,
+						[
+							1,
+							"pax",
+							"*",
+							"bax"
+						],
+						"+",
+						[
+							1,
+							"pay",
+							"*",
+							"bay"
+						]
+					],
+					"/",
+					"len"
 				]
 			],
 			[
 				13,
-				"r",
+				"overshoot",
 				[
-					7,
-					"tint",
-					"x"
+					6,
+					"std.max",
+					[[
+						6,
+						"std.max",
+						[[
+							4,
+							"-",
+							"t"
+						], [
+							1,
+							"t",
+							"-",
+							"len"
+						]]
+					], [
+						6,
+						"d.f32",
+						[[5, "0"]]
+					]]
 				]
 			],
 			[
 				13,
-				"g",
+				"h",
 				[
-					7,
-					"tint",
-					"y"
-				]
-			],
-			[
-				13,
-				"b",
-				[
-					7,
-					"tint",
-					"z"
-				]
-			],
-			[
-				13,
-				"gPhase",
-				[
-					7,
-					"tint",
-					"w"
+					6,
+					"std.clamp",
+					[
+						[
+							1,
+							"t",
+							"/",
+							"len"
+						],
+						[
+							6,
+							"d.f32",
+							[[5, "0"]]
+						],
+						[
+							6,
+							"d.f32",
+							[[5, "1"]]
+						]
+					]
 				]
 			],
 			[
 				13,
-				"ghostPos",
+				"dSeg",
 				[
 					6,
-					[
-						7,
-						"lightPos",
-						"add"
-					],
+					"std.length",
 					[[
 						6,
-						[
-							7,
-							"flareAxis",
-							"mul"
-						],
+						"d.vec2f",
 						[[
 							1,
+							"pax",
+							"-",
 							[
 								1,
-								"offset",
+								"bax",
 								"*",
-								"ghostSpread"
-							],
-							"*",
-							[5, "2"]
+								"h"
+							]
+						], [
+							1,
+							"pay",
+							"-",
+							[
+								1,
+								"bay",
+								"*",
+								"h"
+							]
 						]]
 					]]
 				]
 			],
 			[
 				13,
-				"toGhost",
+				"perp",
 				[
 					6,
-					"d.vec2f",
+					"std.sqrt",
 					[[
-						1,
-						[
+						6,
+						"std.max",
+						[[
 							1,
 							[
-								7,
-								"uv",
-								"x"
+								1,
+								"dSeg",
+								"*",
+								"dSeg"
 							],
 							"-",
 							[
-								7,
-								"ghostPos",
-								"x"
+								1,
+								"overshoot",
+								"*",
+								"overshoot"
 							]
-						],
-						"*",
-						"aspect"
-					], [
-						1,
-						[
-							7,
-							"uv",
-							"y"
-						],
-						"-",
-						[
-							7,
-							"ghostPos",
-							"y"
-						]
+						], [
+							6,
+							"d.f32",
+							[[5, "0"]]
+						]]
 					]]
 				]
 			],
+			[10, [
+				6,
+				"d.vec3f",
+				[
+					"t",
+					"perp",
+					"len"
+				]
+			]]
+		]]
+	},
+	externals: {
+		"std.max": () => max,
+		"std.length": () => length,
+		"d.vec2f": () => vec2f,
+		"d.f32": () => f32,
+		"EPS": () => EPS,
+		"std.clamp": () => clamp,
+		"std.sqrt": () => sqrt,
+		"d.vec3f": () => vec3f
+	}
+}) && $.f)({}));
+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 = aspectOf(viewport);
+	const seg = segmentArcPerp(aspectCorrectedUV(uv, viewport), aspectCentrePosition(pointA, aspect), aspectCentrePosition(pointB, aspect));
+	const t = seg.x;
+	const perp = seg.y;
+	const len = seg.z;
+	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",
+				[
+					6,
+					"geom.aspectOf",
+					["viewport"]
+				]
+			],
 			[
 				13,
-				"dist",
+				"p",
 				[
 					6,
-					"std.length",
-					["toGhost"]
+					"geom.aspectCorrectedUV",
+					["uv", "viewport"]
 				]
 			],
 			[
 				13,
-				"sz",
-				"size"
+				"a",
+				[
+					6,
+					"geom.aspectCentrePosition",
+					["pointA", "aspect"]
+				]
 			],
 			[
 				13,
-				"discShape",
+				"b",
 				[
-					1,
-					[5, "1"],
-					"-",
-					[
-						6,
-						"std.smoothstep",
-						[
-							[
-								1,
-								"sz",
-								"*",
-								[5, "0.12"]
-							],
-							"sz",
-							"dist"
-						]
-					]
+					6,
+					"geom.aspectCentrePosition",
+					["pointB", "aspect"]
 				]
 			],
 			[
 				13,
-				"innerFade",
+				"seg",
 				[
-					1,
-					[5, "1"],
-					"-",
+					6,
+					"segmentArcPerp",
 					[
-						6,
-						"std.smoothstep",
-						[
-							[
-								1,
-								"sz",
-								"*",
-								[5, "0.05"]
-							],
-							[
-								1,
-								"sz",
-								"*",
-								[5, "0.45"]
-							],
-							"dist"
-						]
+						"p",
+						"a",
+						"b"
 					]
 				]
 			],
 			[
 				13,
-				"shape",
+				"t",
+				[
+					7,
+					"seg",
+					"x"
+				]
+			],
+			[
+				13,
+				"perp",
+				[
+					7,
+					"seg",
+					"y"
+				]
+			],
+			[
+				13,
+				"len",
+				[
+					7,
+					"seg",
+					"z"
+				]
+			],
+			[
+				13,
+				"halfT",
 				[
 					1,
-					"discShape",
+					"thickness",
 					"*",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"cSolid",
+				[
+					1,
+					"t",
+					"-",
 					[
 						1,
-						[5, "1"],
-						"-",
-						[
-							1,
-							"innerFade",
-							"*",
-							"hollow"
-						]
+						"len",
+						"*",
+						[5, "0.5"]
 					]
 				]
 			],
 			[
 				13,
-				"gShimmer",
+				"axSolid",
 				[
 					1,
-					[
-						1,
-						[
-							1,
-							[
-								6,
-								"std.sin",
-								[[
-									1,
-									[
-										1,
-										"t",
-										"*",
-										[5, "4.3"]
-									],
-									"+",
-									"gPhase"
-								]]
-							],
-							"*",
-							[5, "0.08"]
-						],
-						"+",
-						[
+					"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,
 							[
-								6,
-								"std.sin",
-								[[
+								1,
+								[
 									1,
-									[
-										1,
-										"t",
-										"*",
-										[5, "9.1"]
-									],
+									"len",
 									"+",
-									[
-										1,
-										"gPhase",
-										"*",
-										[5, "1.7"]
-									]
-								]]
+									"gapLength"
+								],
+								"/",
+								"rawPeriod"
 							],
-							"*",
-							[5, "0.05"]
-						]
-					],
-					"+",
-					[5, "0.95"]
+							"+",
+							[5, "0.5"]
+						]]
+					], [
+						6,
+						"d.f32",
+						[[5, "1"]]
+					]]
 				]
 			],
 			[
 				13,
-				"ringCenter",
+				"scale",
 				[
 					1,
-					"sz",
-					"*",
-					[5, "0.78"]
+					"len",
+					"/",
+					[
+						6,
+						"std.max",
+						[[
+							1,
+							[
+								1,
+								"nDash",
+								"*",
+								"rawDash"
+							],
+							"+",
+							[
+								1,
+								[
+									1,
+									"nDash",
+									"-",
+									[5, "1"]
+								],
+								"*",
+								"gapLength"
+							]
+						], [
+							6,
+							"d.f32",
+							["EPS"]
+						]]
+					]
 				]
 			],
 			[
 				13,
-				"chromaSpread",
+				"dashL",
 				[
 					1,
-					[
-						1,
-						"sz",
-						"*",
-						"ghostChroma"
-					],
+					"rawDash",
 					"*",
-					[5, "0.14"]
+					"scale"
 				]
 			],
 			[
 				13,
-				"ringWidth",
+				"period",
 				[
 					1,
-					"sz",
+					"rawPeriod",
 					"*",
-					[5, "0.1"]
+					"scale"
 				]
 			],
 			[
 				13,
-				"ring",
+				"kDash",
 				[
 					6,
-					"lightfields.chromaticRingBand",
+					"std.clamp",
 					[
-						"dist",
-						"ringCenter",
-						"chromaSpread",
-						"ringWidth"
+						[
+							6,
+							"std.floor",
+							[[
+								1,
+								"t",
+								"/",
+								"period"
+							]]
+						],
+						[
+							6,
+							"d.f32",
+							[[5, "0"]]
+						],
+						[
+							1,
+							"nDash",
+							"-",
+							[5, "1"]
+						]
 					]
 				]
 			],
 			[
 				13,
-				"rRing",
+				"cDash",
 				[
-					7,
-					"ring",
-					"x"
+					1,
+					"t",
+					"-",
+					[
+						1,
+						[
+							1,
+							"kDash",
+							"*",
+							"period"
+						],
+						"+",
+						[
+							1,
+							"dashL",
+							"*",
+							[5, "0.5"]
+						]
+					]
 				]
 			],
 			[
 				13,
-				"gRing",
+				"axDashRound",
 				[
-					7,
-					"ring",
-					"y"
+					6,
+					"std.max",
+					[[
+						1,
+						[
+							1,
+							"dashL",
+							"*",
+							[5, "0.5"]
+						],
+						"-",
+						"halfT"
+					], [
+						6,
+						"d.f32",
+						[[5, "0"]]
+					]]
 				]
 			],
 			[
 				13,
-				"bRing",
+				"axDashSquare",
 				[
-					7,
-					"ring",
-					"z"
+					1,
+					"dashL",
+					"*",
+					[5, "0.5"]
 				]
 			],
 			[
 				13,
-				"brightness",
+				"rawDotPeriod",
 				[
-					1,
-					[
+					6,
+					"std.max",
+					[[
 						1,
-						"bright",
-						"*",
-						"ghostInt"
-					],
-					"*",
-					"gShimmer"
+						"thickness",
+						"+",
+						"gapLength"
+					], [
+						6,
+						"d.f32",
+						["EPS"]
+					]]
 				]
 			],
-			[10, [
-				6,
-				"d.vec3f",
+			[
+				13,
+				"nDot",
 				[
-					[
-						1,
-						[
+					6,
+					"std.max",
+					[[
+						6,
+						"std.floor",
+						[[
 							1,
 							[
 								1,
-								"shape",
-								"*",
-								"r"
+								"len",
+								"/",
+								"rawDotPeriod"
 							],
 							"+",
-							[
-								1,
-								"rRing",
-								"*",
-								"ghostChroma"
-							]
-						],
-						"*",
-						"brightness"
-					],
+							[5, "0.5"]
+						]]
+					], [
+						6,
+						"d.f32",
+						[[5, "1"]]
+					]]
+				]
+			],
+			[
+				13,
+				"dotPeriod",
+				[
+					1,
+					"len",
+					"/",
+					"nDot"
+				]
+			],
+			[
+				13,
+				"kDot",
+				[
+					6,
+					"std.clamp",
 					[
-						1,
 						[
-							1,
-							[
-								1,
-								"shape",
-								"*",
-								"g"
-							],
-							"+",
-							[
+							6,
+							"std.floor",
+							[[
 								1,
-								"gRing",
-								"*",
-								"ghostChroma"
-							]
+								[
+									1,
+									"t",
+									"/",
+									"dotPeriod"
+								],
+								"+",
+								[5, "0.5"]
+							]]
 						],
-						"*",
-						"brightness"
-					],
-					[
-						1,
 						[
-							1,
-							[
-								1,
-								"shape",
-								"*",
-								"b"
-							],
-							"+",
-							[
-								1,
-								"bRing",
-								"*",
-								"ghostChroma"
-							]
+							6,
+							"d.f32",
+							[[5, "0"]]
 						],
-						"*",
-						"brightness"
+						"nDot"
 					]
 				]
-			]]
-		]]
-	},
-	externals: {
-		"d.vec2f": () => vec2f,
-		"std.length": () => length,
-		"std.smoothstep": () => smoothstep,
-		"std.sin": () => sin,
-		"lightfields.chromaticRingBand": () => chromaticRingBand,
-		"d.vec3f": () => vec3f
-	}
-}) && $.f)({}));
-const lensFlareColor = typegpu_default.fn([
-	vec2f,
-	vec2f,
-	f32,
-	vec2f,
-	vec4f,
-	vec4f,
-	vec4f,
-	vec4f
-], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, animTime, lightPosRaw, p1, p2, p3, p4) => {
-	"use gpu";
-	const intensity = p1.x;
-	const ghostInt = p1.y;
-	const ghostSpread = p1.z;
-	const ghostChroma = p1.w;
-	const haloInt = p2.x;
-	const haloRad = p2.y;
-	const haloChroma = p2.z;
-	const haloSoft = p2.w;
-	const starburstInt = p3.x;
-	const starburstPts = p3.y;
-	const streakInt = p3.z;
-	const streakLen = p3.w;
-	const glareInt = p4.x;
-	const glareSz = p4.y;
-	const edgeFade = p4.z;
-	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 t = animTime;
-	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));
-	const lightDist = length(toLightAR);
-	const gShared = vec3f(ghostSpread, ghostChroma, ghostInt);
-	let ghostAccum = vec3f(0, 0, 0);
-	ghostAccum = ghostAccum.add(lensFlareGhost(uv, aspect, lightPos, flareAxis, t, gShared, vec4f(.15, .2, .3, .1), vec4f(1, .95, .9, 0)));
-	ghostAccum = ghostAccum.add(lensFlareGhost(uv, aspect, lightPos, flareAxis, t, gShared, vec4f(.3, .12, .25, .65), vec4f(1, .85, .55, 2.17)));
-	ghostAccum = ghostAccum.add(lensFlareGhost(uv, aspect, lightPos, flareAxis, t, gShared, vec4f(.5, .08, .35, .15), vec4f(.62, .82, 1, 4.34)));
-	ghostAccum = ghostAccum.add(lensFlareGhost(uv, aspect, lightPos, flareAxis, t, gShared, vec4f(.72, .14, .18, .75), vec4f(.75, 1, .7, 6.51)));
-	ghostAccum = ghostAccum.add(lensFlareGhost(uv, aspect, lightPos, flareAxis, t, gShared, vec4f(.95, .06, .3, 0), vec4f(1, .6, .85, 8.68)));
-	ghostAccum = ghostAccum.add(lensFlareGhost(uv, aspect, lightPos, flareAxis, t, gShared, vec4f(1.25, .1, .15, .8), vec4f(.55, .88, 1, 10.85)));
-	ghostAccum = ghostAccum.add(lensFlareGhost(uv, aspect, lightPos, flareAxis, t, gShared, vec4f(1.55, .07, .2, .25), vec4f(1, .92, .6, 13.02)));
-	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);
-	const haloColor = halo.mul(haloInt).mul(haloAngVar);
-	const lightAngle = atan2(toLightAR.y, toLightAR.x);
-	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));
-	const starburstColor = mix(vec3f(1, .97, .92), starSpectral, .12).mul(__tsover_mul(__tsover_mul(__tsover_add(primarySpikes, secondarySpikes), radialFall), starburstInt));
-	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)));
-	const streakColor = vec3f(__tsover_mul(__tsover_mul(vertFall, rStreak), .5), __tsover_mul(__tsover_mul(vertFall, gStreak), .65), __tsover_mul(__tsover_mul(vertFall, bStreak), .9)).mul(streakInt);
-	const glareFalloff = radialGaussianFalloff(lightDist, __tsover_div(1, __tsover_add(__tsover_mul(glareSz, glareSz), .01)));
-	const glareColor = vec3f(1, .98, .95).mul(__tsover_mul(glareFalloff, glareInt));
-	const coreSoft = exp(__tsover_mul(__tsover_mul(-500, lightDist), lightDist));
-	const coreSharp = __tsover_sub(1, smoothstep(0, .025, lightDist));
-	const coreColor = vec3f(1, .98, .96).mul(__tsover_mul(__tsover_add(coreSoft, __tsover_mul(coreSharp, 1.5)), intensity));
-	const finalColor = ghostAccum.add(haloColor).add(starburstColor).add(streakColor).add(glareColor).add(coreColor).mul(masterFade);
-	return vec4f(finalColor, clamp(__tsover_mul(luma601Dot(finalColor), 2), 0, 1));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "uv"
-			},
-			{
-				"type": "i",
-				"name": "viewport"
-			},
-			{
-				"type": "i",
-				"name": "animTime"
-			},
-			{
-				"type": "i",
-				"name": "lightPosRaw"
-			},
-			{
-				"type": "i",
-				"name": "p1"
-			},
-			{
-				"type": "i",
-				"name": "p2"
-			},
-			{
-				"type": "i",
-				"name": "p3"
-			},
-			{
-				"type": "i",
-				"name": "p4"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"intensity",
-				[
-					7,
-					"p1",
-					"x"
-				]
 			],
 			[
 				13,
-				"ghostInt",
+				"cDot",
 				[
-					7,
-					"p1",
-					"y"
+					1,
+					"t",
+					"-",
+					[
+						1,
+						"kDot",
+						"*",
+						"dotPeriod"
+					]
 				]
 			],
 			[
 				13,
-				"ghostSpread",
+				"isPattern",
 				[
-					7,
-					"p1",
-					"z"
+					1,
+					"style",
+					">=",
+					[5, "0.5"]
 				]
 			],
 			[
 				13,
-				"ghostChroma",
+				"isDotted",
 				[
-					7,
-					"p1",
-					"w"
+					1,
+					"style",
+					">=",
+					[5, "1.5"]
 				]
 			],
 			[
 				13,
-				"haloInt",
+				"c",
 				[
-					7,
-					"p2",
-					"x"
+					6,
+					"std.select",
+					[
+						"cSolid",
+						[
+							6,
+							"std.select",
+							[
+								"cDash",
+								"cDot",
+								"isDotted"
+							]
+						],
+						"isPattern"
+					]
 				]
 			],
 			[
 				13,
-				"haloRad",
+				"axRound",
 				[
-					7,
-					"p2",
-					"y"
+					6,
+					"std.select",
+					[
+						"axSolid",
+						[
+							6,
+							"std.select",
+							[
+								"axDashRound",
+								[
+									6,
+									"d.f32",
+									[[5, "0"]]
+								],
+								"isDotted"
+							]
+						],
+						"isPattern"
+					]
 				]
 			],
 			[
 				13,
-				"haloChroma",
+				"axSquare",
 				[
-					7,
-					"p2",
-					"z"
+					6,
+					"std.select",
+					[
+						"axSolid",
+						[
+							6,
+							"std.select",
+							[
+								"axDashSquare",
+								"halfT",
+								"isDotted"
+							]
+						],
+						"isPattern"
+					]
 				]
 			],
 			[
 				13,
-				"haloSoft",
+				"capHere",
 				[
-					7,
-					"p2",
-					"w"
+					6,
+					"std.select",
+					[
+						"capStart",
+						"capEnd",
+						[
+							1,
+							"c",
+							">",
+							[5, "0"]
+						]
+					]
 				]
 			],
 			[
 				13,
-				"starburstInt",
+				"sdRound",
 				[
-					7,
-					"p3",
-					"x"
+					1,
+					[
+						6,
+						"std.length",
+						[[
+							6,
+							"d.vec2f",
+							[[
+								6,
+								"std.max",
+								[[
+									1,
+									[
+										6,
+										"std.abs",
+										["c"]
+									],
+									"-",
+									"axRound"
+								], [
+									6,
+									"d.f32",
+									[[5, "0"]]
+								]]
+							], "perp"]
+						]]
+					],
+					"-",
+					"halfT"
 				]
 			],
 			[
 				13,
-				"starburstPts",
+				"qx",
 				[
-					7,
-					"p3",
-					"y"
+					1,
+					[
+						6,
+						"std.abs",
+						["c"]
+					],
+					"-",
+					"axSquare"
 				]
 			],
 			[
 				13,
-				"streakInt",
+				"qy",
 				[
-					7,
-					"p3",
-					"z"
+					1,
+					"perp",
+					"-",
+					"halfT"
 				]
 			],
 			[
 				13,
-				"streakLen",
+				"sdSquare",
 				[
-					7,
-					"p3",
-					"w"
+					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,
-				"glareInt",
+				"sd",
 				[
-					7,
-					"p4",
-					"x"
+					6,
+					"std.select",
+					[
+						"sdSquare",
+						"sdRound",
+						[
+							1,
+							"capHere",
+							">=",
+							[5, "0.5"]
+						]
+					]
 				]
 			],
 			[
 				13,
-				"glareSz",
+				"feather",
 				[
-					7,
-					"p4",
-					"y"
+					1,
+					[5, "1"],
+					"/",
+					[
+						7,
+						"viewport",
+						"y"
+					]
 				]
 			],
-			[
-				13,
-				"edgeFade",
+			[10, [
+				1,
+				[5, "1"],
+				"-",
 				[
-					7,
-					"p4",
-					"z"
+					6,
+					"std.smoothstep",
+					[
+						[
+							4,
+							"-",
+							"feather"
+						],
+						"feather",
+						"sd"
+					]
 				]
-			],
+			]]
+		]]
+	},
+	externals: {
+		"geom.aspectOf": () => aspectOf,
+		"geom.aspectCorrectedUV": () => aspectCorrectedUV,
+		"geom.aspectCentrePosition": () => aspectCentrePosition,
+		"segmentArcPerp": () => segmentArcPerp,
+		"std.max": () => max,
+		"d.f32": () => f32,
+		"EPS": () => EPS,
+		"std.floor": () => floor,
+		"std.clamp": () => clamp,
+		"std.select": () => select,
+		"std.length": () => length,
+		"d.vec2f": () => vec2f,
+		"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 centered = aspectCenteredDelta(uv, position, viewport);
+	const angleRad = __tsover_mul(angle, DEG_TO_RAD);
+	const rotated = rotate2(centered, cos(angleRad), sin(angleRad));
+	const waveInput = __tsover_add(__tsover_mul(__tsover_mul(rotated.x, frequency), TAU), animTime);
+	const sineWave = __tsover_mul(sin(waveInput), amplitude);
+	const distanceFromWave = abs(__tsover_sub(rotated.y, 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",
+				"centered",
 				[
 					6,
-					"geom.aspectOf",
-					["viewport"]
+					"geom.aspectCenteredDelta",
+					[
+						"uv",
+						"position",
+						"viewport"
+					]
 				]
 			],
 			[
 				13,
-				"lightPos",
+				"angleRad",
+				[
+					1,
+					"angle",
+					"*",
+					"DEG_TO_RAD"
+				]
+			],
+			[
+				13,
+				"cosAngle",
 				[
 					6,
-					"d.vec2f",
-					[[
-						7,
-						"lightPosRaw",
-						"x"
-					], [
-						1,
-						[5, "1"],
-						"-",
-						[
-							7,
-							"lightPosRaw",
-							"y"
-						]
-					]]
+					"std.cos",
+					["angleRad"]
 				]
 			],
 			[
 				13,
-				"flareAxis",
+				"sinAngle",
 				[
 					6,
-					"d.vec2f",
-					[[
-						1,
-						[5, "0.5"],
-						"-",
-						[
-							7,
-							"lightPos",
-							"x"
-						]
-					], [
-						1,
-						[5, "0.5"],
-						"-",
-						[
-							7,
-							"lightPos",
-							"y"
-						]
-					]]
+					"std.sin",
+					["angleRad"]
 				]
 			],
 			[
 				13,
-				"t",
-				"animTime"
+				"rotated",
+				[
+					6,
+					"geom.rotate2",
+					[
+						"centered",
+						"cosAngle",
+						"sinAngle"
+					]
+				]
 			],
 			[
 				13,
-				"shimmer",
+				"waveInput",
 				[
 					1,
 					[
@@ -981,549 +1211,1176 @@ const lensFlareColor = typegpu_default.fn([
 						[
 							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"]
-								]]
+								7,
+								"rotated",
+								"x"
 							],
 							"*",
-							[5, "0.02"]
-						]
+							"frequency"
+						],
+						"*",
+						"TAU"
 					],
 					"+",
-					[5, "0.97"]
+					"animTime"
 				]
 			],
 			[
 				13,
-				"edgeDist",
+				"sineWave",
+				[
+					1,
+					[
+						6,
+						"std.sin",
+						["waveInput"]
+					],
+					"*",
+					"amplitude"
+				]
+			],
+			[
+				13,
+				"distanceFromWave",
 				[
 					6,
-					"std.max",
+					"std.abs",
 					[[
 						1,
 						[
-							6,
-							"std.abs",
-							[[
-								1,
-								[
-									7,
-									"lightPos",
-									"x"
-								],
-								"-",
-								[5, "0.5"]
-							]]
-						],
-						"*",
-						[5, "2"]
-					], [
-						1,
-						[
-							6,
-							"std.abs",
-							[[
-								1,
-								[
-									7,
-									"lightPos",
-									"y"
-								],
-								"-",
-								[5, "0.5"]
-							]]
+							7,
+							"rotated",
+							"y"
 						],
-						"*",
-						[5, "2"]
+						"-",
+						"sineWave"
 					]]
 				]
 			],
 			[
 				13,
-				"fadeStart",
+				"halfThickness",
 				[
 					1,
-					[5, "1"],
-					"-",
-					[
-						1,
-						"edgeFade",
-						"*",
-						[5, "0.5"]
-					]
+					"thickness",
+					"*",
+					[5, "0.5"]
 				]
 			],
 			[
 				13,
-				"edgeFadeV",
+				"halfSoftness",
+				[
+					1,
+					"softness",
+					"*",
+					[5, "0.5"]
+				]
+			],
+			[10, [
+				1,
+				[5, "1"],
+				"-",
 				[
 					6,
-					"std.mix",
+					"std.smoothstep",
 					[
-						[5, "1"],
 						[
 							1,
-							[5, "1"],
+							"halfThickness",
 							"-",
-							[
-								6,
-								"std.smoothstep",
-								[
-									"fadeStart",
-									[5, "1"],
-									"edgeDist"
-								]
-							]
+							"halfSoftness"
 						],
-						"edgeFade"
-					]
-				]
-			],
+						[
+							1,
+							"halfThickness",
+							"+",
+							"halfSoftness"
+						],
+						"distanceFromWave"
+					]
+				]
+			]]
+		]]
+	},
+	externals: {
+		"geom.aspectCenteredDelta": () => aspectCenteredDelta,
+		"DEG_TO_RAD": () => DEG_TO_RAD,
+		"std.cos": () => cos,
+		"std.sin": () => sin,
+		"geom.rotate2": () => rotate2,
+		"TAU": () => TAU,
+		"std.abs": () => abs,
+		"std.smoothstep": () => smoothstep
+	}
+}) && $.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,
-				"masterFade",
+				"ringCenter",
 				[
 					1,
-					[
-						1,
-						"intensity",
-						"*",
-						"edgeFadeV"
-					],
+					"sz",
 					"*",
-					"shimmer"
+					[5, "0.78"]
 				]
 			],
 			[
 				13,
-				"toLightAR",
+				"chromaSpread",
 				[
-					6,
-					"d.vec2f",
-					[[
+					1,
+					[
 						1,
-						[
-							1,
-							[
-								7,
-								"uv",
-								"x"
-							],
-							"-",
-							[
-								7,
-								"lightPos",
-								"x"
-							]
-						],
+						"sz",
 						"*",
-						"aspect"
-					], [
-						1,
-						[
-							7,
-							"uv",
-							"y"
-						],
-						"-",
-						[
-							7,
-							"lightPos",
-							"y"
-						]
-					]]
+						"ghostChroma"
+					],
+					"*",
+					[5, "0.14"]
 				]
 			],
 			[
 				13,
-				"lightDist",
+				"ringWidth",
 				[
-					6,
-					"std.length",
-					["toLightAR"]
+					1,
+					"sz",
+					"*",
+					[5, "0.1"]
 				]
 			],
 			[
 				13,
-				"gShared",
+				"ring",
 				[
 					6,
-					"d.vec3f",
+					"lightfields.chromaticRingBand",
 					[
-						"ghostSpread",
-						"ghostChroma",
-						"ghostInt"
+						"dist",
+						"ringCenter",
+						"chromaSpread",
+						"ringWidth"
 					]
 				]
 			],
 			[
-				12,
-				"ghostAccum",
+				13,
+				"rRing",
 				[
-					6,
-					"d.vec3f",
-					[
-						[5, "0"],
-						[5, "0"],
-						[5, "0"]
-					]
+					7,
+					"ring",
+					"x"
 				]
 			],
 			[
-				2,
-				"ghostAccum",
-				"=",
+				13,
+				"gRing",
 				[
-					6,
-					[
-						7,
-						"ghostAccum",
-						"add"
-					],
-					[[
-						6,
-						"lensFlareGhost",
-						[
-							"uv",
-							"aspect",
-							"lightPos",
-							"flareAxis",
-							"t",
-							"gShared",
-							[
-								6,
-								"d.vec4f",
-								[
-									[5, "0.15"],
-									[5, "0.2"],
-									[5, "0.3"],
-									[5, "0.1"]
-								]
-							],
-							[
-								6,
-								"d.vec4f",
-								[
-									[5, "1"],
-									[5, "0.95"],
-									[5, "0.9"],
-									[5, "0"]
-								]
-							]
-						]
-					]]
+					7,
+					"ring",
+					"y"
 				]
 			],
 			[
-				2,
-				"ghostAccum",
-				"=",
+				13,
+				"bRing",
 				[
-					6,
-					[
-						7,
-						"ghostAccum",
-						"add"
-					],
-					[[
-						6,
-						"lensFlareGhost",
-						[
-							"uv",
-							"aspect",
-							"lightPos",
-							"flareAxis",
-							"t",
-							"gShared",
-							[
-								6,
-								"d.vec4f",
-								[
-									[5, "0.3"],
-									[5, "0.12"],
-									[5, "0.25"],
-									[5, "0.65"]
-								]
-							],
-							[
-								6,
-								"d.vec4f",
-								[
-									[5, "1"],
-									[5, "0.85"],
-									[5, "0.55"],
-									[5, "2.17"]
-								]
-							]
-						]
-					]]
+					7,
+					"ring",
+					"z"
 				]
 			],
 			[
-				2,
-				"ghostAccum",
-				"=",
+				13,
+				"brightness",
 				[
-					6,
+					1,
 					[
-						7,
-						"ghostAccum",
-						"add"
+						1,
+						"bright",
+						"*",
+						"ghostInt"
 					],
-					[[
-						6,
-						"lensFlareGhost",
-						[
-							"uv",
-							"aspect",
-							"lightPos",
-							"flareAxis",
-							"t",
-							"gShared",
-							[
-								6,
-								"d.vec4f",
-								[
-									[5, "0.5"],
-									[5, "0.08"],
-									[5, "0.35"],
-									[5, "0.15"]
-								]
-							],
-							[
-								6,
-								"d.vec4f",
-								[
-									[5, "0.62"],
-									[5, "0.82"],
-									[5, "1"],
-									[5, "4.34"]
-								]
-							]
-						]
-					]]
+					"*",
+					"gShimmer"
 				]
 			],
-			[
-				2,
-				"ghostAccum",
-				"=",
+			[10, [
+				6,
+				"d.vec3f",
 				[
-					6,
 					[
-						7,
-						"ghostAccum",
-						"add"
-					],
-					[[
-						6,
-						"lensFlareGhost",
+						1,
 						[
-							"uv",
-							"aspect",
-							"lightPos",
-							"flareAxis",
-							"t",
-							"gShared",
+							1,
 							[
-								6,
-								"d.vec4f",
-								[
-									[5, "0.72"],
-									[5, "0.14"],
-									[5, "0.18"],
-									[5, "0.75"]
-								]
+								1,
+								"shape",
+								"*",
+								"r"
 							],
+							"+",
 							[
-								6,
-								"d.vec4f",
-								[
-									[5, "0.75"],
-									[5, "1"],
-									[5, "0.7"],
-									[5, "6.51"]
-								]
+								1,
+								"rRing",
+								"*",
+								"ghostChroma"
 							]
-						]
-					]]
-				]
-			],
-			[
-				2,
-				"ghostAccum",
-				"=",
-				[
-					6,
-					[
-						7,
-						"ghostAccum",
-						"add"
+						],
+						"*",
+						"brightness"
 					],
-					[[
-						6,
-						"lensFlareGhost",
-						[
-							"uv",
-							"aspect",
-							"lightPos",
-							"flareAxis",
-							"t",
-							"gShared",
-							[
-								6,
-								"d.vec4f",
-								[
-									[5, "0.95"],
-									[5, "0.06"],
-									[5, "0.3"],
-									[5, "0"]
-								]
-							],
-							[
-								6,
-								"d.vec4f",
-								[
-									[5, "1"],
-									[5, "0.6"],
-									[5, "0.85"],
-									[5, "8.68"]
-								]
-							]
-						]
-					]]
-				]
-			],
-			[
-				2,
-				"ghostAccum",
-				"=",
-				[
-					6,
 					[
-						7,
-						"ghostAccum",
-						"add"
-					],
-					[[
-						6,
-						"lensFlareGhost",
+						1,
 						[
-							"uv",
-							"aspect",
-							"lightPos",
-							"flareAxis",
-							"t",
-							"gShared",
+							1,
 							[
-								6,
-								"d.vec4f",
-								[
-									[5, "1.25"],
-									[5, "0.1"],
-									[5, "0.15"],
-									[5, "0.8"]
-								]
+								1,
+								"shape",
+								"*",
+								"g"
 							],
+							"+",
 							[
-								6,
-								"d.vec4f",
-								[
-									[5, "0.55"],
-									[5, "0.88"],
-									[5, "1"],
-									[5, "10.85"]
-								]
+								1,
+								"gRing",
+								"*",
+								"ghostChroma"
 							]
-						]
-					]]
-				]
-			],
-			[
-				2,
-				"ghostAccum",
-				"=",
-				[
-					6,
-					[
-						7,
-						"ghostAccum",
-						"add"
+						],
+						"*",
+						"brightness"
 					],
-					[[
-						6,
-						"lensFlareGhost",
+					[
+						1,
 						[
-							"uv",
-							"aspect",
-							"lightPos",
-							"flareAxis",
-							"t",
-							"gShared",
+							1,
 							[
-								6,
-								"d.vec4f",
-								[
-									[5, "1.55"],
-									[5, "0.07"],
-									[5, "0.2"],
-									[5, "0.25"]
-								]
+								1,
+								"shape",
+								"*",
+								"b"
 							],
+							"+",
 							[
-								6,
-								"d.vec4f",
-								[
-									[5, "1"],
-									[5, "0.92"],
-									[5, "0.6"],
-									[5, "13.02"]
-								]
+								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",
@@ -1695,44 +2552,86 @@ const lensFlareColor = typegpu_default.fn([
 					[5, "0.88"]
 				]
 			],
-			[
-				13,
-				"haloColor",
+			[10, [
+				6,
 				[
-					6,
+					7,
 					[
-						7,
+						6,
 						[
-							6,
-							[
-								7,
-								"halo",
-								"mul"
-							],
-							["haloInt"]
+							7,
+							"halo",
+							"mul"
 						],
-						"mul"
+						["haloInt"]
 					],
-					["haloAngVar"]
-				]
-			],
-			[
-				13,
-				"lightAngle",
-				[
-					6,
-					"std.atan2",
-					[[
-						7,
-						"toLightAR",
-						"y"
-					], [
-						7,
-						"toLightAR",
-						"x"
-					]]
-				]
-			],
+					"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",
@@ -1868,7 +2767,7 @@ const lensFlareColor = typegpu_default.fn([
 							1,
 							"spikeAngle",
 							"/",
-							"TAU"
+							"TAU_FULL"
 						],
 						"+",
 						[5, "0.5"]
@@ -1896,34 +2795,79 @@ const lensFlareColor = typegpu_default.fn([
 					]
 				]
 			],
-			[
-				13,
-				"starburstColor",
+			[10, [
+				6,
 				[
-					6,
+					7,
+					"starTint",
+					"mul"
+				],
+				[[
+					1,
 					[
-						7,
-						"starTint",
-						"mul"
-					],
-					[[
 						1,
 						[
 							1,
-							[
-								1,
-								"primarySpikes",
-								"+",
-								"secondarySpikes"
-							],
-							"*",
-							"radialFall"
+							"primarySpikes",
+							"+",
+							"secondarySpikes"
 						],
 						"*",
-						"starburstInt"
-					]]
-				]
-			],
+						"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",
@@ -2105,57 +3049,88 @@ const lensFlareColor = typegpu_default.fn([
 					]]
 				]
 			],
-			[
-				13,
-				"streakColor",
+			[10, [
+				6,
 				[
-					6,
+					7,
 					[
-						7,
+						6,
+						"d.vec3f",
 						[
-							6,
-							"d.vec3f",
 							[
+								1,
 								[
 									1,
-									[
-										1,
-										"vertFall",
-										"*",
-										"rStreak"
-									],
+									"vertFall",
 									"*",
-									[5, "0.5"]
+									"rStreak"
 								],
+								"*",
+								[5, "0.5"]
+							],
+							[
+								1,
 								[
 									1,
-									[
-										1,
-										"vertFall",
-										"*",
-										"gStreak"
-									],
+									"vertFall",
 									"*",
-									[5, "0.65"]
+									"gStreak"
 								],
+								"*",
+								[5, "0.65"]
+							],
+							[
+								1,
 								[
 									1,
-									[
-										1,
-										"vertFall",
-										"*",
-										"bStreak"
-									],
+									"vertFall",
 									"*",
-									[5, "0.9"]
-								]
+									"bStreak"
+								],
+								"*",
+								[5, "0.9"]
 							]
-						],
-						"mul"
+						]
 					],
-					["streakInt"]
-				]
-			],
+					"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",
@@ -2185,32 +3160,52 @@ const lensFlareColor = typegpu_default.fn([
 					["lightDist", "glareSharpness"]
 				]
 			],
-			[
-				13,
-				"glareColor",
+			[10, [
+				6,
 				[
-					6,
+					7,
 					[
-						7,
+						6,
+						"d.vec3f",
 						[
-							6,
-							"d.vec3f",
-							[
-								[5, "1"],
-								[5, "0.98"],
-								[5, "0.95"]
-							]
-						],
-						"mul"
+							[5, "1"],
+							[5, "0.98"],
+							[5, "0.95"]
+						]
 					],
-					[[
-						1,
-						"glareFalloff",
-						"*",
-						"glareInt"
-					]]
-				]
-			],
+					"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",
@@ -2252,87 +3247,62 @@ const lensFlareColor = typegpu_default.fn([
 					]
 				]
 			],
-			[
-				13,
-				"coreColor",
+			[10, [
+				6,
 				[
-					6,
+					7,
 					[
-						7,
+						6,
+						"d.vec3f",
 						[
-							6,
-							"d.vec3f",
-							[
-								[5, "1"],
-								[5, "0.98"],
-								[5, "0.96"]
-							]
-						],
-						"mul"
+							[5, "1"],
+							[5, "0.98"],
+							[5, "0.96"]
+						]
 					],
-					[[
+					"mul"
+				],
+				[[
+					1,
+					[
 						1,
+						"coreSoft",
+						"+",
 						[
 							1,
-							"coreSoft",
-							"+",
-							[
-								1,
-								"coreSharp",
-								"*",
-								[5, "1.5"]
-							]
-						],
-						"*",
-						"intensity"
-					]]
-				]
-			],
-			[
-				13,
-				"flareTotal",
-				[
-					6,
-					[
-						7,
-						[
-							6,
-							[
-								7,
-								[
-									6,
-									[
-										7,
-										[
-											6,
-											[
-												7,
-												[
-													6,
-													[
-														7,
-														"ghostAccum",
-														"add"
-													],
-													["haloColor"]
-												],
-												"add"
-											],
-											["starburstColor"]
-										],
-										"add"
-									],
-									["streakColor"]
-								],
-								"add"
-							],
-							["glareColor"]
-						],
-						"add"
+							"coreSharp",
+							"*",
+							[5, "1.5"]
+						]
 					],
-					["coreColor"]
-				]
-			],
+					"*",
+					"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",
@@ -2376,261 +3346,9 @@ const lensFlareColor = typegpu_default.fn([
 		]]
 	},
 	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,
-		"d.vec3f": () => vec3f,
-		"lensFlareGhost": () => lensFlareGhost,
-		"d.vec4f": () => vec4f,
-		"lightfields.chromaticRingBand": () => chromaticRingBand,
-		"std.atan2": () => atan2,
-		"lightfields.angularCosineSpikes": () => angularCosineSpikes,
-		"lensFlareSpectral": () => lensFlareSpectral,
-		"TAU": () => TAU,
-		"std.exp": () => exp,
-		"lightfields.radialGaussianFalloff": () => radialGaussianFalloff,
 		"std.clamp": () => clamp,
-		"tone.luma601Dot": () => luma601Dot
+		"tone.luma601Dot": () => luma601Dot,
+		"d.vec4f": () => vec4f
 	}
 }) && $.f)({}));
-const componentDefinition = {
-	name: "LensFlare",
-	boundingBoxDeclaration: {
-		aspectRatio: null,
-		supportsResizeFit: true
-	},
-	category: "Stylize",
-	description: "Realistic camera lens flare with artifacts.",
-	acceptsUVContext: true,
-	animatedTime: { speed: "speed" },
-	props: {
-		lightPosition: {
-			default: {
-				x: .3,
-				y: .3
-			},
-			transform: transformPosition,
-			description: "Position of the light source",
-			ui: {
-				type: "position",
-				label: "Light Position",
-				group: "Light"
-			}
-		},
-		intensity: {
-			default: .5,
-			description: "Master brightness of the entire lens flare effect",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 2,
-				step: .01,
-				label: "Intensity",
-				group: "Light"
-			}
-		},
-		ghostIntensity: {
-			default: .4,
-			description: "Brightness of internal reflection ghost discs along the flare axis",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Ghosts",
-				group: "Reflections"
-			}
-		},
-		ghostSpread: {
-			default: .7,
-			description: "Spacing between ghost reflections along the flare axis",
-			ui: {
-				type: "range",
-				min: .1,
-				max: 2,
-				step: .01,
-				label: "Ghost Spread",
-				group: "Reflections"
-			}
-		},
-		ghostChroma: {
-			default: .3,
-			description: "Rainbow chromatic fringing around ghost element edges",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Ghost Chroma",
-				group: "Reflections"
-			}
-		},
-		haloIntensity: {
-			default: .4,
-			description: "Brightness of the circular halo ring from internal reflection",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Halo",
-				group: "Reflections"
-			}
-		},
-		haloRadius: {
-			default: .6,
-			description: "Radius of the halo ring",
-			ui: {
-				type: "range",
-				min: .1,
-				max: 1,
-				step: .01,
-				label: "Halo Size",
-				group: "Reflections"
-			}
-		},
-		haloChroma: {
-			default: .6,
-			description: "Spectral dispersion on the halo creating rainbow color separation",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Halo Chroma",
-				group: "Reflections"
-			}
-		},
-		haloSoftness: {
-			default: .8,
-			description: "Thickness and softness of the halo ring",
-			ui: {
-				type: ["range", "map"],
-				min: .01,
-				max: 3,
-				step: .01,
-				label: "Halo Softness",
-				group: "Reflections"
-			}
-		},
-		starburstIntensity: {
-			default: .3,
-			description: "Brightness of diffraction spikes radiating from the light source",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Starburst",
-				group: "Effects"
-			}
-		},
-		starburstPoints: {
-			default: 6,
-			description: "Number of starburst spikes (simulates aperture blade count)",
-			ui: {
-				type: ["range", "map"],
-				min: 4,
-				max: 16,
-				step: 1,
-				label: "Blades",
-				group: "Effects"
-			}
-		},
-		streakIntensity: {
-			default: .15,
-			description: "Brightness of horizontal anamorphic light streak",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Streak",
-				group: "Effects"
-			}
-		},
-		streakLength: {
-			default: .5,
-			description: "Horizontal extent of the anamorphic streak",
-			ui: {
-				type: ["range", "map"],
-				min: .1,
-				max: 1,
-				step: .01,
-				label: "Streak Length",
-				group: "Effects"
-			}
-		},
-		glareIntensity: {
-			default: .2,
-			description: "Soft veiling glare that washes out contrast around the light",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Glare",
-				group: "Effects"
-			}
-		},
-		glareSize: {
-			default: .5,
-			description: "Size of the soft glare glow",
-			ui: {
-				type: ["range", "map"],
-				min: .1,
-				max: 1,
-				step: .01,
-				label: "Glare Size",
-				group: "Effects"
-			}
-		},
-		edgeFade: {
-			default: .2,
-			description: "How much the flare fades when the light source is near the screen edge (0 = no fade, 1 = heavy fade)",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Edge Fade",
-				group: "Light"
-			}
-		},
-		speed: {
-			default: .5,
-			description: "Speed of subtle flare shimmer and starburst rotation",
-			ui: {
-				type: "range",
-				min: 0,
-				max: 3,
-				step: .1,
-				label: "Speed",
-				group: "Animation"
-			}
-		}
-	},
-	fragment: (params) => {
-		const uv = params.uvContext ?? params.ctx.uv;
-		const viewport = params.effectiveViewportSize ?? params.ctx.viewportSize;
-		const t = animatedTime(params);
-		const u = params.uniforms;
-		return call(lensFlareColor, "lensFlareColor", [
-			uv,
-			viewport,
-			t,
-			u.lightPosition,
-			vec4(u.intensity, u.ghostIntensity, u.ghostSpread, u.ghostChroma),
-			vec4(u.haloIntensity, u.haloRadius, u.haloChroma, u.haloSoftness),
-			vec4(u.starburstIntensity, u.starburstPoints, u.streakIntensity, u.streakLength),
-			vec4(u.glareIntensity, u.glareSize, u.edgeFade, 0)
-		]);
-	}
-};
-var LensFlare_default = componentDefinition;
-export { componentDefinition as n, lensFlareColor as r, LensFlare_default as t };
+export { flareHalo as a, lensFlareGhost as c, flareGlare as i, lineMask as l, flareCore as n, flareStarburst as o, flareFrame as r, flareStreak as s, flareComposite as t, sineWaveMask as u };