shaders 3.0.453 → 3.1.455

package/dist/core/lightfields-ffHoLyJn.js

@@ -0,0 +1,1550 @@
+import { At as max, Bt as sin, Dt as floor, Gt as data_exports, Ht as sqrt, Mt as mix, Pt as pow, St as cos, Tt as exp, Vt as smoothstep, _t as abs, at as std_exports, gt as select, kt as length, on as vec3f, pn as __export, rn as vec2f, rt as src_default, un as f32, xt as clamp, yt as atan2 } from "./edges-CD7gCAto.js";
+import { o as TAU } from "./constants-DoOzbl5b.js";
+var lightfields_exports = /* @__PURE__ */ __export({
+	angularCosineSpikes: () => angularCosineSpikes,
+	angularSineLobes: () => angularSineLobes,
+	anisotropicGaussianSpot: () => anisotropicGaussianSpot,
+	beamLocalFrame: () => beamLocalFrame,
+	chromaticRingBand: () => chromaticRingBand,
+	pointToSegment: () => pointToSegment,
+	radialGaussianFalloff: () => radialGaussianFalloff,
+	radialGaussianGlow: () => radialGaussianGlow,
+	seamlessAngularField: () => seamlessAngularField,
+	taperedSegmentGlow: () => taperedSegmentGlow
+});
+const radialGaussianFalloff = src_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: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "dist"
+		}, {
+			"type": "i",
+			"name": "sharpness"
+		}],
+		"body": [0, [[10, [
+			6,
+			[
+				7,
+				"std",
+				"exp"
+			],
+			[[
+				4,
+				"-",
+				[
+					1,
+					[
+						1,
+						"dist",
+						"*",
+						"dist"
+					],
+					"*",
+					"sharpness"
+				]
+			]]
+		]]]],
+		"externalNames": ["std"]
+	},
+	externals: () => ({ std: std_exports })
+}) && $.f)({}));
+const anisotropicGaussianSpot = src_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: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "du"
+			},
+			{
+				"type": "i",
+				"name": "dv"
+			},
+			{
+				"type": "i",
+				"name": "sharpness"
+			}
+		],
+		"body": [0, [[10, [
+			6,
+			[
+				7,
+				"std",
+				"exp"
+			],
+			[[
+				1,
+				[
+					1,
+					[
+						1,
+						"du",
+						"*",
+						"du"
+					],
+					"+",
+					[
+						1,
+						"dv",
+						"*",
+						"dv"
+					]
+				],
+				"*",
+				[
+					4,
+					"-",
+					"sharpness"
+				]
+			]]
+		]]]],
+		"externalNames": ["std"]
+	},
+	externals: () => ({ std: std_exports })
+}) && $.f)({}));
+const radialGaussianGlow = src_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: 1,
+	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,
+				[
+					7,
+					"std",
+					"exp"
+				],
+				[[
+					1,
+					[
+						1,
+						[
+							4,
+							"-",
+							[5, "0.5"]
+						],
+						"*",
+						"dd2"
+					],
+					"/",
+					"sizeSq"
+				]]
+			]]
+		]],
+		"externalNames": ["std"]
+	},
+	externals: () => ({ std: std_exports })
+}) && $.f)({}));
+const angularSineLobes = src_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: 1,
+	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,
+						[
+							7,
+							"std",
+							"sin"
+						],
+						[[
+							1,
+							[
+								1,
+								"angle",
+								"*",
+								"count"
+							],
+							"+",
+							"phase"
+						]]
+					],
+					"*",
+					[5, "0.5"]
+				],
+				"+",
+				[5, "0.5"]
+			]
+		], [10, [
+			6,
+			[
+				7,
+				"std",
+				"pow"
+			],
+			["t", "sharpness"]
+		]]]],
+		"externalNames": ["std"]
+	},
+	externals: () => ({ std: std_exports })
+}) && $.f)({}));
+const angularCosineSpikes = src_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: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "angle"
+			},
+			{
+				"type": "i",
+				"name": "halfCount"
+			},
+			{
+				"type": "i",
+				"name": "power"
+			}
+		],
+		"body": [0, [[10, [
+			6,
+			[
+				7,
+				"std",
+				"pow"
+			],
+			[[
+				6,
+				[
+					7,
+					"std",
+					"abs"
+				],
+				[[
+					6,
+					[
+						7,
+						"std",
+						"cos"
+					],
+					[[
+						1,
+						"angle",
+						"*",
+						"halfCount"
+					]]
+				]]
+			], "power"]
+		]]]],
+		"externalNames": ["std"]
+	},
+	externals: () => ({ std: std_exports })
+}) && $.f)({}));
+const seamlessAngularField = src_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: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "delta"
+		}],
+		"body": [0, [
+			[
+				13,
+				"angle",
+				[
+					6,
+					[
+						7,
+						"std",
+						"atan2"
+					],
+					[[
+						7,
+						"delta",
+						"y"
+					], [
+						7,
+						"delta",
+						"x"
+					]]
+				]
+			],
+			[
+				13,
+				"angleWrapped",
+				[
+					1,
+					"angle",
+					"-",
+					[
+						1,
+						"TAU",
+						"*",
+						[
+							6,
+							[
+								7,
+								"std",
+								"floor"
+							],
+							[[
+								1,
+								"angle",
+								"/",
+								"TAU"
+							]]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"blend",
+				[
+					6,
+					[
+						7,
+						"std",
+						"smoothstep"
+					],
+					[
+						[
+							4,
+							"-",
+							[5, "0.15"]
+						],
+						[5, "0.15"],
+						[
+							7,
+							"delta",
+							"x"
+						]
+					]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"d",
+					"vec3f"
+				],
+				[
+					"angle",
+					"angleWrapped",
+					"blend"
+				]
+			]]
+		]],
+		"externalNames": [
+			"std",
+			"TAU",
+			"d"
+		]
+	},
+	externals: () => ({
+		std: std_exports,
+		TAU,
+		d: data_exports
+	})
+}) && $.f)({}));
+const chromaticRingBand = src_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: 1,
+	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,
+					[
+						7,
+						"std",
+						"max"
+					],
+					["width", [5, "0.0001"]]
+				]
+			],
+			[
+				13,
+				"r",
+				[
+					1,
+					[5, "1"],
+					"-",
+					[
+						6,
+						[
+							7,
+							"std",
+							"smoothstep"
+						],
+						[
+							[5, "0"],
+							"w",
+							[
+								6,
+								[
+									7,
+									"std",
+									"abs"
+								],
+								[[
+									1,
+									"dist",
+									"-",
+									[
+										1,
+										"center",
+										"+",
+										"spread"
+									]
+								]]
+							]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"g",
+				[
+					1,
+					[5, "1"],
+					"-",
+					[
+						6,
+						[
+							7,
+							"std",
+							"smoothstep"
+						],
+						[
+							[5, "0"],
+							"w",
+							[
+								6,
+								[
+									7,
+									"std",
+									"abs"
+								],
+								[[
+									1,
+									"dist",
+									"-",
+									"center"
+								]]
+							]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"b",
+				[
+					1,
+					[5, "1"],
+					"-",
+					[
+						6,
+						[
+							7,
+							"std",
+							"smoothstep"
+						],
+						[
+							[5, "0"],
+							"w",
+							[
+								6,
+								[
+									7,
+									"std",
+									"abs"
+								],
+								[[
+									1,
+									"dist",
+									"-",
+									[
+										1,
+										"center",
+										"-",
+										"spread"
+									]
+								]]
+							]
+						]
+					]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"d",
+					"vec3f"
+				],
+				[
+					"r",
+					"g",
+					"b"
+				]
+			]]
+		]],
+		"externalNames": ["std", "d"]
+	},
+	externals: () => ({
+		std: std_exports,
+		d: data_exports
+	})
+}) && $.f)({}));
+const pointToSegment = src_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: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "p"
+			},
+			{
+				"type": "i",
+				"name": "a"
+			},
+			{
+				"type": "i",
+				"name": "b"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"lineVec",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec2f"
+					],
+					[[
+						1,
+						[
+							7,
+							"b",
+							"x"
+						],
+						"-",
+						[
+							7,
+							"a",
+							"x"
+						]
+					], [
+						1,
+						[
+							7,
+							"b",
+							"y"
+						],
+						"-",
+						[
+							7,
+							"a",
+							"y"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"toPoint",
+				[
+					6,
+					[
+						7,
+						"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,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							"dotProduct",
+							"/",
+							[
+								6,
+								[
+									7,
+									"std",
+									"max"
+								],
+								["lineLengthSq", [5, "0.0001"]]
+							]
+						],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"closestPoint",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec2f"
+					],
+					[[
+						1,
+						[
+							7,
+							"a",
+							"x"
+						],
+						"+",
+						[
+							1,
+							[
+								7,
+								"lineVec",
+								"x"
+							],
+							"*",
+							"t"
+						]
+					], [
+						1,
+						[
+							7,
+							"a",
+							"y"
+						],
+						"+",
+						[
+							1,
+							[
+								7,
+								"lineVec",
+								"y"
+							],
+							"*",
+							"t"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"distVec",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec2f"
+					],
+					[[
+						1,
+						[
+							7,
+							"p",
+							"x"
+						],
+						"-",
+						[
+							7,
+							"closestPoint",
+							"x"
+						]
+					], [
+						1,
+						[
+							7,
+							"p",
+							"y"
+						],
+						"-",
+						[
+							7,
+							"closestPoint",
+							"y"
+						]
+					]]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"d",
+					"vec2f"
+				],
+				["t", [
+					6,
+					[
+						7,
+						"std",
+						"sqrt"
+					],
+					[[
+						1,
+						[
+							1,
+							[
+								7,
+								"distVec",
+								"x"
+							],
+							"*",
+							[
+								7,
+								"distVec",
+								"x"
+							]
+						],
+						"+",
+						[
+							1,
+							[
+								7,
+								"distVec",
+								"y"
+							],
+							"*",
+							[
+								7,
+								"distVec",
+								"y"
+							]
+						]
+					]]
+				]]
+			]]
+		]],
+		"externalNames": ["d", "std"]
+	},
+	externals: () => ({
+		d: data_exports,
+		std: std_exports
+	})
+}) && $.f)({}));
+const taperedSegmentGlow = src_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: 1,
+	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,
+					[
+						7,
+						"std",
+						"mix"
+					],
+					[
+						"startThickness",
+						"endThickness",
+						"t"
+					]
+				]
+			],
+			[
+				13,
+				"softness",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"mix"
+						],
+						[
+							"startSoftness",
+							"endSoftness",
+							"t"
+						]
+					], [5, "0.0001"]]
+				]
+			],
+			[
+				13,
+				"normalizedDist",
+				[
+					1,
+					"dist",
+					"/",
+					[
+						6,
+						[
+							7,
+							"std",
+							"max"
+						],
+						["thickness", [5, "0.0001"]]
+					]
+				]
+			],
+			[
+				13,
+				"edgeEnd",
+				[
+					1,
+					[5, "1"],
+					"+",
+					"softness"
+				]
+			],
+			[
+				13,
+				"alphaBase",
+				[
+					1,
+					[5, "1"],
+					"-",
+					[
+						6,
+						[
+							7,
+							"std",
+							"smoothstep"
+						],
+						[
+							[5, "1"],
+							"edgeEnd",
+							"normalizedDist"
+						]
+					]
+				]
+			],
+			[
+				13,
+				"softnessFactor",
+				[
+					1,
+					[5, "1"],
+					"+",
+					[
+						1,
+						"softness",
+						"*",
+						[5, "1.5"]
+					]
+				]
+			],
+			[
+				13,
+				"alpha",
+				[
+					6,
+					[
+						7,
+						"std",
+						"pow"
+					],
+					["alphaBase", "softnessFactor"]
+				]
+			],
+			[
+				13,
+				"colorGradientStart",
+				[
+					1,
+					[5, "1"],
+					"-",
+					"softness"
+				]
+			],
+			[
+				13,
+				"colorGradientEnd",
+				[
+					1,
+					[5, "1"],
+					"+",
+					"softness"
+				]
+			],
+			[
+				13,
+				"colorT",
+				[
+					6,
+					[
+						7,
+						"std",
+						"smoothstep"
+					],
+					[
+						"colorGradientStart",
+						"colorGradientEnd",
+						"normalizedDist"
+					]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"d",
+					"vec2f"
+				],
+				["colorT", "alpha"]
+			]]
+		]],
+		"externalNames": ["std", "d"]
+	},
+	externals: () => ({
+		std: std_exports,
+		d: data_exports
+	})
+}) && $.f)({}));
+const beamLocalFrame = src_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: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "aspect"
+			},
+			{
+				"type": "i",
+				"name": "anchorRaw"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"pA",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec2f"
+					],
+					[[
+						1,
+						[
+							7,
+							"uv",
+							"x"
+						],
+						"*",
+						"aspect"
+					], [
+						7,
+						"uv",
+						"y"
+					]]
+				]
+			],
+			[
+				13,
+				"anchor",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec2f"
+					],
+					[[
+						1,
+						[
+							7,
+							"anchorRaw",
+							"x"
+						],
+						"*",
+						"aspect"
+					], [
+						1,
+						[5, "1"],
+						"-",
+						[
+							7,
+							"anchorRaw",
+							"y"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"toCenter",
+				[
+					6,
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec2f"
+							],
+							[[
+								1,
+								"aspect",
+								"*",
+								[5, "0.5"]
+							], [5, "0.5"]]
+						],
+						"sub"
+					],
+					["anchor"]
+				]
+			],
+			[
+				13,
+				"cLen",
+				[
+					6,
+					[
+						7,
+						"std",
+						"length"
+					],
+					["toCenter"]
+				]
+			],
+			[
+				13,
+				"dirX",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						[
+							1,
+							[
+								7,
+								"toCenter",
+								"x"
+							],
+							"/",
+							[
+								6,
+								[
+									7,
+									"std",
+									"max"
+								],
+								["cLen", [5, "0.001"]]
+							]
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "1"]]
+						],
+						[
+							1,
+							"cLen",
+							"<",
+							[5, "0.02"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"dirY",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						[
+							1,
+							[
+								7,
+								"toCenter",
+								"y"
+							],
+							"/",
+							[
+								6,
+								[
+									7,
+									"std",
+									"max"
+								],
+								["cLen", [5, "0.001"]]
+							]
+						],
+						[
+							6,
+							[
+								7,
+								"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,
+				[
+					7,
+					"d",
+					"vec2f"
+				],
+				[[
+					1,
+					[
+						1,
+						"relX",
+						"*",
+						"dirX"
+					],
+					"+",
+					[
+						1,
+						"relY",
+						"*",
+						"dirY"
+					]
+				], [
+					1,
+					[
+						1,
+						"relY",
+						"*",
+						"dirX"
+					],
+					"-",
+					[
+						1,
+						"relX",
+						"*",
+						"dirY"
+					]
+				]]
+			]]
+		]],
+		"externalNames": ["d", "std"]
+	},
+	externals: () => ({
+		d: data_exports,
+		std: std_exports
+	})
+}) && $.f)({}));
+export { chromaticRingBand as a, radialGaussianFalloff as c, taperedSegmentGlow as d, beamLocalFrame as i, radialGaussianGlow as l, angularSineLobes as n, lightfields_exports as o, anisotropicGaussianSpot as r, pointToSegment as s, angularCosineSpikes as t, seamlessAngularField as u };