shaders 3.2.464 → 3.2.465

package/dist/core/{gradientPaints-B6-PoDoK.js → gradientPaints-Du0XCNHB.js}

@@ -1,7 +1,918 @@
-import { $n as vec4f, Cn as atan2, En as cos, Fn as min, Gn as sqrt, In as mix, Jn as vec2f, Jt as aspectCentrePosition, Kn as step, Ln as normalize, Mn as fract, Nn as length, On as dot, Pn as max, Qt as directionalProjection, Rn as pow, Tn as clamp, Un as sin, Wn as smoothstep, Xt as aspectOf, Zn as vec3f, Zt as canvasCentredDelta, bn as select, hr as f32, in as DEG_TO_RAD, jn as floor, kn as exp, ln as TAU, lr as mod, mn as typegpu_default, qt as aspectCenteredDelta, rn as unflipPosition, tn as rotate2, un as TWO_PI, xn as abs } from "./lower-z2vuXP8M.js";
-import { T as fwidth, f as mxNoiseFloat3, s as hash12, y as value12 } from "./noise-B3Oq1k3_.js";
-import { i as toneRemap } from "./tone-BA0D_veZ.js";
-import { f as seamlessAngularField, h as taperedSegmentGlow, m as streakBand, n as anisotropicGaussianSpot, o as pointToSegment } from "./lightfields-BjzpZvFy.js";
+import { $n as clamp, An as DEG_TO_RAD, Br as f32, En as value12, Fn as TWO_PI, Gn as dpdy, Jn as select, Kn as fwidth, Pn as TAU, Pr as mod, Tr as vec4f, Wn as dpdx, Xt as aspectCenteredDelta, Yn as abs, Zn as atan2, Zt as aspectCentrePosition, _r as smoothstep, an as rotate2, ar as floor, cr as max, dr as normalize, en as aspectOf, er as cos, fr as pow, gr as sin, lr as min, mn as hash12, nn as directionalProjection, nr as dot, or as fract, rr as exp, sn as unflipPosition, sr as length, tn as canvasCentredDelta, ur as mix, vr as sqrt, wr as vec3f, xr as vec2f, yn as mxNoiseFloat3, yr as step, zn as typegpu_default } from "./lower-DSk_KxOY.js";
+import { a as toneRemap } from "./tone-Ax72n2WU.js";
+import { f as seamlessAngularField, h as taperedSegmentGlow, m as streakBand, n as anisotropicGaussianSpot, o as pointToSegment } from "./lightfields-D5lW4WSp.js";
+const footprint1 = typegpu_default.fn([f32, f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x, softness) => {
+	"use gpu";
+	const baseW = max(abs(dpdx(x)), abs(dpdy(x)));
+	return max(__tsover_add(baseW, softness), 1e-5);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "x"
+		}, {
+			"type": "i",
+			"name": "softness"
+		}],
+		"body": [0, [[
+			13,
+			"baseW",
+			[
+				6,
+				"std.max",
+				[[
+					6,
+					"std.abs",
+					[[
+						6,
+						"std.dpdx",
+						["x"]
+					]]
+				], [
+					6,
+					"std.abs",
+					[[
+						6,
+						"std.dpdy",
+						["x"]
+					]]
+				]]
+			]
+		], [10, [
+			6,
+			"std.max",
+			[[
+				1,
+				"baseW",
+				"+",
+				"softness"
+			], [5, "0.00001"]]
+		]]]]
+	},
+	externals: {
+		"std.max": () => max,
+		"std.abs": () => abs,
+		"std.dpdx": () => dpdx,
+		"std.dpdy": () => dpdy
+	}
+}) && $.f)({}));
+const footprint2 = typegpu_default.fn([vec2f, f32], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p, softness) => {
+	"use gpu";
+	const dpx = dpdx(p);
+	const dpy = dpdy(p);
+	const baseW = vec2f(max(abs(dpx.x), abs(dpy.x)), max(abs(dpx.y), abs(dpy.y)));
+	return vec2f(max(__tsover_add(baseW.x, softness), 1e-5), max(__tsover_add(baseW.y, softness), 1e-5));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "p"
+		}, {
+			"type": "i",
+			"name": "softness"
+		}],
+		"body": [0, [
+			[
+				13,
+				"dpx",
+				[
+					6,
+					"std.dpdx",
+					["p"]
+				]
+			],
+			[
+				13,
+				"dpy",
+				[
+					6,
+					"std.dpdy",
+					["p"]
+				]
+			],
+			[
+				13,
+				"baseW",
+				[
+					6,
+					"d.vec2f",
+					[[
+						6,
+						"std.max",
+						[[
+							6,
+							"std.abs",
+							[[
+								7,
+								"dpx",
+								"x"
+							]]
+						], [
+							6,
+							"std.abs",
+							[[
+								7,
+								"dpy",
+								"x"
+							]]
+						]]
+					], [
+						6,
+						"std.max",
+						[[
+							6,
+							"std.abs",
+							[[
+								7,
+								"dpx",
+								"y"
+							]]
+						], [
+							6,
+							"std.abs",
+							[[
+								7,
+								"dpy",
+								"y"
+							]]
+						]]
+					]]
+				]
+			],
+			[10, [
+				6,
+				"d.vec2f",
+				[[
+					6,
+					"std.max",
+					[[
+						1,
+						[
+							7,
+							"baseW",
+							"x"
+						],
+						"+",
+						"softness"
+					], [5, "0.00001"]]
+				], [
+					6,
+					"std.max",
+					[[
+						1,
+						[
+							7,
+							"baseW",
+							"y"
+						],
+						"+",
+						"softness"
+					], [5, "0.00001"]]
+				]]
+			]]
+		]]
+	},
+	externals: {
+		"std.dpdx": () => dpdx,
+		"std.dpdy": () => dpdy,
+		"d.vec2f": () => vec2f,
+		"std.max": () => max,
+		"std.abs": () => abs
+	}
+}) && $.f)({}));
+const quilezStepFilter = typegpu_default.fn([
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p, w, threshold) => {
+	"use gpu";
+	const a = __tsover_add(p, __tsover_mul(w, .5));
+	const b = __tsover_sub(p, __tsover_mul(w, .5));
+	const oneMinusThreshold = __tsover_sub(1, threshold);
+	const Fa = __tsover_add(__tsover_mul(floor(a), oneMinusThreshold), max(__tsover_sub(fract(a), threshold), 0));
+	const Fb = __tsover_add(__tsover_mul(floor(b), oneMinusThreshold), max(__tsover_sub(fract(b), threshold), 0));
+	return clamp(__tsover_div(__tsover_sub(Fa, Fb), w), 0, 1);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "p"
+			},
+			{
+				"type": "i",
+				"name": "w"
+			},
+			{
+				"type": "i",
+				"name": "threshold"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"a",
+				[
+					1,
+					"p",
+					"+",
+					[
+						1,
+						"w",
+						"*",
+						[5, "0.5"]
+					]
+				]
+			],
+			[
+				13,
+				"b",
+				[
+					1,
+					"p",
+					"-",
+					[
+						1,
+						"w",
+						"*",
+						[5, "0.5"]
+					]
+				]
+			],
+			[
+				13,
+				"oneMinusThreshold",
+				[
+					1,
+					[5, "1"],
+					"-",
+					"threshold"
+				]
+			],
+			[
+				13,
+				"Fa",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							"std.floor",
+							["a"]
+						],
+						"*",
+						"oneMinusThreshold"
+					],
+					"+",
+					[
+						6,
+						"std.max",
+						[[
+							1,
+							[
+								6,
+								"std.fract",
+								["a"]
+							],
+							"-",
+							"threshold"
+						], [5, "0"]]
+					]
+				]
+			],
+			[
+				13,
+				"Fb",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							"std.floor",
+							["b"]
+						],
+						"*",
+						"oneMinusThreshold"
+					],
+					"+",
+					[
+						6,
+						"std.max",
+						[[
+							1,
+							[
+								6,
+								"std.fract",
+								["b"]
+							],
+							"-",
+							"threshold"
+						], [5, "0"]]
+					]
+				]
+			],
+			[10, [
+				6,
+				"std.clamp",
+				[
+					[
+						1,
+						[
+							1,
+							"Fa",
+							"-",
+							"Fb"
+						],
+						"/",
+						"w"
+					],
+					[5, "0"],
+					[5, "1"]
+				]
+			]]
+		]]
+	},
+	externals: {
+		"std.floor": () => floor,
+		"std.max": () => max,
+		"std.fract": () => fract,
+		"std.clamp": () => clamp
+	}
+}) && $.f)({}));
+const quilezLineFilterAxis = typegpu_default.fn([
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p, w, N) => {
+	"use gpu";
+	const a = __tsover_add(p, __tsover_mul(w, .5));
+	const b = __tsover_sub(p, __tsover_mul(w, .5));
+	return __tsover_div(__tsover_sub(__tsover_sub(__tsover_add(floor(a), min(__tsover_mul(fract(a), N), 1)), floor(b)), min(__tsover_mul(fract(b), N), 1)), __tsover_mul(N, w));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "p"
+			},
+			{
+				"type": "i",
+				"name": "w"
+			},
+			{
+				"type": "i",
+				"name": "N"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"a",
+				[
+					1,
+					"p",
+					"+",
+					[
+						1,
+						"w",
+						"*",
+						[5, "0.5"]
+					]
+				]
+			],
+			[
+				13,
+				"b",
+				[
+					1,
+					"p",
+					"-",
+					[
+						1,
+						"w",
+						"*",
+						[5, "0.5"]
+					]
+				]
+			],
+			[10, [
+				1,
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								6,
+								"std.floor",
+								["a"]
+							],
+							"+",
+							[
+								6,
+								"std.min",
+								[[
+									1,
+									[
+										6,
+										"std.fract",
+										["a"]
+									],
+									"*",
+									"N"
+								], [5, "1"]]
+							]
+						],
+						"-",
+						[
+							6,
+							"std.floor",
+							["b"]
+						]
+					],
+					"-",
+					[
+						6,
+						"std.min",
+						[[
+							1,
+							[
+								6,
+								"std.fract",
+								["b"]
+							],
+							"*",
+							"N"
+						], [5, "1"]]
+					]
+				],
+				"/",
+				[
+					1,
+					"N",
+					"*",
+					"w"
+				]
+			]]
+		]]
+	},
+	externals: {
+		"std.floor": () => floor,
+		"std.min": () => min,
+		"std.fract": () => fract
+	}
+}) && $.f)({}));
+const quilezCheckerFilter = typegpu_default.fn([vec2f, vec2f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p, w) => {
+	"use gpu";
+	const aHalf = vec2f(__tsover_mul(w.x, .5), __tsover_mul(w.y, .5));
+	const minusSideX = abs(__tsover_sub(fract(__tsover_mul(__tsover_sub(p.x, aHalf.x), .5)), .5));
+	const minusSideY = abs(__tsover_sub(fract(__tsover_mul(__tsover_sub(p.y, aHalf.y), .5)), .5));
+	const plusSideX = abs(__tsover_sub(fract(__tsover_mul(__tsover_add(p.x, aHalf.x), .5)), .5));
+	const plusSideY = abs(__tsover_sub(fract(__tsover_mul(__tsover_add(p.y, aHalf.y), .5)), .5));
+	const iX = __tsover_div(__tsover_mul(__tsover_sub(minusSideX, plusSideX), 2), w.x);
+	const iY = __tsover_div(__tsover_mul(__tsover_sub(minusSideY, plusSideY), 2), w.y);
+	return clamp(__tsover_sub(.5, __tsover_mul(__tsover_mul(iX, iY), .5)), 0, 1);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "p"
+		}, {
+			"type": "i",
+			"name": "w"
+		}],
+		"body": [0, [
+			[
+				13,
+				"aHalf",
+				[
+					6,
+					"d.vec2f",
+					[[
+						1,
+						[
+							7,
+							"w",
+							"x"
+						],
+						"*",
+						[5, "0.5"]
+					], [
+						1,
+						[
+							7,
+							"w",
+							"y"
+						],
+						"*",
+						[5, "0.5"]
+					]]
+				]
+			],
+			[
+				13,
+				"minusSideX",
+				[
+					6,
+					"std.abs",
+					[[
+						1,
+						[
+							6,
+							"std.fract",
+							[[
+								1,
+								[
+									1,
+									[
+										7,
+										"p",
+										"x"
+									],
+									"-",
+									[
+										7,
+										"aHalf",
+										"x"
+									]
+								],
+								"*",
+								[5, "0.5"]
+							]]
+						],
+						"-",
+						[5, "0.5"]
+					]]
+				]
+			],
+			[
+				13,
+				"minusSideY",
+				[
+					6,
+					"std.abs",
+					[[
+						1,
+						[
+							6,
+							"std.fract",
+							[[
+								1,
+								[
+									1,
+									[
+										7,
+										"p",
+										"y"
+									],
+									"-",
+									[
+										7,
+										"aHalf",
+										"y"
+									]
+								],
+								"*",
+								[5, "0.5"]
+							]]
+						],
+						"-",
+						[5, "0.5"]
+					]]
+				]
+			],
+			[
+				13,
+				"plusSideX",
+				[
+					6,
+					"std.abs",
+					[[
+						1,
+						[
+							6,
+							"std.fract",
+							[[
+								1,
+								[
+									1,
+									[
+										7,
+										"p",
+										"x"
+									],
+									"+",
+									[
+										7,
+										"aHalf",
+										"x"
+									]
+								],
+								"*",
+								[5, "0.5"]
+							]]
+						],
+						"-",
+						[5, "0.5"]
+					]]
+				]
+			],
+			[
+				13,
+				"plusSideY",
+				[
+					6,
+					"std.abs",
+					[[
+						1,
+						[
+							6,
+							"std.fract",
+							[[
+								1,
+								[
+									1,
+									[
+										7,
+										"p",
+										"y"
+									],
+									"+",
+									[
+										7,
+										"aHalf",
+										"y"
+									]
+								],
+								"*",
+								[5, "0.5"]
+							]]
+						],
+						"-",
+						[5, "0.5"]
+					]]
+				]
+			],
+			[
+				13,
+				"iX",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							"minusSideX",
+							"-",
+							"plusSideX"
+						],
+						"*",
+						[5, "2"]
+					],
+					"/",
+					[
+						7,
+						"w",
+						"x"
+					]
+				]
+			],
+			[
+				13,
+				"iY",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							"minusSideY",
+							"-",
+							"plusSideY"
+						],
+						"*",
+						[5, "2"]
+					],
+					"/",
+					[
+						7,
+						"w",
+						"y"
+					]
+				]
+			],
+			[10, [
+				6,
+				"std.clamp",
+				[
+					[
+						1,
+						[5, "0.5"],
+						"-",
+						[
+							1,
+							[
+								1,
+								"iX",
+								"*",
+								"iY"
+							],
+							"*",
+							[5, "0.5"]
+						]
+					],
+					[5, "0"],
+					[5, "1"]
+				]
+			]]
+		]]
+	},
+	externals: {
+		"d.vec2f": () => vec2f,
+		"std.abs": () => abs,
+		"std.fract": () => fract,
+		"std.clamp": () => clamp
+	}
+}) && $.f)({}));
+const lineMaskFromField = typegpu_default.fn([
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((field, lineWidth, lo, hi) => {
+	"use gpu";
+	return __tsover_mul(__tsover_sub(1, smoothstep(lo, hi, field)), step(1e-4, lineWidth));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "field"
+			},
+			{
+				"type": "i",
+				"name": "lineWidth"
+			},
+			{
+				"type": "i",
+				"name": "lo"
+			},
+			{
+				"type": "i",
+				"name": "hi"
+			}
+		],
+		"body": [0, [[10, [
+			1,
+			[
+				1,
+				[5, "1"],
+				"-",
+				[
+					6,
+					"std.smoothstep",
+					[
+						"lo",
+						"hi",
+						"field"
+					]
+				]
+			],
+			"*",
+			[
+				6,
+				"std.step",
+				[[5, "0.0001"], "lineWidth"]
+			]
+		]]]]
+	},
+	externals: {
+		"std.smoothstep": () => smoothstep,
+		"std.step": () => step
+	}
+}) && $.f)({}));
+const bandMask = typegpu_default.fn([
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x, lo, hi) => {
+	"use gpu";
+	return __tsover_mul(smoothstep(lo, hi, x), smoothstep(lo, hi, __tsover_sub(1, x)));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "x"
+			},
+			{
+				"type": "i",
+				"name": "lo"
+			},
+			{
+				"type": "i",
+				"name": "hi"
+			}
+		],
+		"body": [0, [[10, [
+			1,
+			[
+				6,
+				"std.smoothstep",
+				[
+					"lo",
+					"hi",
+					"x"
+				]
+			],
+			"*",
+			[
+				6,
+				"std.smoothstep",
+				[
+					"lo",
+					"hi",
+					[
+						1,
+						[5, "1"],
+						"-",
+						"x"
+					]
+				]
+			]
+		]]]]
+	},
+	externals: { "std.smoothstep": () => smoothstep }
+}) && $.f)({}));
+const discCoverage = typegpu_default.fn([
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((dist, radius, footprint) => {
+	"use gpu";
+	return __tsover_sub(1, smoothstep(__tsover_sub(radius, __tsover_mul(footprint, .5)), radius, dist));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "dist"
+			},
+			{
+				"type": "i",
+				"name": "radius"
+			},
+			{
+				"type": "i",
+				"name": "footprint"
+			}
+		],
+		"body": [0, [[10, [
+			1,
+			[5, "1"],
+			"-",
+			[
+				6,
+				"std.smoothstep",
+				[
+					[
+						1,
+						"radius",
+						"-",
+						[
+							1,
+							"footprint",
+							"*",
+							[5, "0.5"]
+						]
+					],
+					"radius",
+					"dist"
+				]
+			]
+		]]]]
+	},
+	externals: { "std.smoothstep": () => smoothstep }
+}) && $.f)({}));
 var INV_360 = 1 / 360;
 const gradientRawT = typegpu_default.fn([
 	vec2f,
@@ -1365,7 +2276,7 @@ const colorWheelSelect = typegpu_default.fn([
 		"std.step": () => step
 	}
 }) && $.f)({}));
-typegpu_default.fn([
+const spiralOffset = typegpu_default.fn([
 	vec2f,
 	f32,
 	f32,
@@ -1539,11 +2450,8 @@ const spiralMask = typegpu_default.fn([
 ], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, scale, strokeWidth, strokeFalloff, softness, animTime, uv, viewport) => {
 	"use gpu";
 	const aspect = __tsover_div(viewport.x, viewport.y);
-	const dx = __tsover_sub(__tsover_mul(uv.x, aspect), __tsover_mul(center.x, aspect));
-	const dy = __tsover_sub(uv.y, __tsover_sub(1, center.y));
-	const l = length(vec2f(dx, dy));
-	const angle = __tsover_sub(atan2(dy, dx), animTime);
-	const offset = __tsover_add(__tsover_mul(l, scale), __tsover_div(angle, TWO_PI));
+	const l = length(vec2f(__tsover_sub(__tsover_mul(uv.x, aspect), __tsover_mul(center.x, aspect)), __tsover_sub(uv.y, __tsover_sub(1, center.y))));
+	const offset = spiralOffset(center, scale, animTime, uv, viewport);
 	const stripe = fract(offset);
 	const shape = __tsover_mul(abs(__tsover_sub(stripe, .5)), 2);
 	const baseWidth = clamp(strokeWidth, __tsover_mul(strokeFalloff, .005), 1);
@@ -1674,37 +2582,18 @@ const spiralMask = typegpu_default.fn([
 					]]
 				]
 			],
-			[
-				13,
-				"angle",
-				[
-					1,
-					[
-						6,
-						"std.atan2",
-						["dy", "dx"]
-					],
-					"-",
-					"animTime"
-				]
-			],
 			[
 				13,
 				"offset",
 				[
-					1,
-					[
-						1,
-						"l",
-						"*",
-						"scale"
-					],
-					"+",
+					6,
+					"spiralOffset",
 					[
-						1,
-						"angle",
-						"/",
-						"TWO_PI"
+						"center",
+						"scale",
+						"animTime",
+						"uv",
+						"viewport"
 					]
 				]
 			],
@@ -1911,8 +2800,7 @@ const spiralMask = typegpu_default.fn([
 	externals: {
 		"std.length": () => length,
 		"d.vec2f": () => vec2f,
-		"std.atan2": () => atan2,
-		"TWO_PI": () => TWO_PI,
+		"spiralOffset": () => spiralOffset,
 		"std.fract": () => fract,
 		"std.abs": () => abs,
 		"std.clamp": () => clamp,
@@ -4239,36 +5127,22 @@ const godraysFrame = typegpu_default.fn([
 		"std.length": () => length
 	}
 }) && $.f)({}));
-const godraysRayStack = typegpu_default.fn([
+var godraysRayLayer = typegpu_default.fn([
 	vec4f,
 	f32,
 	f32,
 	f32,
-	f32
-], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((frame, animTimeRaw, density, intensity, spotty) => {
+	f32,
+	vec4f,
+	vec2f
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((frame, animTime, spots, intensityCalc, dens, sched, freqs) => {
 	"use gpu";
-	const angle = frame.x;
-	const angleWrapped = frame.y;
-	const blendFactor = frame.z;
-	const radius = frame.w;
-	const animTime = __tsover_mul(animTimeRaw, .2);
-	const spots = __tsover_mul(6.5, abs(spotty));
-	const intensityCalc = __tsover_sub(4, __tsover_mul(3, clamp(intensity, 0, 1)));
-	const dens = __tsover_mul(6, density);
-	let accumRay = f32(0);
-	const r1 = __tsover_sub(__tsover_mul(radius, 1), __tsover_mul(animTime, 3));
-	const r2 = __tsover_sub(__tsover_mul(__tsover_mul(radius, .5), __tsover_add(1, spots)), __tsover_mul(animTime, 2));
-	const f1 = __tsover_mul(dens, 5);
-	let ray = godraysRaysShape(angle, angleWrapped, blendFactor, r1, f1, intensityCalc);
-	ray = __tsover_mul(ray, godraysRaysShape(angle, angleWrapped, blendFactor, r2, __tsover_mul(f1, 4), intensityCalc));
-	accumRay = __tsover_add(accumRay, ray);
-	const r3 = __tsover_sub(__tsover_mul(radius, 1.4), __tsover_mul(animTime, 2.5));
-	const r4 = __tsover_sub(__tsover_mul(__tsover_mul(radius, .7), __tsover_add(1, spots)), __tsover_mul(animTime, 1.8));
-	const f2 = __tsover_mul(dens, 4.5);
-	let ray2 = godraysRaysShape(angle, angleWrapped, blendFactor, r3, f2, intensityCalc);
-	ray2 = __tsover_mul(ray2, godraysRaysShape(angle, angleWrapped, blendFactor, r4, __tsover_mul(f2, 3.5), intensityCalc));
-	accumRay = __tsover_add(accumRay, __tsover_mul(ray2, .7));
-	return clamp(accumRay, 0, 1);
+	const rA = __tsover_sub(__tsover_mul(frame.w, sched.x), __tsover_mul(animTime, sched.y));
+	const rB = __tsover_sub(__tsover_mul(__tsover_mul(frame.w, sched.z), __tsover_add(1, spots)), __tsover_mul(animTime, sched.w));
+	const f = __tsover_mul(dens, freqs.x);
+	const shapeA = godraysRaysShape(frame.x, frame.y, frame.z, rA, f, intensityCalc);
+	const shapeB = godraysRaysShape(frame.x, frame.y, frame.z, rB, __tsover_mul(f, freqs.y), intensityCalc);
+	return __tsover_mul(shapeA, shapeB);
 }), {
 	v: 2,
 	name: void 0,
@@ -4280,58 +5154,235 @@ const godraysRayStack = typegpu_default.fn([
 			},
 			{
 				"type": "i",
-				"name": "animTimeRaw"
+				"name": "animTime"
 			},
 			{
 				"type": "i",
-				"name": "density"
+				"name": "spots"
 			},
 			{
 				"type": "i",
-				"name": "intensity"
+				"name": "intensityCalc"
 			},
 			{
 				"type": "i",
-				"name": "spotty"
+				"name": "dens"
+			},
+			{
+				"type": "i",
+				"name": "sched"
+			},
+			{
+				"type": "i",
+				"name": "freqs"
 			}
 		],
 		"body": [0, [
 			[
 				13,
-				"angle",
+				"rA",
 				[
-					7,
-					"frame",
-					"x"
+					1,
+					[
+						1,
+						[
+							7,
+							"frame",
+							"w"
+						],
+						"*",
+						[
+							7,
+							"sched",
+							"x"
+						]
+					],
+					"-",
+					[
+						1,
+						"animTime",
+						"*",
+						[
+							7,
+							"sched",
+							"y"
+						]
+					]
 				]
 			],
 			[
 				13,
-				"angleWrapped",
+				"rB",
 				[
-					7,
-					"frame",
-					"y"
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								7,
+								"frame",
+								"w"
+							],
+							"*",
+							[
+								7,
+								"sched",
+								"z"
+							]
+						],
+						"*",
+						[
+							1,
+							[5, "1"],
+							"+",
+							"spots"
+						]
+					],
+					"-",
+					[
+						1,
+						"animTime",
+						"*",
+						[
+							7,
+							"sched",
+							"w"
+						]
+					]
 				]
 			],
 			[
 				13,
-				"blendFactor",
+				"f",
 				[
-					7,
-					"frame",
-					"z"
+					1,
+					"dens",
+					"*",
+					[
+						7,
+						"freqs",
+						"x"
+					]
 				]
 			],
 			[
 				13,
-				"radius",
+				"shapeA",
 				[
-					7,
-					"frame",
-					"w"
+					6,
+					"godraysRaysShape",
+					[
+						[
+							7,
+							"frame",
+							"x"
+						],
+						[
+							7,
+							"frame",
+							"y"
+						],
+						[
+							7,
+							"frame",
+							"z"
+						],
+						"rA",
+						"f",
+						"intensityCalc"
+					]
+				]
+			],
+			[
+				13,
+				"shapeB",
+				[
+					6,
+					"godraysRaysShape",
+					[
+						[
+							7,
+							"frame",
+							"x"
+						],
+						[
+							7,
+							"frame",
+							"y"
+						],
+						[
+							7,
+							"frame",
+							"z"
+						],
+						"rB",
+						[
+							1,
+							"f",
+							"*",
+							[
+								7,
+								"freqs",
+								"y"
+							]
+						],
+						"intensityCalc"
+					]
 				]
 			],
+			[10, [
+				1,
+				"shapeA",
+				"*",
+				"shapeB"
+			]]
+		]]
+	},
+	externals: { "godraysRaysShape": () => godraysRaysShape }
+}) && $.f)({}));
+const godraysRayStack = typegpu_default.fn([
+	vec4f,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((frame, animTimeRaw, density, intensity, spotty) => {
+	"use gpu";
+	const animTime = __tsover_mul(animTimeRaw, .2);
+	const spots = __tsover_mul(6.5, abs(spotty));
+	const intensityCalc = __tsover_sub(4, __tsover_mul(3, clamp(intensity, 0, 1)));
+	const dens = __tsover_mul(6, density);
+	const layer1 = godraysRayLayer(frame, animTime, spots, intensityCalc, dens, vec4f(1, 3, .5, 2), vec2f(5, 4));
+	const layer2 = godraysRayLayer(frame, animTime, spots, intensityCalc, dens, vec4f(1.4, 2.5, .7, 1.8), vec2f(4.5, 3.5));
+	return clamp(__tsover_add(layer1, __tsover_mul(layer2, .7)), 0, 1);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "frame"
+			},
+			{
+				"type": "i",
+				"name": "animTimeRaw"
+			},
+			{
+				"type": "i",
+				"name": "density"
+			},
+			{
+				"type": "i",
+				"name": "intensity"
+			},
+			{
+				"type": "i",
+				"name": "spotty"
+			}
+		],
+		"body": [0, [
 			[
 				13,
 				"animTime",
@@ -4389,253 +5440,81 @@ const godraysRayStack = typegpu_default.fn([
 					"density"
 				]
 			],
-			[
-				12,
-				"accumRay",
-				[
-					6,
-					"d.f32",
-					[[5, "0"]]
-				]
-			],
 			[
 				13,
-				"r1",
+				"layer1",
 				[
-					1,
-					[
-						1,
-						"radius",
-						"*",
-						[5, "1"]
-					],
-					"-",
+					6,
+					"godraysRayLayer",
 					[
-						1,
+						"frame",
 						"animTime",
-						"*",
-						[5, "3"]
-					]
-				]
-			],
-			[
-				13,
-				"r2",
-				[
-					1,
-					[
-						1,
+						"spots",
+						"intensityCalc",
+						"dens",
 						[
-							1,
-							"radius",
-							"*",
-							[5, "0.5"]
+							6,
+							"d.vec4f",
+							[
+								[5, "1"],
+								[5, "3"],
+								[5, "0.5"],
+								[5, "2"]
+							]
 						],
-						"*",
 						[
-							1,
-							[5, "1"],
-							"+",
-							"spots"
+							6,
+							"d.vec2f",
+							[[5, "5"], [5, "4"]]
 						]
-					],
-					"-",
-					[
-						1,
-						"animTime",
-						"*",
-						[5, "2"]
 					]
 				]
 			],
 			[
 				13,
-				"f1",
-				[
-					1,
-					"dens",
-					"*",
-					[5, "5"]
-				]
-			],
-			[
-				12,
-				"ray",
+				"layer2",
 				[
 					6,
-					"godraysRaysShape",
-					[
-						"angle",
-						"angleWrapped",
-						"blendFactor",
-						"r1",
-						"f1",
-						"intensityCalc"
-					]
-				]
-			],
-			[
-				2,
-				"ray",
-				"=",
-				[
-					1,
-					"ray",
-					"*",
+					"godraysRayLayer",
 					[
-						6,
-						"godraysRaysShape",
+						"frame",
+						"animTime",
+						"spots",
+						"intensityCalc",
+						"dens",
 						[
-							"angle",
-							"angleWrapped",
-							"blendFactor",
-							"r2",
+							6,
+							"d.vec4f",
 							[
-								1,
-								"f1",
-								"*",
-								[5, "4"]
-							],
-							"intensityCalc"
+								[5, "1.4"],
+								[5, "2.5"],
+								[5, "0.7"],
+								[5, "1.8"]
+							]
+						],
+						[
+							6,
+							"d.vec2f",
+							[[5, "4.5"], [5, "3.5"]]
 						]
 					]
 				]
 			],
-			[
-				2,
-				"accumRay",
-				"=",
-				[
-					1,
-					"accumRay",
-					"+",
-					"ray"
-				]
-			],
-			[
-				13,
-				"r3",
-				[
-					1,
-					[
-						1,
-						"radius",
-						"*",
-						[5, "1.4"]
-					],
-					"-",
-					[
-						1,
-						"animTime",
-						"*",
-						[5, "2.5"]
-					]
-				]
-			],
-			[
-				13,
-				"r4",
+			[10, [
+				6,
+				"std.clamp",
 				[
-					1,
 					[
 						1,
+						"layer1",
+						"+",
 						[
 							1,
-							"radius",
+							"layer2",
 							"*",
 							[5, "0.7"]
-						],
-						"*",
-						[
-							1,
-							[5, "1"],
-							"+",
-							"spots"
 						]
 					],
-					"-",
-					[
-						1,
-						"animTime",
-						"*",
-						[5, "1.8"]
-					]
-				]
-			],
-			[
-				13,
-				"f2",
-				[
-					1,
-					"dens",
-					"*",
-					[5, "4.5"]
-				]
-			],
-			[
-				12,
-				"ray2",
-				[
-					6,
-					"godraysRaysShape",
-					[
-						"angle",
-						"angleWrapped",
-						"blendFactor",
-						"r3",
-						"f2",
-						"intensityCalc"
-					]
-				]
-			],
-			[
-				2,
-				"ray2",
-				"=",
-				[
-					1,
-					"ray2",
-					"*",
-					[
-						6,
-						"godraysRaysShape",
-						[
-							"angle",
-							"angleWrapped",
-							"blendFactor",
-							"r4",
-							[
-								1,
-								"f2",
-								"*",
-								[5, "3.5"]
-							],
-							"intensityCalc"
-						]
-					]
-				]
-			],
-			[
-				2,
-				"accumRay",
-				"=",
-				[
-					1,
-					"accumRay",
-					"+",
-					[
-						1,
-						"ray2",
-						"*",
-						[5, "0.7"]
-					]
-				]
-			],
-			[10, [
-				6,
-				"std.clamp",
-				[
-					"accumRay",
 					[5, "0"],
 					[5, "1"]
 				]
@@ -4645,8 +5524,9 @@ const godraysRayStack = typegpu_default.fn([
 	externals: {
 		"std.abs": () => abs,
 		"std.clamp": () => clamp,
-		"d.f32": () => f32,
-		"godraysRaysShape": () => godraysRaysShape
+		"godraysRayLayer": () => godraysRayLayer,
+		"d.vec4f": () => vec4f,
+		"d.vec2f": () => vec2f
 	}
 }) && $.f)({}));
 const coverageOverComposite = typegpu_default.fn([
@@ -5575,4 +6455,110 @@ const heatDither = typegpu_default.fn([
 		"std.max": () => max
 	}
 }) && $.f)({}));
-export { volumeDomain as A, radialDist as C, spiralMask as D, shimmerPulse as E, unitNoise3 as O, plasmaTone as S, repeatWrap as T, heatDither as _, colorWheelT as a, leakStreaks as b, diamondDist as c, godraysRayStack as d, gradientClamp01 as f, gradientTransparentAlpha as g, gradientRawT as h, colorWheelSelect as i, unitThreshold as k, flowLayers as l, gradientEdgeWrap as m, colorWheelPhase as n, conicSweep as o, gradientEdgeMirror as p, colorWheelRainbow as r, coverageOverComposite as s, beamField as t, godraysFrame as u, leakBloom as v, repeatRings as w, mpgFactors as x, leakDrift as y };
+const rampWrap = typegpu_default.fn([f32, f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((t, cycles) => {
+	"use gpu";
+	const s = __tsover_mul(t, cycles);
+	const m = __tsover_mul(fract(__tsover_mul(s, .5)), 2);
+	return mix(__tsover_sub(1, abs(__tsover_sub(m, 1))), .5, smoothstep(.5, 1.5, __tsover_mul(footprint1(t, 0), cycles)));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "t"
+		}, {
+			"type": "i",
+			"name": "cycles"
+		}],
+		"body": [0, [
+			[
+				13,
+				"s",
+				[
+					1,
+					"t",
+					"*",
+					"cycles"
+				]
+			],
+			[
+				13,
+				"m",
+				[
+					1,
+					[
+						6,
+						"std.fract",
+						[[
+							1,
+							"s",
+							"*",
+							[5, "0.5"]
+						]]
+					],
+					"*",
+					[5, "2"]
+				]
+			],
+			[
+				13,
+				"band",
+				[
+					1,
+					[5, "1"],
+					"-",
+					[
+						6,
+						"std.abs",
+						[[
+							1,
+							"m",
+							"-",
+							[5, "1"]
+						]]
+					]
+				]
+			],
+			[
+				13,
+				"fp",
+				[
+					1,
+					[
+						6,
+						"footprint1",
+						["t", [5, "0"]]
+					],
+					"*",
+					"cycles"
+				]
+			],
+			[10, [
+				6,
+				"std.mix",
+				[
+					"band",
+					[5, "0.5"],
+					[
+						6,
+						"std.smoothstep",
+						[
+							[5, "0.5"],
+							[5, "1.5"],
+							"fp"
+						]
+					]
+				]
+			]]
+		]]
+	},
+	externals: {
+		"std.fract": () => fract,
+		"std.abs": () => abs,
+		"footprint1": () => footprint1,
+		"std.mix": () => mix,
+		"std.smoothstep": () => smoothstep
+	}
+}) && $.f)({}));
+export { unitThreshold as A, radialDist as C, shimmerPulse as D, repeatWrap as E, footprint2 as F, lineMaskFromField as I, quilezCheckerFilter as L, bandMask as M, discCoverage as N, spiralMask as O, footprint1 as P, quilezLineFilterAxis as R, plasmaTone as S, repeatRings as T, heatDither as _, colorWheelT as a, leakStreaks as b, diamondDist as c, godraysRayStack as d, gradientClamp01 as f, gradientTransparentAlpha as g, gradientRawT as h, colorWheelSelect as i, volumeDomain as j, unitNoise3 as k, flowLayers as l, gradientEdgeWrap as m, colorWheelPhase as n, conicSweep as o, gradientEdgeMirror as p, colorWheelRainbow as r, coverageOverComposite as s, beamField as t, godraysFrame as u, leakBloom as v, rampWrap as w, mpgFactors as x, leakDrift as y, quilezStepFilter as z };