shaders 3.1.456 → 3.1.458

package/dist/core/MeshGradient-DxUlAoDr.js

@@ -0,0 +1,1508 @@
+import { Dt as sin, Ft as vec3f, Lt as vec4f, Mt as vec2f, Ot as smoothstep, _t as max, ct as clamp, et as typegpu_default, ft as exp, gt as length, ht as fract, it as abs, kt as sqrt, lt as cos, m as call, rt as select, sn as f32, xt as pow, yt as mix } from "./edges-BvIjDyJK.js";
+import { n as GOLDEN, o as TAU } from "./constants-BKlzQFdJ.js";
+import { i as rotate2, t as aspectOf } from "./geom-D1eEB6WE.js";
+import { n as footprint1 } from "./aa-C759fSpb.js";
+import { n as domainWarp2 } from "./fields-DORoQP7V.js";
+import { V as colorStopsPropConfig, t as animatedTime } from "./porters-BnG6v9YC.js";
+import { f as mxNoiseFloat3, l as hash22, o as hash11, s as hash12 } from "./noise-Be9_Xz5F.js";
+import { t as mixStopsOrColorsExpr } from "./noiseColor-CCePJCFN.js";
+import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-u-UZrXjj.js";
+var DOMAIN_SCALE = 1.6;
+var WARP_AMOUNT = .48;
+var WARP_RATE = .125;
+var SWIRL_MAX = 3;
+var VAR_FREQ = 1.9;
+var VAR_STRENGTH = 1.4;
+var VAR_RATE = .045;
+var DRIFT_RATE = .11;
+var WRAP_CYCLES = 9;
+var GOLDEN_CONJ = .6180339887;
+var MAX_ANCHORS = 8;
+var meshWarp = domainWarp2(mxNoiseFloat3, { name: "meshWarp" });
+const meshAnchor = typegpu_default.fn([
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((fi, count, seed, drift, aspect, animTime) => {
+	"use gpu";
+	const theta = __tsover_add(__tsover_mul(fi, 2.3999632297286535), __tsover_mul(hash11(__tsover_add(__tsover_mul(seed, .7311), 1.618)), TAU));
+	const r = sqrt(__tsover_div(__tsover_add(fi, .5), count));
+	const j = hash22(vec2f(__tsover_add(__tsover_mul(fi, 3.77), .917), __tsover_add(__tsover_mul(seed, 1.093), 2.236))).sub(.5).mul(.26);
+	const ph = hash22(vec2f(__tsover_add(__tsover_mul(fi, 7.13), 1.618), __tsover_add(__tsover_mul(seed, .531), 3.71))).mul(TAU);
+	const w1 = __tsover_add(.5, __tsover_mul(hash11(__tsover_add(__tsover_add(__tsover_mul(fi, 5.417), __tsover_mul(seed, .291)), .917)), .7));
+	const dx = sin(__tsover_add(__tsover_mul(__tsover_mul(animTime, DRIFT_RATE), w1), ph.x));
+	const dy = cos(__tsover_add(__tsover_mul(__tsover_mul(__tsover_mul(animTime, DRIFT_RATE), w1), 1.37), ph.y));
+	const nx = __tsover_add(__tsover_add(__tsover_mul(__tsover_mul(cos(theta), r), .62), j.x), __tsover_mul(__tsover_mul(dx, drift), .16));
+	const ny = __tsover_add(__tsover_add(__tsover_mul(__tsover_mul(sin(theta), r), .62), j.y), __tsover_mul(__tsover_mul(dy, drift), .16));
+	return vec2f(__tsover_mul(__tsover_add(.5, nx), aspect), __tsover_add(.5, ny));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "fi"
+			},
+			{
+				"type": "i",
+				"name": "count"
+			},
+			{
+				"type": "i",
+				"name": "seed"
+			},
+			{
+				"type": "i",
+				"name": "drift"
+			},
+			{
+				"type": "i",
+				"name": "aspect"
+			},
+			{
+				"type": "i",
+				"name": "animTime"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"theta",
+				[
+					1,
+					[
+						1,
+						"fi",
+						"*",
+						"GOLDEN"
+					],
+					"+",
+					[
+						1,
+						[
+							6,
+							"noise.hash11",
+							[[
+								1,
+								[
+									1,
+									"seed",
+									"*",
+									[5, "0.7311"]
+								],
+								"+",
+								[5, "1.618"]
+							]]
+						],
+						"*",
+						"TAU"
+					]
+				]
+			],
+			[
+				13,
+				"r",
+				[
+					6,
+					"std.sqrt",
+					[[
+						1,
+						[
+							1,
+							"fi",
+							"+",
+							[5, "0.5"]
+						],
+						"/",
+						"count"
+					]]
+				]
+			],
+			[
+				13,
+				"j",
+				[
+					6,
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								[
+									6,
+									"noise.hash22",
+									[[
+										6,
+										"d.vec2f",
+										[[
+											1,
+											[
+												1,
+												"fi",
+												"*",
+												[5, "3.77"]
+											],
+											"+",
+											[5, "0.917"]
+										], [
+											1,
+											[
+												1,
+												"seed",
+												"*",
+												[5, "1.093"]
+											],
+											"+",
+											[5, "2.236"]
+										]]
+									]]
+								],
+								"sub"
+							],
+							[[5, "0.5"]]
+						],
+						"mul"
+					],
+					[[5, "0.26"]]
+				]
+			],
+			[
+				13,
+				"ph",
+				[
+					6,
+					[
+						7,
+						[
+							6,
+							"noise.hash22",
+							[[
+								6,
+								"d.vec2f",
+								[[
+									1,
+									[
+										1,
+										"fi",
+										"*",
+										[5, "7.13"]
+									],
+									"+",
+									[5, "1.618"]
+								], [
+									1,
+									[
+										1,
+										"seed",
+										"*",
+										[5, "0.531"]
+									],
+									"+",
+									[5, "3.71"]
+								]]
+							]]
+						],
+						"mul"
+					],
+					["TAU"]
+				]
+			],
+			[
+				13,
+				"w1",
+				[
+					1,
+					[5, "0.5"],
+					"+",
+					[
+						1,
+						[
+							6,
+							"noise.hash11",
+							[[
+								1,
+								[
+									1,
+									[
+										1,
+										"fi",
+										"*",
+										[5, "5.417"]
+									],
+									"+",
+									[
+										1,
+										"seed",
+										"*",
+										[5, "0.291"]
+									]
+								],
+								"+",
+								[5, "0.917"]
+							]]
+						],
+						"*",
+						[5, "0.7"]
+					]
+				]
+			],
+			[
+				13,
+				"dx",
+				[
+					6,
+					"std.sin",
+					[[
+						1,
+						[
+							1,
+							[
+								1,
+								"animTime",
+								"*",
+								"DRIFT_RATE"
+							],
+							"*",
+							"w1"
+						],
+						"+",
+						[
+							7,
+							"ph",
+							"x"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"dy",
+				[
+					6,
+					"std.cos",
+					[[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									"animTime",
+									"*",
+									"DRIFT_RATE"
+								],
+								"*",
+								"w1"
+							],
+							"*",
+							[5, "1.37"]
+						],
+						"+",
+						[
+							7,
+							"ph",
+							"y"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"nx",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									6,
+									"std.cos",
+									["theta"]
+								],
+								"*",
+								"r"
+							],
+							"*",
+							[5, "0.62"]
+						],
+						"+",
+						[
+							7,
+							"j",
+							"x"
+						]
+					],
+					"+",
+					[
+						1,
+						[
+							1,
+							"dx",
+							"*",
+							"drift"
+						],
+						"*",
+						[5, "0.16"]
+					]
+				]
+			],
+			[
+				13,
+				"ny",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									6,
+									"std.sin",
+									["theta"]
+								],
+								"*",
+								"r"
+							],
+							"*",
+							[5, "0.62"]
+						],
+						"+",
+						[
+							7,
+							"j",
+							"y"
+						]
+					],
+					"+",
+					[
+						1,
+						[
+							1,
+							"dy",
+							"*",
+							"drift"
+						],
+						"*",
+						[5, "0.16"]
+					]
+				]
+			],
+			[10, [
+				6,
+				"d.vec2f",
+				[[
+					1,
+					[
+						1,
+						[5, "0.5"],
+						"+",
+						"nx"
+					],
+					"*",
+					"aspect"
+				], [
+					1,
+					[5, "0.5"],
+					"+",
+					"ny"
+				]]
+			]]
+		]]
+	},
+	externals: {
+		"GOLDEN": () => 2.3999632297286535,
+		"noise.hash11": () => hash11,
+		"TAU": () => TAU,
+		"std.sqrt": () => sqrt,
+		"noise.hash22": () => hash22,
+		"d.vec2f": () => vec2f,
+		"std.sin": () => sin,
+		"DRIFT_RATE": () => DRIFT_RATE,
+		"std.cos": () => cos
+	}
+}) && $.f)({}));
+const meshField = typegpu_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, count, seed, drift, swirl, variation, smoothness, animTime) => {
+	"use gpu";
+	const aspect = aspectOf(viewport);
+	const uvA = vec2f(__tsover_mul(uv.x, aspect), uv.y);
+	const d0 = vec2f(__tsover_sub(uvA.x, __tsover_mul(aspect, .5)), __tsover_sub(uvA.y, .5));
+	const swirlAngle = __tsover_mul(__tsover_mul(-SWIRL_MAX, swirl), smoothstep(0, 1, length(d0)));
+	const rot = rotate2(d0, cos(swirlAngle), sin(swirlAngle));
+	const uvS = vec2f(__tsover_add(rot.x, __tsover_mul(aspect, .5)), __tsover_add(rot.y, .5));
+	const w3 = meshWarp(vec3f(__tsover_mul(uvS.x, DOMAIN_SCALE), __tsover_mul(uvS.y, DOMAIN_SCALE), __tsover_mul(seed, 7.31)), __tsover_mul(animTime, WARP_RATE), WARP_AMOUNT);
+	const q = vec2f(__tsover_div(w3.x, DOMAIN_SCALE), __tsover_div(w3.y, DOMAIN_SCALE));
+	const effPower = __tsover_div(8, __tsover_add(smoothness, .5));
+	const vn = mxNoiseFloat3(vec3f(__tsover_mul(q.x, VAR_FREQ), __tsover_mul(q.y, VAR_FREQ), __tsover_add(__tsover_mul(seed, 3.17), __tsover_mul(animTime, VAR_RATE))));
+	const effP = clamp(__tsover_mul(effPower, exp(__tsover_mul(__tsover_mul(vn, variation), VAR_STRENGTH))), .6, 16);
+	let num = f32(0);
+	let den = f32(0);
+	for (let i = 0; i < MAX_ANCHORS; i++) {
+		const fi = f32(i);
+		const active = select(f32(0), f32(1), fi < __tsover_sub(count, .5));
+		const anchor = meshAnchor(fi, count, seed, drift, aspect, animTime);
+		const dist = max(length(q.sub(anchor)), .01);
+		const w = __tsover_div(active, pow(dist, effP));
+		const ti = fract(__tsover_add(__tsover_mul(fi, GOLDEN_CONJ), hash11(__tsover_add(__tsover_mul(seed, .531), .77))));
+		num = __tsover_add(num, __tsover_mul(w, ti));
+		den = __tsover_add(den, w);
+	}
+	return __tsover_div(num, max(den, 1e-6));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "viewport"
+			},
+			{
+				"type": "i",
+				"name": "count"
+			},
+			{
+				"type": "i",
+				"name": "seed"
+			},
+			{
+				"type": "i",
+				"name": "drift"
+			},
+			{
+				"type": "i",
+				"name": "swirl"
+			},
+			{
+				"type": "i",
+				"name": "variation"
+			},
+			{
+				"type": "i",
+				"name": "smoothness"
+			},
+			{
+				"type": "i",
+				"name": "animTime"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"aspect",
+				[
+					6,
+					"geom.aspectOf",
+					["viewport"]
+				]
+			],
+			[
+				13,
+				"uvA",
+				[
+					6,
+					"d.vec2f",
+					[[
+						1,
+						[
+							7,
+							"uv",
+							"x"
+						],
+						"*",
+						"aspect"
+					], [
+						7,
+						"uv",
+						"y"
+					]]
+				]
+			],
+			[
+				13,
+				"d0",
+				[
+					6,
+					"d.vec2f",
+					[[
+						1,
+						[
+							7,
+							"uvA",
+							"x"
+						],
+						"-",
+						[
+							1,
+							"aspect",
+							"*",
+							[5, "0.5"]
+						]
+					], [
+						1,
+						[
+							7,
+							"uvA",
+							"y"
+						],
+						"-",
+						[5, "0.5"]
+					]]
+				]
+			],
+			[
+				13,
+				"swirlAngle",
+				[
+					1,
+					[
+						1,
+						[
+							4,
+							"-",
+							"SWIRL_MAX"
+						],
+						"*",
+						"swirl"
+					],
+					"*",
+					[
+						6,
+						"std.smoothstep",
+						[
+							[5, "0"],
+							[5, "1"],
+							[
+								6,
+								"std.length",
+								["d0"]
+							]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"rot",
+				[
+					6,
+					"geom.rotate2",
+					[
+						"d0",
+						[
+							6,
+							"std.cos",
+							["swirlAngle"]
+						],
+						[
+							6,
+							"std.sin",
+							["swirlAngle"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"uvS",
+				[
+					6,
+					"d.vec2f",
+					[[
+						1,
+						[
+							7,
+							"rot",
+							"x"
+						],
+						"+",
+						[
+							1,
+							"aspect",
+							"*",
+							[5, "0.5"]
+						]
+					], [
+						1,
+						[
+							7,
+							"rot",
+							"y"
+						],
+						"+",
+						[5, "0.5"]
+					]]
+				]
+			],
+			[
+				13,
+				"w3",
+				[
+					6,
+					"meshWarp",
+					[
+						[
+							6,
+							"d.vec3f",
+							[
+								[
+									1,
+									[
+										7,
+										"uvS",
+										"x"
+									],
+									"*",
+									"DOMAIN_SCALE"
+								],
+								[
+									1,
+									[
+										7,
+										"uvS",
+										"y"
+									],
+									"*",
+									"DOMAIN_SCALE"
+								],
+								[
+									1,
+									"seed",
+									"*",
+									[5, "7.31"]
+								]
+							]
+						],
+						[
+							1,
+							"animTime",
+							"*",
+							"WARP_RATE"
+						],
+						"WARP_AMOUNT"
+					]
+				]
+			],
+			[
+				13,
+				"q",
+				[
+					6,
+					"d.vec2f",
+					[[
+						1,
+						[
+							7,
+							"w3",
+							"x"
+						],
+						"/",
+						"DOMAIN_SCALE"
+					], [
+						1,
+						[
+							7,
+							"w3",
+							"y"
+						],
+						"/",
+						"DOMAIN_SCALE"
+					]]
+				]
+			],
+			[
+				13,
+				"effPower",
+				[
+					1,
+					[5, "8"],
+					"/",
+					[
+						1,
+						"smoothness",
+						"+",
+						[5, "0.5"]
+					]
+				]
+			],
+			[
+				13,
+				"vn",
+				[
+					6,
+					"noise.mxNoiseFloat3",
+					[[
+						6,
+						"d.vec3f",
+						[
+							[
+								1,
+								[
+									7,
+									"q",
+									"x"
+								],
+								"*",
+								"VAR_FREQ"
+							],
+							[
+								1,
+								[
+									7,
+									"q",
+									"y"
+								],
+								"*",
+								"VAR_FREQ"
+							],
+							[
+								1,
+								[
+									1,
+									"seed",
+									"*",
+									[5, "3.17"]
+								],
+								"+",
+								[
+									1,
+									"animTime",
+									"*",
+									"VAR_RATE"
+								]
+							]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"effP",
+				[
+					6,
+					"std.clamp",
+					[
+						[
+							1,
+							"effPower",
+							"*",
+							[
+								6,
+								"std.exp",
+								[[
+									1,
+									[
+										1,
+										"vn",
+										"*",
+										"variation"
+									],
+									"*",
+									"VAR_STRENGTH"
+								]]
+							]
+						],
+						[5, "0.6"],
+						[5, "16"]
+					]
+				]
+			],
+			[
+				12,
+				"num",
+				[
+					6,
+					"d.f32",
+					[[5, "0"]]
+				]
+			],
+			[
+				12,
+				"den",
+				[
+					6,
+					"d.f32",
+					[[5, "0"]]
+				]
+			],
+			[
+				14,
+				[
+					12,
+					"i",
+					[5, "0"]
+				],
+				[
+					1,
+					"i",
+					"<",
+					"MAX_ANCHORS"
+				],
+				[
+					102,
+					"++",
+					"i"
+				],
+				[0, [
+					[
+						13,
+						"fi",
+						[
+							6,
+							"d.f32",
+							["i"]
+						]
+					],
+					[
+						13,
+						"active",
+						[
+							6,
+							"std.select",
+							[
+								[
+									6,
+									"d.f32",
+									[[5, "0"]]
+								],
+								[
+									6,
+									"d.f32",
+									[[5, "1"]]
+								],
+								[
+									1,
+									"fi",
+									"<",
+									[
+										1,
+										"count",
+										"-",
+										[5, "0.5"]
+									]
+								]
+							]
+						]
+					],
+					[
+						13,
+						"anchor",
+						[
+							6,
+							"meshAnchor",
+							[
+								"fi",
+								"count",
+								"seed",
+								"drift",
+								"aspect",
+								"animTime"
+							]
+						]
+					],
+					[
+						13,
+						"dist",
+						[
+							6,
+							"std.max",
+							[[
+								6,
+								"std.length",
+								[[
+									6,
+									[
+										7,
+										"q",
+										"sub"
+									],
+									["anchor"]
+								]]
+							], [5, "0.01"]]
+						]
+					],
+					[
+						13,
+						"w",
+						[
+							1,
+							"active",
+							"/",
+							[
+								6,
+								"std.pow",
+								["dist", "effP"]
+							]
+						]
+					],
+					[
+						13,
+						"ti",
+						[
+							6,
+							"std.fract",
+							[[
+								1,
+								[
+									1,
+									"fi",
+									"*",
+									"GOLDEN_CONJ"
+								],
+								"+",
+								[
+									6,
+									"noise.hash11",
+									[[
+										1,
+										[
+											1,
+											"seed",
+											"*",
+											[5, "0.531"]
+										],
+										"+",
+										[5, "0.77"]
+									]]
+								]
+							]]
+						]
+					],
+					[
+						2,
+						"num",
+						"=",
+						[
+							1,
+							"num",
+							"+",
+							[
+								1,
+								"w",
+								"*",
+								"ti"
+							]
+						]
+					],
+					[
+						2,
+						"den",
+						"=",
+						[
+							1,
+							"den",
+							"+",
+							"w"
+						]
+					]
+				]]
+			],
+			[10, [
+				1,
+				"num",
+				"/",
+				[
+					6,
+					"std.max",
+					["den", [5, "0.000001"]]
+				]
+			]]
+		]]
+	},
+	externals: {
+		"geom.aspectOf": () => aspectOf,
+		"d.vec2f": () => vec2f,
+		"SWIRL_MAX": () => SWIRL_MAX,
+		"std.smoothstep": () => smoothstep,
+		"std.length": () => length,
+		"geom.rotate2": () => rotate2,
+		"std.cos": () => cos,
+		"std.sin": () => sin,
+		"meshWarp": () => meshWarp,
+		"d.vec3f": () => vec3f,
+		"DOMAIN_SCALE": () => DOMAIN_SCALE,
+		"WARP_RATE": () => WARP_RATE,
+		"WARP_AMOUNT": () => WARP_AMOUNT,
+		"noise.mxNoiseFloat3": () => mxNoiseFloat3,
+		"VAR_FREQ": () => VAR_FREQ,
+		"VAR_RATE": () => VAR_RATE,
+		"std.clamp": () => clamp,
+		"std.exp": () => exp,
+		"VAR_STRENGTH": () => VAR_STRENGTH,
+		"d.f32": () => f32,
+		"MAX_ANCHORS": () => MAX_ANCHORS,
+		"std.select": () => select,
+		"meshAnchor": () => meshAnchor,
+		"std.max": () => max,
+		"std.pow": () => pow,
+		"std.fract": () => fract,
+		"GOLDEN_CONJ": () => GOLDEN_CONJ,
+		"noise.hash11": () => hash11
+	}
+}) && $.f)({}));
+const meshWrapT = typegpu_default.fn([f32, f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((t, wrapping) => {
+	"use gpu";
+	const cycles = __tsover_add(1, __tsover_mul(wrapping, WRAP_CYCLES));
+	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": "wrapping"
+		}],
+		"body": [0, [
+			[
+				13,
+				"cycles",
+				[
+					1,
+					[5, "1"],
+					"+",
+					[
+						1,
+						"wrapping",
+						"*",
+						"WRAP_CYCLES"
+					]
+				]
+			],
+			[
+				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,
+						"aa.footprint1",
+						["t", [5, "0"]]
+					],
+					"*",
+					"cycles"
+				]
+			],
+			[10, [
+				6,
+				"std.mix",
+				[
+					"band",
+					[5, "0.5"],
+					[
+						6,
+						"std.smoothstep",
+						[
+							[5, "0.5"],
+							[5, "1.5"],
+							"fp"
+						]
+					]
+				]
+			]]
+		]]
+	},
+	externals: {
+		"WRAP_CYCLES": () => WRAP_CYCLES,
+		"std.fract": () => fract,
+		"std.abs": () => abs,
+		"aa.footprint1": () => footprint1,
+		"std.mix": () => mix,
+		"std.smoothstep": () => smoothstep
+	}
+}) && $.f)({}));
+const meshDither = typegpu_default.fn([
+	vec4f,
+	vec2f,
+	vec2f,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((base, uv, viewport, animTime) => {
+	"use gpu";
+	const n = hash12(uv.mul(viewport).add(vec2f(animTime, __tsover_mul(animTime, 1.618))));
+	return vec4f(clamp(base.xyz.add(__tsover_mul(__tsover_sub(n, .5), .004)), vec3f(0), vec3f(1)), base.w);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "base"
+			},
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "viewport"
+			},
+			{
+				"type": "i",
+				"name": "animTime"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"n",
+				[
+					6,
+					"noise.hash12",
+					[[
+						6,
+						[
+							7,
+							[
+								6,
+								[
+									7,
+									"uv",
+									"mul"
+								],
+								["viewport"]
+							],
+							"add"
+						],
+						[[
+							6,
+							"d.vec2f",
+							["animTime", [
+								1,
+								"animTime",
+								"*",
+								[5, "1.618"]
+							]]
+						]]
+					]]
+				]
+			],
+			[
+				13,
+				"rgb",
+				[
+					6,
+					"std.clamp",
+					[
+						[
+							6,
+							[
+								7,
+								[
+									7,
+									"base",
+									"xyz"
+								],
+								"add"
+							],
+							[[
+								1,
+								[
+									1,
+									"n",
+									"-",
+									[5, "0.5"]
+								],
+								"*",
+								[5, "0.004"]
+							]]
+						],
+						[
+							6,
+							"d.vec3f",
+							[[5, "0"]]
+						],
+						[
+							6,
+							"d.vec3f",
+							[[5, "1"]]
+						]
+					]
+				]
+			],
+			[10, [
+				6,
+				"d.vec4f",
+				["rgb", [
+					7,
+					"base",
+					"w"
+				]]
+			]]
+		]]
+	},
+	externals: {
+		"noise.hash12": () => hash12,
+		"d.vec2f": () => vec2f,
+		"std.clamp": () => clamp,
+		"d.vec3f": () => vec3f,
+		"d.vec4f": () => vec4f
+	}
+}) && $.f)({}));
+var DEFAULT_STOPS = [
+	{
+		color: "#1a0533",
+		position: 0
+	},
+	{
+		color: "#6d2fd1",
+		position: .26
+	},
+	{
+		color: "#e04b9e",
+		position: .52
+	},
+	{
+		color: "#ff8c42",
+		position: .76
+	},
+	{
+		color: "#ffdf8e",
+		position: 1
+	}
+];
+const componentDefinition = {
+	name: "MeshGradient",
+	boundingBoxDeclaration: {
+		aspectRatio: null,
+		supportsResizeFit: true
+	},
+	category: "Textures",
+	description: "Flowing mesh gradient of soft drifting color swaths whose seams wrap through the palette",
+	acceptsUVContext: true,
+	animatedTime: { speed: "speed" },
+	props: {
+		colorA: {
+			default: "#1a0533",
+			transform: transformColor,
+			description: "First gradient color (two-color fallback when stops are cleared)",
+			ui: {
+				type: "color",
+				label: "Color A",
+				group: "Colors"
+			}
+		},
+		colorB: {
+			default: "#ffdf8e",
+			transform: transformColor,
+			description: "Second gradient color (two-color fallback when stops are cleared)",
+			ui: {
+				type: "color",
+				label: "Color B",
+				group: "Colors"
+			}
+		},
+		stops: {
+			...colorStopsPropConfig(),
+			default: DEFAULT_STOPS
+		},
+		colorSpace: {
+			default: "oklab",
+			transform: transformColorSpace,
+			compileTime: true,
+			description: "Color space for color interpolation",
+			ui: {
+				type: "select",
+				options: colorSpaceOptions,
+				label: "Color Space",
+				group: "Colors"
+			}
+		},
+		count: {
+			default: 5,
+			description: "Number of color points scattered across the canvas",
+			ui: {
+				type: "range",
+				min: 2,
+				max: 8,
+				step: 1,
+				label: "Points",
+				group: "Effect"
+			}
+		},
+		smoothness: {
+			default: 2,
+			description: "How smoothly the color points blend into each other",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 5,
+				step: .01,
+				label: "Smoothness",
+				group: "Effect"
+			}
+		},
+		variation: {
+			default: .35,
+			description: "Varies edge softness across the canvas — some color boundaries crisp, others diffuse",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Variation",
+				group: "Effect"
+			}
+		},
+		swirl: {
+			default: .3,
+			description: "Vortex rotation that spirals the field around the frame centre — negative values spin the other way",
+			ui: {
+				type: ["range", "map"],
+				min: -1,
+				max: 1,
+				step: .01,
+				label: "Swirl",
+				group: "Effect"
+			}
+		},
+		drift: {
+			default: .5,
+			description: "How far the color points wander from their home positions",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Drift",
+				group: "Effect"
+			}
+		},
+		wrapping: {
+			default: 0,
+			description: "Wraps the palette back through itself where colors meet — banded seams where the field pinches, smooth elsewhere",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Wrapping",
+				group: "Effect"
+			}
+		},
+		speed: {
+			default: 1,
+			description: "Animation speed",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 10,
+				step: .1,
+				label: "Speed",
+				group: "Animation"
+			}
+		},
+		seed: {
+			default: 0,
+			description: "Random seed for the point layout and palette assignment",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 100,
+				step: 1,
+				label: "Seed",
+				group: "Effect"
+			}
+		}
+	},
+	fragment: (params) => {
+		const { uniforms, ctx } = params;
+		const uv = params.uvContext ?? ctx.uv;
+		const viewport = params.effectiveViewportSize ?? ctx.viewportSize;
+		const t = animatedTime(params);
+		return call(meshDither, "meshDither", [
+			mixStopsOrColorsExpr(params, call(meshWrapT, "meshWrapT", [call(meshField, "meshField", [
+				uv,
+				viewport,
+				uniforms.count,
+				uniforms.seed,
+				uniforms.drift,
+				uniforms.swirl,
+				uniforms.variation,
+				uniforms.smoothness,
+				t
+			]), uniforms.wrapping])),
+			uv,
+			viewport,
+			t
+		]);
+	}
+};
+var MeshGradient_default = componentDefinition;
+export { meshField as a, meshDither as i, componentDefinition as n, meshWrapT as o, meshAnchor as r, MeshGradient_default as t };