shaders 3.2.475 → 4.0.0

package/dist/core/lightfields-D120ZvMt.js

@@ -1,2255 +0,0 @@
-import { Cr as sin, Gn as typegpu_default, Mr as vec4f, Or as vec2f, Tr as sqrt, _r as mix, ar as clamp, er as select, fr as floor, hr as max, in as aspectOf, jr as vec3f, lr as exp, mr as length, or as cos, qr as f32, rr as atan2, tr as abs, wr as smoothstep, yr as pow, zn as TAU } from "./lower-DtoDQ7hV.js";
-import { t as luma601Dot } from "./tone-CsRho9qb.js";
-const radialGaussianFalloff = typegpu_default.fn([f32, f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((dist, sharpness) => {
-	"use gpu";
-	return exp(-__tsover_mul(__tsover_mul(dist, dist), sharpness));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "dist"
-		}, {
-			"type": "i",
-			"name": "sharpness"
-		}],
-		"body": [0, [[10, [
-			6,
-			"std.exp",
-			[[
-				4,
-				"-",
-				[
-					1,
-					[
-						1,
-						"dist",
-						"*",
-						"dist"
-					],
-					"*",
-					"sharpness"
-				]
-			]]
-		]]]]
-	},
-	externals: { "std.exp": () => exp }
-}) && $.f)({}));
-const anisotropicGaussianSpot = typegpu_default.fn([
-	f32,
-	f32,
-	f32
-], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((du, dv, sharpness) => {
-	"use gpu";
-	return exp(__tsover_mul(__tsover_add(__tsover_mul(du, du), __tsover_mul(dv, dv)), -sharpness));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "du"
-			},
-			{
-				"type": "i",
-				"name": "dv"
-			},
-			{
-				"type": "i",
-				"name": "sharpness"
-			}
-		],
-		"body": [0, [[10, [
-			6,
-			"std.exp",
-			[[
-				1,
-				[
-					1,
-					[
-						1,
-						"du",
-						"*",
-						"du"
-					],
-					"+",
-					[
-						1,
-						"dv",
-						"*",
-						"dv"
-					]
-				],
-				"*",
-				[
-					4,
-					"-",
-					"sharpness"
-				]
-			]]
-		]]]]
-	},
-	externals: { "std.exp": () => exp }
-}) && $.f)({}));
-const radialGaussianGlow = typegpu_default.fn([
-	vec2f,
-	f32,
-	f32,
-	f32,
-	f32
-], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, lx, ly, sizeSq) => {
-	"use gpu";
-	const dx = __tsover_mul(__tsover_sub(uv.x, lx), aspect);
-	const dy = __tsover_sub(uv.y, ly);
-	const dd2 = __tsover_add(__tsover_mul(dx, dx), __tsover_mul(dy, dy));
-	return exp(__tsover_div(__tsover_mul(-.5, dd2), sizeSq));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "uv"
-			},
-			{
-				"type": "i",
-				"name": "aspect"
-			},
-			{
-				"type": "i",
-				"name": "lx"
-			},
-			{
-				"type": "i",
-				"name": "ly"
-			},
-			{
-				"type": "i",
-				"name": "sizeSq"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"dx",
-				[
-					1,
-					[
-						1,
-						[
-							7,
-							"uv",
-							"x"
-						],
-						"-",
-						"lx"
-					],
-					"*",
-					"aspect"
-				]
-			],
-			[
-				13,
-				"dy",
-				[
-					1,
-					[
-						7,
-						"uv",
-						"y"
-					],
-					"-",
-					"ly"
-				]
-			],
-			[
-				13,
-				"dd2",
-				[
-					1,
-					[
-						1,
-						"dx",
-						"*",
-						"dx"
-					],
-					"+",
-					[
-						1,
-						"dy",
-						"*",
-						"dy"
-					]
-				]
-			],
-			[10, [
-				6,
-				"std.exp",
-				[[
-					1,
-					[
-						1,
-						[
-							4,
-							"-",
-							[5, "0.5"]
-						],
-						"*",
-						"dd2"
-					],
-					"/",
-					"sizeSq"
-				]]
-			]]
-		]]
-	},
-	externals: { "std.exp": () => exp }
-}) && $.f)({}));
-const angularSineLobes = typegpu_default.fn([
-	f32,
-	f32,
-	f32,
-	f32
-], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((angle, count, phase, sharpness) => {
-	"use gpu";
-	return pow(__tsover_add(__tsover_mul(sin(__tsover_add(__tsover_mul(angle, count), phase)), .5), .5), sharpness);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "angle"
-			},
-			{
-				"type": "i",
-				"name": "count"
-			},
-			{
-				"type": "i",
-				"name": "phase"
-			},
-			{
-				"type": "i",
-				"name": "sharpness"
-			}
-		],
-		"body": [0, [[
-			13,
-			"t",
-			[
-				1,
-				[
-					1,
-					[
-						6,
-						"std.sin",
-						[[
-							1,
-							[
-								1,
-								"angle",
-								"*",
-								"count"
-							],
-							"+",
-							"phase"
-						]]
-					],
-					"*",
-					[5, "0.5"]
-				],
-				"+",
-				[5, "0.5"]
-			]
-		], [10, [
-			6,
-			"std.pow",
-			["t", "sharpness"]
-		]]]]
-	},
-	externals: {
-		"std.sin": () => sin,
-		"std.pow": () => pow
-	}
-}) && $.f)({}));
-const angularCosineSpikes = typegpu_default.fn([
-	f32,
-	f32,
-	f32
-], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((angle, halfCount, power) => {
-	"use gpu";
-	return pow(abs(cos(__tsover_mul(angle, halfCount))), power);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "angle"
-			},
-			{
-				"type": "i",
-				"name": "halfCount"
-			},
-			{
-				"type": "i",
-				"name": "power"
-			}
-		],
-		"body": [0, [[10, [
-			6,
-			"std.pow",
-			[[
-				6,
-				"std.abs",
-				[[
-					6,
-					"std.cos",
-					[[
-						1,
-						"angle",
-						"*",
-						"halfCount"
-					]]
-				]]
-			], "power"]
-		]]]]
-	},
-	externals: {
-		"std.pow": () => pow,
-		"std.abs": () => abs,
-		"std.cos": () => cos
-	}
-}) && $.f)({}));
-const seamlessAngularField = typegpu_default.fn([vec2f], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((delta) => {
-	"use gpu";
-	const angle = atan2(delta.y, delta.x);
-	return vec3f(angle, __tsover_sub(angle, __tsover_mul(TAU, floor(__tsover_div(angle, TAU)))), smoothstep(-.15, .15, delta.x));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "delta"
-		}],
-		"body": [0, [
-			[
-				13,
-				"angle",
-				[
-					6,
-					"std.atan2",
-					[[
-						7,
-						"delta",
-						"y"
-					], [
-						7,
-						"delta",
-						"x"
-					]]
-				]
-			],
-			[
-				13,
-				"angleWrapped",
-				[
-					1,
-					"angle",
-					"-",
-					[
-						1,
-						"TAU",
-						"*",
-						[
-							6,
-							"std.floor",
-							[[
-								1,
-								"angle",
-								"/",
-								"TAU"
-							]]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"blend",
-				[
-					6,
-					"std.smoothstep",
-					[
-						[
-							4,
-							"-",
-							[5, "0.15"]
-						],
-						[5, "0.15"],
-						[
-							7,
-							"delta",
-							"x"
-						]
-					]
-				]
-			],
-			[10, [
-				6,
-				"d.vec3f",
-				[
-					"angle",
-					"angleWrapped",
-					"blend"
-				]
-			]]
-		]]
-	},
-	externals: {
-		"std.atan2": () => atan2,
-		"TAU": () => TAU,
-		"std.floor": () => floor,
-		"std.smoothstep": () => smoothstep,
-		"d.vec3f": () => vec3f
-	}
-}) && $.f)({}));
-const chromaticRingBand = typegpu_default.fn([
-	f32,
-	f32,
-	f32,
-	f32
-], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((dist, center, spread, width) => {
-	"use gpu";
-	const w = max(width, 1e-4);
-	return vec3f(__tsover_sub(1, smoothstep(0, w, abs(__tsover_sub(dist, __tsover_add(center, spread))))), __tsover_sub(1, smoothstep(0, w, abs(__tsover_sub(dist, center)))), __tsover_sub(1, smoothstep(0, w, abs(__tsover_sub(dist, __tsover_sub(center, spread))))));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "dist"
-			},
-			{
-				"type": "i",
-				"name": "center"
-			},
-			{
-				"type": "i",
-				"name": "spread"
-			},
-			{
-				"type": "i",
-				"name": "width"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"w",
-				[
-					6,
-					"std.max",
-					["width", [5, "0.0001"]]
-				]
-			],
-			[
-				13,
-				"r",
-				[
-					1,
-					[5, "1"],
-					"-",
-					[
-						6,
-						"std.smoothstep",
-						[
-							[5, "0"],
-							"w",
-							[
-								6,
-								"std.abs",
-								[[
-									1,
-									"dist",
-									"-",
-									[
-										1,
-										"center",
-										"+",
-										"spread"
-									]
-								]]
-							]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"g",
-				[
-					1,
-					[5, "1"],
-					"-",
-					[
-						6,
-						"std.smoothstep",
-						[
-							[5, "0"],
-							"w",
-							[
-								6,
-								"std.abs",
-								[[
-									1,
-									"dist",
-									"-",
-									"center"
-								]]
-							]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"b",
-				[
-					1,
-					[5, "1"],
-					"-",
-					[
-						6,
-						"std.smoothstep",
-						[
-							[5, "0"],
-							"w",
-							[
-								6,
-								"std.abs",
-								[[
-									1,
-									"dist",
-									"-",
-									[
-										1,
-										"center",
-										"-",
-										"spread"
-									]
-								]]
-							]
-						]
-					]
-				]
-			],
-			[10, [
-				6,
-				"d.vec3f",
-				[
-					"r",
-					"g",
-					"b"
-				]
-			]]
-		]]
-	},
-	externals: {
-		"std.max": () => max,
-		"std.smoothstep": () => smoothstep,
-		"std.abs": () => abs,
-		"d.vec3f": () => vec3f
-	}
-}) && $.f)({}));
-const pointToSegment = typegpu_default.fn([
-	vec2f,
-	vec2f,
-	vec2f
-], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p, a, b) => {
-	"use gpu";
-	const lineVec = vec2f(__tsover_sub(b.x, a.x), __tsover_sub(b.y, a.y));
-	const toPoint = vec2f(__tsover_sub(p.x, a.x), __tsover_sub(p.y, a.y));
-	const dotProduct = __tsover_add(__tsover_mul(toPoint.x, lineVec.x), __tsover_mul(toPoint.y, lineVec.y));
-	const lineLengthSq = __tsover_add(__tsover_mul(lineVec.x, lineVec.x), __tsover_mul(lineVec.y, lineVec.y));
-	const t = clamp(__tsover_div(dotProduct, max(lineLengthSq, 1e-4)), 0, 1);
-	const closestPoint = vec2f(__tsover_add(a.x, __tsover_mul(lineVec.x, t)), __tsover_add(a.y, __tsover_mul(lineVec.y, t)));
-	const distVec = vec2f(__tsover_sub(p.x, closestPoint.x), __tsover_sub(p.y, closestPoint.y));
-	return vec2f(t, sqrt(__tsover_add(__tsover_mul(distVec.x, distVec.x), __tsover_mul(distVec.y, distVec.y))));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "p"
-			},
-			{
-				"type": "i",
-				"name": "a"
-			},
-			{
-				"type": "i",
-				"name": "b"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"lineVec",
-				[
-					6,
-					"d.vec2f",
-					[[
-						1,
-						[
-							7,
-							"b",
-							"x"
-						],
-						"-",
-						[
-							7,
-							"a",
-							"x"
-						]
-					], [
-						1,
-						[
-							7,
-							"b",
-							"y"
-						],
-						"-",
-						[
-							7,
-							"a",
-							"y"
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"toPoint",
-				[
-					6,
-					"d.vec2f",
-					[[
-						1,
-						[
-							7,
-							"p",
-							"x"
-						],
-						"-",
-						[
-							7,
-							"a",
-							"x"
-						]
-					], [
-						1,
-						[
-							7,
-							"p",
-							"y"
-						],
-						"-",
-						[
-							7,
-							"a",
-							"y"
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"dotProduct",
-				[
-					1,
-					[
-						1,
-						[
-							7,
-							"toPoint",
-							"x"
-						],
-						"*",
-						[
-							7,
-							"lineVec",
-							"x"
-						]
-					],
-					"+",
-					[
-						1,
-						[
-							7,
-							"toPoint",
-							"y"
-						],
-						"*",
-						[
-							7,
-							"lineVec",
-							"y"
-						]
-					]
-				]
-			],
-			[
-				13,
-				"lineLengthSq",
-				[
-					1,
-					[
-						1,
-						[
-							7,
-							"lineVec",
-							"x"
-						],
-						"*",
-						[
-							7,
-							"lineVec",
-							"x"
-						]
-					],
-					"+",
-					[
-						1,
-						[
-							7,
-							"lineVec",
-							"y"
-						],
-						"*",
-						[
-							7,
-							"lineVec",
-							"y"
-						]
-					]
-				]
-			],
-			[
-				13,
-				"t",
-				[
-					6,
-					"std.clamp",
-					[
-						[
-							1,
-							"dotProduct",
-							"/",
-							[
-								6,
-								"std.max",
-								["lineLengthSq", [5, "0.0001"]]
-							]
-						],
-						[5, "0"],
-						[5, "1"]
-					]
-				]
-			],
-			[
-				13,
-				"closestPoint",
-				[
-					6,
-					"d.vec2f",
-					[[
-						1,
-						[
-							7,
-							"a",
-							"x"
-						],
-						"+",
-						[
-							1,
-							[
-								7,
-								"lineVec",
-								"x"
-							],
-							"*",
-							"t"
-						]
-					], [
-						1,
-						[
-							7,
-							"a",
-							"y"
-						],
-						"+",
-						[
-							1,
-							[
-								7,
-								"lineVec",
-								"y"
-							],
-							"*",
-							"t"
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"distVec",
-				[
-					6,
-					"d.vec2f",
-					[[
-						1,
-						[
-							7,
-							"p",
-							"x"
-						],
-						"-",
-						[
-							7,
-							"closestPoint",
-							"x"
-						]
-					], [
-						1,
-						[
-							7,
-							"p",
-							"y"
-						],
-						"-",
-						[
-							7,
-							"closestPoint",
-							"y"
-						]
-					]]
-				]
-			],
-			[10, [
-				6,
-				"d.vec2f",
-				["t", [
-					6,
-					"std.sqrt",
-					[[
-						1,
-						[
-							1,
-							[
-								7,
-								"distVec",
-								"x"
-							],
-							"*",
-							[
-								7,
-								"distVec",
-								"x"
-							]
-						],
-						"+",
-						[
-							1,
-							[
-								7,
-								"distVec",
-								"y"
-							],
-							"*",
-							[
-								7,
-								"distVec",
-								"y"
-							]
-						]
-					]]
-				]]
-			]]
-		]]
-	},
-	externals: {
-		"d.vec2f": () => vec2f,
-		"std.clamp": () => clamp,
-		"std.max": () => max,
-		"std.sqrt": () => sqrt
-	}
-}) && $.f)({}));
-const taperedSegmentGlow = typegpu_default.fn([
-	f32,
-	f32,
-	f32,
-	f32,
-	f32,
-	f32
-], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((dist, t, startThickness, endThickness, startSoftness, endSoftness) => {
-	"use gpu";
-	const thickness = mix(startThickness, endThickness, t);
-	const softness = max(mix(startSoftness, endSoftness, t), 1e-4);
-	const normalizedDist = __tsover_div(dist, max(thickness, 1e-4));
-	const edgeEnd = __tsover_add(1, softness);
-	const alpha = pow(__tsover_sub(1, smoothstep(1, edgeEnd, normalizedDist)), __tsover_add(1, __tsover_mul(softness, 1.5)));
-	return vec2f(smoothstep(__tsover_sub(1, softness), __tsover_add(1, softness), normalizedDist), alpha);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "dist"
-			},
-			{
-				"type": "i",
-				"name": "t"
-			},
-			{
-				"type": "i",
-				"name": "startThickness"
-			},
-			{
-				"type": "i",
-				"name": "endThickness"
-			},
-			{
-				"type": "i",
-				"name": "startSoftness"
-			},
-			{
-				"type": "i",
-				"name": "endSoftness"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"thickness",
-				[
-					6,
-					"std.mix",
-					[
-						"startThickness",
-						"endThickness",
-						"t"
-					]
-				]
-			],
-			[
-				13,
-				"softness",
-				[
-					6,
-					"std.max",
-					[[
-						6,
-						"std.mix",
-						[
-							"startSoftness",
-							"endSoftness",
-							"t"
-						]
-					], [5, "0.0001"]]
-				]
-			],
-			[
-				13,
-				"normalizedDist",
-				[
-					1,
-					"dist",
-					"/",
-					[
-						6,
-						"std.max",
-						["thickness", [5, "0.0001"]]
-					]
-				]
-			],
-			[
-				13,
-				"edgeEnd",
-				[
-					1,
-					[5, "1"],
-					"+",
-					"softness"
-				]
-			],
-			[
-				13,
-				"alphaBase",
-				[
-					1,
-					[5, "1"],
-					"-",
-					[
-						6,
-						"std.smoothstep",
-						[
-							[5, "1"],
-							"edgeEnd",
-							"normalizedDist"
-						]
-					]
-				]
-			],
-			[
-				13,
-				"softnessFactor",
-				[
-					1,
-					[5, "1"],
-					"+",
-					[
-						1,
-						"softness",
-						"*",
-						[5, "1.5"]
-					]
-				]
-			],
-			[
-				13,
-				"alpha",
-				[
-					6,
-					"std.pow",
-					["alphaBase", "softnessFactor"]
-				]
-			],
-			[
-				13,
-				"colorGradientStart",
-				[
-					1,
-					[5, "1"],
-					"-",
-					"softness"
-				]
-			],
-			[
-				13,
-				"colorGradientEnd",
-				[
-					1,
-					[5, "1"],
-					"+",
-					"softness"
-				]
-			],
-			[
-				13,
-				"colorT",
-				[
-					6,
-					"std.smoothstep",
-					[
-						"colorGradientStart",
-						"colorGradientEnd",
-						"normalizedDist"
-					]
-				]
-			],
-			[10, [
-				6,
-				"d.vec2f",
-				["colorT", "alpha"]
-			]]
-		]]
-	},
-	externals: {
-		"std.mix": () => mix,
-		"std.max": () => max,
-		"std.smoothstep": () => smoothstep,
-		"std.pow": () => pow,
-		"d.vec2f": () => vec2f
-	}
-}) && $.f)({}));
-const streakBand = typegpu_default.fn([
-	f32,
-	f32,
-	f32
-], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((u, center, width) => {
-	"use gpu";
-	return exp(__tsover_div(__tsover_mul(__tsover_mul(__tsover_sub(u, center), __tsover_sub(u, center)), -1), __tsover_mul(width, width)));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "u"
-			},
-			{
-				"type": "i",
-				"name": "center"
-			},
-			{
-				"type": "i",
-				"name": "width"
-			}
-		],
-		"body": [0, [[10, [
-			6,
-			"std.exp",
-			[[
-				1,
-				[
-					1,
-					[
-						1,
-						[
-							1,
-							"u",
-							"-",
-							"center"
-						],
-						"*",
-						[
-							1,
-							"u",
-							"-",
-							"center"
-						]
-					],
-					"*",
-					[
-						4,
-						"-",
-						[5, "1"]
-					]
-				],
-				"/",
-				[
-					1,
-					"width",
-					"*",
-					"width"
-				]
-			]]
-		]]]]
-	},
-	externals: { "std.exp": () => exp }
-}) && $.f)({}));
-const heatRamp3 = typegpu_default.fn([
-	f32,
-	vec3f,
-	vec3f,
-	vec3f
-], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((heat, hot, mid, fringe) => {
-	"use gpu";
-	const toMid = smoothstep(0, .5, heat);
-	const toHot = smoothstep(.55, 1.15, heat);
-	return mix(mix(fringe, mid, vec3f(toMid)), hot, vec3f(toHot)).mul(clamp(heat, 0, 1.6));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "heat"
-			},
-			{
-				"type": "i",
-				"name": "hot"
-			},
-			{
-				"type": "i",
-				"name": "mid"
-			},
-			{
-				"type": "i",
-				"name": "fringe"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"toMid",
-				[
-					6,
-					"std.smoothstep",
-					[
-						[5, "0"],
-						[5, "0.5"],
-						"heat"
-					]
-				]
-			],
-			[
-				13,
-				"toHot",
-				[
-					6,
-					"std.smoothstep",
-					[
-						[5, "0.55"],
-						[5, "1.15"],
-						"heat"
-					]
-				]
-			],
-			[
-				13,
-				"rgb",
-				[
-					6,
-					"std.mix",
-					[
-						[
-							6,
-							"std.mix",
-							[
-								"fringe",
-								"mid",
-								[
-									6,
-									"d.vec3f",
-									["toMid"]
-								]
-							]
-						],
-						"hot",
-						[
-							6,
-							"d.vec3f",
-							["toHot"]
-						]
-					]
-				]
-			],
-			[10, [
-				6,
-				[
-					7,
-					"rgb",
-					"mul"
-				],
-				[[
-					6,
-					"std.clamp",
-					[
-						"heat",
-						[5, "0"],
-						[5, "1.6"]
-					]
-				]]
-			]]
-		]]
-	},
-	externals: {
-		"std.smoothstep": () => smoothstep,
-		"std.mix": () => mix,
-		"d.vec3f": () => vec3f,
-		"std.clamp": () => clamp
-	}
-}) && $.f)({}));
-const chromaticHeatTaps = typegpu_default.fn([
-	f32,
-	vec3f,
-	vec3f,
-	vec3f
-], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((heat, hot, mid, fringe) => {
-	"use gpu";
-	const rampR = heatRamp3(__tsover_mul(heat, 1.08), hot, mid, fringe);
-	const rampG = heatRamp3(heat, hot, mid, fringe);
-	const rampB = heatRamp3(__tsover_mul(heat, .88), hot, mid, fringe);
-	return vec3f(rampR.x, rampG.y, rampB.z);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "heat"
-			},
-			{
-				"type": "i",
-				"name": "hot"
-			},
-			{
-				"type": "i",
-				"name": "mid"
-			},
-			{
-				"type": "i",
-				"name": "fringe"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"rampR",
-				[
-					6,
-					"heatRamp3",
-					[
-						[
-							1,
-							"heat",
-							"*",
-							[5, "1.08"]
-						],
-						"hot",
-						"mid",
-						"fringe"
-					]
-				]
-			],
-			[
-				13,
-				"rampG",
-				[
-					6,
-					"heatRamp3",
-					[
-						"heat",
-						"hot",
-						"mid",
-						"fringe"
-					]
-				]
-			],
-			[
-				13,
-				"rampB",
-				[
-					6,
-					"heatRamp3",
-					[
-						[
-							1,
-							"heat",
-							"*",
-							[5, "0.88"]
-						],
-						"hot",
-						"mid",
-						"fringe"
-					]
-				]
-			],
-			[10, [
-				6,
-				"d.vec3f",
-				[
-					[
-						7,
-						"rampR",
-						"x"
-					],
-					[
-						7,
-						"rampG",
-						"y"
-					],
-					[
-						7,
-						"rampB",
-						"z"
-					]
-				]
-			]]
-		]]
-	},
-	externals: {
-		"heatRamp3": () => heatRamp3,
-		"d.vec3f": () => vec3f
-	}
-}) && $.f)({}));
-const radialFeatherMask = typegpu_default.fn([
-	f32,
-	f32,
-	f32
-], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((dist, radius, feather) => {
-	"use gpu";
-	const falloffStart = __tsover_mul(radius, __tsover_sub(1, feather));
-	return __tsover_sub(1, smoothstep(falloffStart, radius, dist));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "dist"
-			},
-			{
-				"type": "i",
-				"name": "radius"
-			},
-			{
-				"type": "i",
-				"name": "feather"
-			}
-		],
-		"body": [0, [[
-			13,
-			"falloffStart",
-			[
-				1,
-				"radius",
-				"*",
-				[
-					1,
-					[5, "1"],
-					"-",
-					"feather"
-				]
-			]
-		], [10, [
-			1,
-			[5, "1"],
-			"-",
-			[
-				6,
-				"std.smoothstep",
-				[
-					"falloffStart",
-					"radius",
-					"dist"
-				]
-			]
-		]]]]
-	},
-	externals: { "std.smoothstep": () => smoothstep }
-}) && $.f)({}));
-const softRayLobes = typegpu_default.fn([
-	f32,
-	f32,
-	f32,
-	f32
-], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((angle, count, phase, softness) => {
-	"use gpu";
-	return angularSineLobes(angle, count, phase, __tsover_mul(__tsover_div(1, __tsover_add(softness, .05)), .3));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "angle"
-			},
-			{
-				"type": "i",
-				"name": "count"
-			},
-			{
-				"type": "i",
-				"name": "phase"
-			},
-			{
-				"type": "i",
-				"name": "softness"
-			}
-		],
-		"body": [0, [[
-			13,
-			"sharpness",
-			[
-				1,
-				[
-					1,
-					[5, "1"],
-					"/",
-					[
-						1,
-						"softness",
-						"+",
-						[5, "0.05"]
-					]
-				],
-				"*",
-				[5, "0.3"]
-			]
-		], [10, [
-			6,
-			"angularSineLobes",
-			[
-				"angle",
-				"count",
-				"phase",
-				"sharpness"
-			]
-		]]]]
-	},
-	externals: { "angularSineLobes": () => angularSineLobes }
-}) && $.f)({}));
-const radialBurstFrame = typegpu_default.fn([
-	vec2f,
-	vec2f,
-	vec2f
-], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, center) => {
-	"use gpu";
-	const aspect = aspectOf(viewport);
-	const cx = center.x;
-	const cy = __tsover_sub(1, center.y);
-	const dx = __tsover_sub(__tsover_mul(uv.x, aspect), __tsover_mul(cx, aspect));
-	const dy = __tsover_sub(uv.y, cy);
-	return vec2f(sqrt(__tsover_add(__tsover_mul(dx, dx), __tsover_mul(dy, dy))), atan2(dy, dx));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "uv"
-			},
-			{
-				"type": "i",
-				"name": "viewport"
-			},
-			{
-				"type": "i",
-				"name": "center"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"aspect",
-				[
-					6,
-					"geom.aspectOf",
-					["viewport"]
-				]
-			],
-			[
-				13,
-				"cx",
-				[
-					7,
-					"center",
-					"x"
-				]
-			],
-			[
-				13,
-				"cy",
-				[
-					1,
-					[5, "1"],
-					"-",
-					[
-						7,
-						"center",
-						"y"
-					]
-				]
-			],
-			[
-				13,
-				"dx",
-				[
-					1,
-					[
-						1,
-						[
-							7,
-							"uv",
-							"x"
-						],
-						"*",
-						"aspect"
-					],
-					"-",
-					[
-						1,
-						"cx",
-						"*",
-						"aspect"
-					]
-				]
-			],
-			[
-				13,
-				"dy",
-				[
-					1,
-					[
-						7,
-						"uv",
-						"y"
-					],
-					"-",
-					"cy"
-				]
-			],
-			[
-				13,
-				"dist",
-				[
-					6,
-					"std.sqrt",
-					[[
-						1,
-						[
-							1,
-							"dx",
-							"*",
-							"dx"
-						],
-						"+",
-						[
-							1,
-							"dy",
-							"*",
-							"dy"
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"angle",
-				[
-					6,
-					"std.atan2",
-					["dy", "dx"]
-				]
-			],
-			[10, [
-				6,
-				"d.vec2f",
-				["dist", "angle"]
-			]]
-		]]
-	},
-	externals: {
-		"geom.aspectOf": () => aspectOf,
-		"std.sqrt": () => sqrt,
-		"std.atan2": () => atan2,
-		"d.vec2f": () => vec2f
-	}
-}) && $.f)({}));
-const vignetteMask = typegpu_default.fn([
-	vec2f,
-	vec2f,
-	f32
-], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, strength) => {
-	"use gpu";
-	const aspect = aspectOf(viewport);
-	const vigX = __tsover_mul(__tsover_sub(uv.x, .5), aspect);
-	const vigY = __tsover_sub(uv.y, .5);
-	const vigD2 = __tsover_add(__tsover_mul(vigX, vigX), __tsover_mul(vigY, vigY));
-	return clamp(__tsover_sub(1, __tsover_mul(vigD2, strength)), 0, 1);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "uv"
-			},
-			{
-				"type": "i",
-				"name": "viewport"
-			},
-			{
-				"type": "i",
-				"name": "strength"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"aspect",
-				[
-					6,
-					"geom.aspectOf",
-					["viewport"]
-				]
-			],
-			[
-				13,
-				"vigX",
-				[
-					1,
-					[
-						1,
-						[
-							7,
-							"uv",
-							"x"
-						],
-						"-",
-						[5, "0.5"]
-					],
-					"*",
-					"aspect"
-				]
-			],
-			[
-				13,
-				"vigY",
-				[
-					1,
-					[
-						7,
-						"uv",
-						"y"
-					],
-					"-",
-					[5, "0.5"]
-				]
-			],
-			[
-				13,
-				"vigD2",
-				[
-					1,
-					[
-						1,
-						"vigX",
-						"*",
-						"vigX"
-					],
-					"+",
-					[
-						1,
-						"vigY",
-						"*",
-						"vigY"
-					]
-				]
-			],
-			[10, [
-				6,
-				"std.clamp",
-				[
-					[
-						1,
-						[5, "1"],
-						"-",
-						[
-							1,
-							"vigD2",
-							"*",
-							"strength"
-						]
-					],
-					[5, "0"],
-					[5, "1"]
-				]
-			]]
-		]]
-	},
-	externals: {
-		"geom.aspectOf": () => aspectOf,
-		"std.clamp": () => clamp
-	}
-}) && $.f)({}));
-const screenGlowComposite = typegpu_default.fn([vec4f, vec3f], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, leakRgb) => {
-	"use gpu";
-	const base = color.xyz;
-	const outRgb = clamp(vec3f(1, 1, 1).sub(vec3f(1, 1, 1).sub(clamp(base, vec3f(0), vec3f(1))).mul(vec3f(1, 1, 1).sub(clamp(leakRgb, vec3f(0), vec3f(1))))).add(leakRgb.mul(.16)), vec3f(0), vec3f(1));
-	const leakLuma = clamp(luma601Dot(leakRgb), 0, 1);
-	return vec4f(outRgb, clamp(__tsover_add(color.w, __tsover_mul(leakLuma, .85)), 0, 1));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "color"
-		}, {
-			"type": "i",
-			"name": "leakRgb"
-		}],
-		"body": [0, [
-			[
-				13,
-				"base",
-				[
-					7,
-					"color",
-					"xyz"
-				]
-			],
-			[
-				13,
-				"screened",
-				[
-					6,
-					[
-						7,
-						[
-							6,
-							"d.vec3f",
-							[
-								[5, "1"],
-								[5, "1"],
-								[5, "1"]
-							]
-						],
-						"sub"
-					],
-					[[
-						6,
-						[
-							7,
-							[
-								6,
-								[
-									7,
-									[
-										6,
-										"d.vec3f",
-										[
-											[5, "1"],
-											[5, "1"],
-											[5, "1"]
-										]
-									],
-									"sub"
-								],
-								[[
-									6,
-									"std.clamp",
-									[
-										"base",
-										[
-											6,
-											"d.vec3f",
-											[[5, "0"]]
-										],
-										[
-											6,
-											"d.vec3f",
-											[[5, "1"]]
-										]
-									]
-								]]
-							],
-							"mul"
-						],
-						[[
-							6,
-							[
-								7,
-								[
-									6,
-									"d.vec3f",
-									[
-										[5, "1"],
-										[5, "1"],
-										[5, "1"]
-									]
-								],
-								"sub"
-							],
-							[[
-								6,
-								"std.clamp",
-								[
-									"leakRgb",
-									[
-										6,
-										"d.vec3f",
-										[[5, "0"]]
-									],
-									[
-										6,
-										"d.vec3f",
-										[[5, "1"]]
-									]
-								]
-							]]
-						]]
-					]]
-				]
-			],
-			[
-				13,
-				"lifted",
-				[
-					6,
-					[
-						7,
-						"screened",
-						"add"
-					],
-					[[
-						6,
-						[
-							7,
-							"leakRgb",
-							"mul"
-						],
-						[[5, "0.16"]]
-					]]
-				]
-			],
-			[
-				13,
-				"outRgb",
-				[
-					6,
-					"std.clamp",
-					[
-						"lifted",
-						[
-							6,
-							"d.vec3f",
-							[[5, "0"]]
-						],
-						[
-							6,
-							"d.vec3f",
-							[[5, "1"]]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"leakLuma",
-				[
-					6,
-					"std.clamp",
-					[
-						[
-							6,
-							"tone.luma601Dot",
-							["leakRgb"]
-						],
-						[5, "0"],
-						[5, "1"]
-					]
-				]
-			],
-			[
-				13,
-				"outA",
-				[
-					6,
-					"std.clamp",
-					[
-						[
-							1,
-							[
-								7,
-								"color",
-								"w"
-							],
-							"+",
-							[
-								1,
-								"leakLuma",
-								"*",
-								[5, "0.85"]
-							]
-						],
-						[5, "0"],
-						[5, "1"]
-					]
-				]
-			],
-			[10, [
-				6,
-				"d.vec4f",
-				["outRgb", "outA"]
-			]]
-		]]
-	},
-	externals: {
-		"d.vec3f": () => vec3f,
-		"std.clamp": () => clamp,
-		"tone.luma601Dot": () => luma601Dot,
-		"d.vec4f": () => vec4f
-	}
-}) && $.f)({}));
-const beamLocalFrame = typegpu_default.fn([
-	vec2f,
-	f32,
-	vec2f
-], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, anchorRaw) => {
-	"use gpu";
-	const pA = vec2f(__tsover_mul(uv.x, aspect), uv.y);
-	const anchor = vec2f(__tsover_mul(anchorRaw.x, aspect), __tsover_sub(1, anchorRaw.y));
-	const toCenter = vec2f(__tsover_mul(aspect, .5), .5).sub(anchor);
-	const cLen = length(toCenter);
-	const dirX = select(__tsover_div(toCenter.x, max(cLen, .001)), f32(1), cLen < .02);
-	const dirY = select(__tsover_div(toCenter.y, max(cLen, .001)), f32(0), cLen < .02);
-	const relX = __tsover_sub(pA.x, anchor.x);
-	const relY = __tsover_sub(pA.y, anchor.y);
-	return vec2f(__tsover_add(__tsover_mul(relX, dirX), __tsover_mul(relY, dirY)), __tsover_sub(__tsover_mul(relY, dirX), __tsover_mul(relX, dirY)));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "uv"
-			},
-			{
-				"type": "i",
-				"name": "aspect"
-			},
-			{
-				"type": "i",
-				"name": "anchorRaw"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"pA",
-				[
-					6,
-					"d.vec2f",
-					[[
-						1,
-						[
-							7,
-							"uv",
-							"x"
-						],
-						"*",
-						"aspect"
-					], [
-						7,
-						"uv",
-						"y"
-					]]
-				]
-			],
-			[
-				13,
-				"anchor",
-				[
-					6,
-					"d.vec2f",
-					[[
-						1,
-						[
-							7,
-							"anchorRaw",
-							"x"
-						],
-						"*",
-						"aspect"
-					], [
-						1,
-						[5, "1"],
-						"-",
-						[
-							7,
-							"anchorRaw",
-							"y"
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"toCenter",
-				[
-					6,
-					[
-						7,
-						[
-							6,
-							"d.vec2f",
-							[[
-								1,
-								"aspect",
-								"*",
-								[5, "0.5"]
-							], [5, "0.5"]]
-						],
-						"sub"
-					],
-					["anchor"]
-				]
-			],
-			[
-				13,
-				"cLen",
-				[
-					6,
-					"std.length",
-					["toCenter"]
-				]
-			],
-			[
-				13,
-				"dirX",
-				[
-					6,
-					"std.select",
-					[
-						[
-							1,
-							[
-								7,
-								"toCenter",
-								"x"
-							],
-							"/",
-							[
-								6,
-								"std.max",
-								["cLen", [5, "0.001"]]
-							]
-						],
-						[
-							6,
-							"d.f32",
-							[[5, "1"]]
-						],
-						[
-							1,
-							"cLen",
-							"<",
-							[5, "0.02"]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"dirY",
-				[
-					6,
-					"std.select",
-					[
-						[
-							1,
-							[
-								7,
-								"toCenter",
-								"y"
-							],
-							"/",
-							[
-								6,
-								"std.max",
-								["cLen", [5, "0.001"]]
-							]
-						],
-						[
-							6,
-							"d.f32",
-							[[5, "0"]]
-						],
-						[
-							1,
-							"cLen",
-							"<",
-							[5, "0.02"]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"relX",
-				[
-					1,
-					[
-						7,
-						"pA",
-						"x"
-					],
-					"-",
-					[
-						7,
-						"anchor",
-						"x"
-					]
-				]
-			],
-			[
-				13,
-				"relY",
-				[
-					1,
-					[
-						7,
-						"pA",
-						"y"
-					],
-					"-",
-					[
-						7,
-						"anchor",
-						"y"
-					]
-				]
-			],
-			[10, [
-				6,
-				"d.vec2f",
-				[[
-					1,
-					[
-						1,
-						"relX",
-						"*",
-						"dirX"
-					],
-					"+",
-					[
-						1,
-						"relY",
-						"*",
-						"dirY"
-					]
-				], [
-					1,
-					[
-						1,
-						"relY",
-						"*",
-						"dirX"
-					],
-					"-",
-					[
-						1,
-						"relX",
-						"*",
-						"dirY"
-					]
-				]]
-			]]
-		]]
-	},
-	externals: {
-		"d.vec2f": () => vec2f,
-		"std.length": () => length,
-		"std.select": () => select,
-		"std.max": () => max,
-		"d.f32": () => f32
-	}
-}) && $.f)({}));
-export { chromaticRingBand as a, radialFeatherMask as c, screenGlowComposite as d, seamlessAngularField as f, vignetteMask as g, taperedSegmentGlow as h, chromaticHeatTaps as i, radialGaussianFalloff as l, streakBand as m, anisotropicGaussianSpot as n, pointToSegment as o, softRayLobes as p, beamLocalFrame as r, radialBurstFrame as s, angularCosineSpikes as t, radialGaussianGlow as u };