shaders 3.0.442 → 3.0.444

package/dist/core/FloatingParticles-Cppgg6I0.js

@@ -0,0 +1,2736 @@
+import { Bt as call, J as std, Rt as ZERO, X as createGuardedCompute, Z as createStateBuffer, bn as d, ct as hash22, i as agents_exports, l as pointShapeOptions, lt as hash33, n as tgpu, o as cursorMagnet, ot as hash11, pt as noise_exports, r as AGENT_SHAPES, s as makeAgentWeightFn, u as resolveAgentShape } from "./coords-CLqRuQwC.js";
+import { a as transformColor } from "./transformations-t0d2-uSX.js";
+var MAX_MOTES = 8192;
+var RES = 1024;
+var INV_RES = 1 / RES;
+var STATE_FORMAT = "rgba16float";
+var SPLAT_R = 16;
+var SPLAT_WIN = 33;
+var AA_W = .75 * INV_RES;
+var TAU = 6.283185307179586;
+var DEG_TO_RAD = Math.PI / 180;
+var BASE_DRIFT = .12;
+var ORBIT_RAD = .035;
+var ORBIT_RATE = 1.4;
+var TWINKLE_FREQ = 2;
+var CURSOR_FORCE_K = 3.5;
+var CURSOR_DRAG = 1.1;
+var ANGLE_FLIP = Math.PI;
+var HARD_GAIN = 637;
+var SOFT_GAIN = 255;
+var SimParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(d.struct({
+	color: d.vec4f,
+	count: d.f32,
+	dt: d.f32,
+	time: d.f32,
+	aspect: d.f32,
+	domainX: d.f32,
+	driftBase: d.f32,
+	angleRad: d.f32,
+	speedVar: d.f32,
+	angleVarRad: d.f32,
+	randomness: d.f32,
+	twinkle: d.f32,
+	softness: d.f32,
+	bodyR: d.f32,
+	cursorX: d.f32,
+	cursorY: d.f32,
+	cursorRadSq: d.f32,
+	cursorForce: d.f32,
+	dragMul: d.f32
+}), "SimParams");
+var simLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+	motes: {
+		storage: d.arrayOf(d.vec4f, MAX_MOTES),
+		access: "mutable"
+	},
+	accumE: {
+		storage: d.arrayOf(d.atomic(d.u32), RES * RES),
+		access: "mutable"
+	},
+	params: { uniform: SimParams },
+	outTex: { storageTexture: d.textureStorage2d(STATE_FORMAT, "write-only") }
+}), "simLayout");
+var moteDrift = tgpu.fn([d.f32], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((fi) => {
+	"use gpu";
+	const prm = simLayout.$.params;
+	const h = hash22(d.vec2f(__tsover_add(__tsover_mul(fi, .7548), .13), __tsover_add(__tsover_mul(fi, 1.3236), 5.71)));
+	const speedMul = __tsover_add(1, __tsover_mul(__tsover_sub(h.x, .5), prm.speedVar));
+	const ang = __tsover_add(prm.angleRad, __tsover_mul(__tsover_mul(__tsover_sub(h.y, .5), 2), prm.angleVarRad));
+	return d.vec2f(std.cos(ang), std.sin(ang)).mul(__tsover_mul(prm.driftBase, speedMul));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "fi"
+		}],
+		"body": [0, [
+			[
+				13,
+				"prm",
+				[
+					7,
+					[
+						7,
+						"simLayout",
+						"$"
+					],
+					"params"
+				]
+			],
+			[
+				13,
+				"h",
+				[
+					6,
+					[
+						7,
+						"noise",
+						"hash22"
+					],
+					[[
+						6,
+						[
+							7,
+							"d",
+							"vec2f"
+						],
+						[[
+							1,
+							[
+								1,
+								"fi",
+								"*",
+								[5, "0.7548"]
+							],
+							"+",
+							[5, "0.13"]
+						], [
+							1,
+							[
+								1,
+								"fi",
+								"*",
+								[5, "1.3236"]
+							],
+							"+",
+							[5, "5.71"]
+						]]
+					]]
+				]
+			],
+			[
+				13,
+				"speedMul",
+				[
+					1,
+					[5, "1"],
+					"+",
+					[
+						1,
+						[
+							1,
+							[
+								7,
+								"h",
+								"x"
+							],
+							"-",
+							[5, "0.5"]
+						],
+						"*",
+						[
+							7,
+							"prm",
+							"speedVar"
+						]
+					]
+				]
+			],
+			[
+				13,
+				"ang",
+				[
+					1,
+					[
+						7,
+						"prm",
+						"angleRad"
+					],
+					"+",
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									"h",
+									"y"
+								],
+								"-",
+								[5, "0.5"]
+							],
+							"*",
+							[5, "2"]
+						],
+						"*",
+						[
+							7,
+							"prm",
+							"angleVarRad"
+						]
+					]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec2f"
+						],
+						[[
+							6,
+							[
+								7,
+								"std",
+								"cos"
+							],
+							["ang"]
+						], [
+							6,
+							[
+								7,
+								"std",
+								"sin"
+							],
+							["ang"]
+						]]
+					],
+					"mul"
+				],
+				[[
+					1,
+					[
+						7,
+						"prm",
+						"driftBase"
+					],
+					"*",
+					"speedMul"
+				]]
+			]]
+		]],
+		"externalNames": [
+			"simLayout",
+			"noise",
+			"d",
+			"std"
+		]
+	},
+	externals: () => ({
+		simLayout,
+		noise: noise_exports,
+		d,
+		std
+	})
+}) && $.f)({})).$name("moteDrift");
+var motePresence = tgpu.fn([d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((fi) => {
+	"use gpu";
+	return __tsover_add(.55, __tsover_mul(hash11(__tsover_add(__tsover_mul(fi, 1.91), 2.53)), .7));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "fi"
+		}],
+		"body": [0, [[10, [
+			1,
+			[5, "0.55"],
+			"+",
+			[
+				1,
+				[
+					6,
+					[
+						7,
+						"noise",
+						"hash11"
+					],
+					[[
+						1,
+						[
+							1,
+							"fi",
+							"*",
+							[5, "1.91"]
+						],
+						"+",
+						[5, "2.53"]
+					]]
+				],
+				"*",
+				[5, "0.7"]
+			]
+		]]]],
+		"externalNames": ["noise"]
+	},
+	externals: () => ({ noise: noise_exports })
+}) && $.f)({})).$name("motePresence");
+var moteOrbit = tgpu.fn([d.f32], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((fi) => {
+	"use gpu";
+	const prm = simLayout.$.params;
+	const h = hash22(d.vec2f(__tsover_add(__tsover_mul(fi, 2.41), .37), __tsover_add(__tsover_mul(fi, .577), 8.19)));
+	const rate = __tsover_mul(__tsover_mul(__tsover_add(.5, h.x), ORBIT_RATE), prm.randomness);
+	const ph = __tsover_mul(h.y, TAU);
+	const rad = __tsover_mul(__tsover_mul(ORBIT_RAD, prm.randomness), __tsover_add(.5, __tsover_mul(h.x, .5)));
+	const t = __tsover_add(__tsover_mul(prm.time, rate), ph);
+	return d.vec2f(std.cos(t), std.sin(t)).mul(rad);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "fi"
+		}],
+		"body": [0, [
+			[
+				13,
+				"prm",
+				[
+					7,
+					[
+						7,
+						"simLayout",
+						"$"
+					],
+					"params"
+				]
+			],
+			[
+				13,
+				"h",
+				[
+					6,
+					[
+						7,
+						"noise",
+						"hash22"
+					],
+					[[
+						6,
+						[
+							7,
+							"d",
+							"vec2f"
+						],
+						[[
+							1,
+							[
+								1,
+								"fi",
+								"*",
+								[5, "2.41"]
+							],
+							"+",
+							[5, "0.37"]
+						], [
+							1,
+							[
+								1,
+								"fi",
+								"*",
+								[5, "0.577"]
+							],
+							"+",
+							[5, "8.19"]
+						]]
+					]]
+				]
+			],
+			[
+				13,
+				"rate",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[5, "0.5"],
+							"+",
+							[
+								7,
+								"h",
+								"x"
+							]
+						],
+						"*",
+						"ORBIT_RATE"
+					],
+					"*",
+					[
+						7,
+						"prm",
+						"randomness"
+					]
+				]
+			],
+			[
+				13,
+				"ph",
+				[
+					1,
+					[
+						7,
+						"h",
+						"y"
+					],
+					"*",
+					"TAU"
+				]
+			],
+			[
+				13,
+				"rad",
+				[
+					1,
+					[
+						1,
+						"ORBIT_RAD",
+						"*",
+						[
+							7,
+							"prm",
+							"randomness"
+						]
+					],
+					"*",
+					[
+						1,
+						[5, "0.5"],
+						"+",
+						[
+							1,
+							[
+								7,
+								"h",
+								"x"
+							],
+							"*",
+							[5, "0.5"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"t",
+				[
+					1,
+					[
+						1,
+						[
+							7,
+							"prm",
+							"time"
+						],
+						"*",
+						"rate"
+					],
+					"+",
+					"ph"
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec2f"
+						],
+						[[
+							6,
+							[
+								7,
+								"std",
+								"cos"
+							],
+							["t"]
+						], [
+							6,
+							[
+								7,
+								"std",
+								"sin"
+							],
+							["t"]
+						]]
+					],
+					"mul"
+				],
+				["rad"]
+			]]
+		]],
+		"externalNames": [
+			"simLayout",
+			"noise",
+			"d",
+			"ORBIT_RATE",
+			"TAU",
+			"ORBIT_RAD",
+			"std"
+		]
+	},
+	externals: () => ({
+		simLayout,
+		noise: noise_exports,
+		d,
+		ORBIT_RATE,
+		TAU,
+		ORBIT_RAD,
+		std
+	})
+}) && $.f)({})).$name("moteOrbit");
+const floatingParticlesInitKernel = tgpu.fn([d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
+	"use gpu";
+	const prm = simLayout.$.params;
+	const fi = d.f32(i);
+	const r = hash33(d.vec3f(__tsover_add(__tsover_mul(fi, 1.618), .71), __tsover_add(__tsover_mul(fi, 2.718), 4.17), __tsover_add(__tsover_mul(fi, 3.142), 9.03)));
+	simLayout.$.motes[i] = d.vec4f(__tsover_mul(r.x, prm.domainX), r.y, d.f32(0), d.f32(0));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "i"
+		}],
+		"body": [0, [
+			[
+				13,
+				"prm",
+				[
+					7,
+					[
+						7,
+						"simLayout",
+						"$"
+					],
+					"params"
+				]
+			],
+			[
+				13,
+				"fi",
+				[
+					6,
+					[
+						7,
+						"d",
+						"f32"
+					],
+					["i"]
+				]
+			],
+			[
+				13,
+				"r",
+				[
+					6,
+					[
+						7,
+						"noise",
+						"hash33"
+					],
+					[[
+						6,
+						[
+							7,
+							"d",
+							"vec3f"
+						],
+						[
+							[
+								1,
+								[
+									1,
+									"fi",
+									"*",
+									[5, "1.618"]
+								],
+								"+",
+								[5, "0.71"]
+							],
+							[
+								1,
+								[
+									1,
+									"fi",
+									"*",
+									[5, "2.718"]
+								],
+								"+",
+								[5, "4.17"]
+							],
+							[
+								1,
+								[
+									1,
+									"fi",
+									"*",
+									[5, "3.142"]
+								],
+								"+",
+								[5, "9.03"]
+							]
+						]
+					]]
+				]
+			],
+			[
+				2,
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"simLayout",
+							"$"
+						],
+						"motes"
+					],
+					"i"
+				],
+				"=",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec4f"
+					],
+					[
+						[
+							1,
+							[
+								7,
+								"r",
+								"x"
+							],
+							"*",
+							[
+								7,
+								"prm",
+								"domainX"
+							]
+						],
+						[
+							7,
+							"r",
+							"y"
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "0"]]
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "0"]]
+						]
+					]
+				]
+			]
+		]],
+		"externalNames": [
+			"simLayout",
+			"d",
+			"noise"
+		]
+	},
+	externals: () => ({
+		simLayout,
+		d,
+		noise: noise_exports
+	})
+}) && $.f)({})).$name("floatingParticlesInit");
+const floatingParticlesClearAccumKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x, y) => {
+	"use gpu";
+	const idx = __tsover_add(__tsover_mul(y, d.u32(RES)), x);
+	std.atomicStore(simLayout.$.accumE[idx], d.u32(0));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "x"
+		}, {
+			"type": "i",
+			"name": "y"
+		}],
+		"body": [0, [[
+			13,
+			"idx",
+			[
+				1,
+				[
+					1,
+					"y",
+					"*",
+					[
+						6,
+						[
+							7,
+							"d",
+							"u32"
+						],
+						["RES"]
+					]
+				],
+				"+",
+				"x"
+			]
+		], [
+			6,
+			[
+				7,
+				"std",
+				"atomicStore"
+			],
+			[[
+				8,
+				[
+					7,
+					[
+						7,
+						"simLayout",
+						"$"
+					],
+					"accumE"
+				],
+				"idx"
+			], [
+				6,
+				[
+					7,
+					"d",
+					"u32"
+				],
+				[[5, "0"]]
+			]]
+		]]],
+		"externalNames": [
+			"d",
+			"RES",
+			"std",
+			"simLayout"
+		]
+	},
+	externals: () => ({
+		d,
+		RES,
+		std,
+		simLayout
+	})
+}) && $.f)({})).$name("floatingParticlesClearAccum");
+const floatingParticlesUpdateKernel = tgpu.fn([d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
+	"use gpu";
+	const prm = simLayout.$.params;
+	const s = simLayout.$.motes[i];
+	const fi = d.f32(i);
+	const dt = prm.dt;
+	let pos = d.vec2f(s.x, s.y);
+	let gust = d.vec2f(s.z, s.w);
+	if (prm.cursorForce > 1e-5) {
+		const delta = pos.sub(d.vec2f(prm.cursorX, prm.cursorY));
+		gust = gust.add(cursorMagnet(delta, prm.cursorRadSq, prm.cursorForce).mul(dt));
+	}
+	gust = gust.mul(prm.dragMul);
+	pos = pos.add(moteDrift(fi).add(gust).mul(dt));
+	const wx = __tsover_sub(pos.x, __tsover_mul(std.floor(__tsover_div(pos.x, std.max(prm.domainX, 1e-4))), prm.domainX));
+	const wy = __tsover_sub(pos.y, std.floor(pos.y));
+	simLayout.$.motes[i] = d.vec4f(wx, wy, gust.x, gust.y);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "i"
+		}],
+		"body": [0, [
+			[
+				13,
+				"prm",
+				[
+					7,
+					[
+						7,
+						"simLayout",
+						"$"
+					],
+					"params"
+				]
+			],
+			[
+				13,
+				"s",
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"simLayout",
+							"$"
+						],
+						"motes"
+					],
+					"i"
+				]
+			],
+			[
+				13,
+				"fi",
+				[
+					6,
+					[
+						7,
+						"d",
+						"f32"
+					],
+					["i"]
+				]
+			],
+			[
+				13,
+				"dt",
+				[
+					7,
+					"prm",
+					"dt"
+				]
+			],
+			[
+				12,
+				"pos",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec2f"
+					],
+					[[
+						7,
+						"s",
+						"x"
+					], [
+						7,
+						"s",
+						"y"
+					]]
+				]
+			],
+			[
+				12,
+				"gust",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec2f"
+					],
+					[[
+						7,
+						"s",
+						"z"
+					], [
+						7,
+						"s",
+						"w"
+					]]
+				]
+			],
+			[
+				11,
+				[
+					1,
+					[
+						7,
+						"prm",
+						"cursorForce"
+					],
+					">",
+					[5, "0.00001"]
+				],
+				[0, [[
+					13,
+					"delta",
+					[
+						6,
+						[
+							7,
+							"pos",
+							"sub"
+						],
+						[[
+							6,
+							[
+								7,
+								"d",
+								"vec2f"
+							],
+							[[
+								7,
+								"prm",
+								"cursorX"
+							], [
+								7,
+								"prm",
+								"cursorY"
+							]]
+						]]
+					]
+				], [
+					2,
+					"gust",
+					"=",
+					[
+						6,
+						[
+							7,
+							"gust",
+							"add"
+						],
+						[[
+							6,
+							[
+								7,
+								[
+									6,
+									[
+										7,
+										"agents",
+										"cursorMagnet"
+									],
+									[
+										"delta",
+										[
+											7,
+											"prm",
+											"cursorRadSq"
+										],
+										[
+											7,
+											"prm",
+											"cursorForce"
+										]
+									]
+								],
+								"mul"
+							],
+							["dt"]
+						]]
+					]
+				]]]
+			],
+			[
+				2,
+				"gust",
+				"=",
+				[
+					6,
+					[
+						7,
+						"gust",
+						"mul"
+					],
+					[[
+						7,
+						"prm",
+						"dragMul"
+					]]
+				]
+			],
+			[
+				2,
+				"pos",
+				"=",
+				[
+					6,
+					[
+						7,
+						"pos",
+						"add"
+					],
+					[[
+						6,
+						[
+							7,
+							[
+								6,
+								[
+									7,
+									[
+										6,
+										"moteDrift",
+										["fi"]
+									],
+									"add"
+								],
+								["gust"]
+							],
+							"mul"
+						],
+						["dt"]
+					]]
+				]
+			],
+			[
+				13,
+				"wx",
+				[
+					1,
+					[
+						7,
+						"pos",
+						"x"
+					],
+					"-",
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"std",
+								"floor"
+							],
+							[[
+								1,
+								[
+									7,
+									"pos",
+									"x"
+								],
+								"/",
+								[
+									6,
+									[
+										7,
+										"std",
+										"max"
+									],
+									[[
+										7,
+										"prm",
+										"domainX"
+									], [5, "0.0001"]]
+								]
+							]]
+						],
+						"*",
+						[
+							7,
+							"prm",
+							"domainX"
+						]
+					]
+				]
+			],
+			[
+				13,
+				"wy",
+				[
+					1,
+					[
+						7,
+						"pos",
+						"y"
+					],
+					"-",
+					[
+						6,
+						[
+							7,
+							"std",
+							"floor"
+						],
+						[[
+							7,
+							"pos",
+							"y"
+						]]
+					]
+				]
+			],
+			[
+				2,
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"simLayout",
+							"$"
+						],
+						"motes"
+					],
+					"i"
+				],
+				"=",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec4f"
+					],
+					[
+						"wx",
+						"wy",
+						[
+							7,
+							"gust",
+							"x"
+						],
+						[
+							7,
+							"gust",
+							"y"
+						]
+					]
+				]
+			]
+		]],
+		"externalNames": [
+			"simLayout",
+			"d",
+			"agents",
+			"moteDrift",
+			"std"
+		]
+	},
+	externals: () => ({
+		simLayout,
+		d,
+		agents: agents_exports,
+		moteDrift,
+		std
+	})
+}) && $.f)({})).$name("floatingParticlesUpdate");
+function makeFloatingParticlesSplatKernel(shape) {
+	const name = resolveAgentShape(shape, "dot");
+	const s = AGENT_SHAPES[name];
+	const weightFn = makeAgentWeightFn(name);
+	const FORCE_SOFT = s.soft;
+	const EXT = s.ext;
+	return tgpu.fn([d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
+		"use gpu";
+		const prm = simLayout.$.params;
+		const s4 = simLayout.$.motes[i];
+		const fi = d.f32(i);
+		const pos = d.vec2f(s4.x, s4.y).add(moteOrbit(fi));
+		const presence = motePresence(fi);
+		const ph = __tsover_mul(hash11(__tsover_add(__tsover_mul(fi, 3.7), .93)), TAU);
+		const twk = __tsover_add(__tsover_mul(std.sin(__tsover_add(__tsover_mul(prm.time, TWINKLE_FREQ), ph)), .5), .5);
+		const bright = __tsover_mul(std.mix(d.f32(1), twk, prm.twinkle), __tsover_add(.4, __tsover_mul(.6, presence)));
+		const softV = std.max(prm.softness, d.f32(FORCE_SOFT));
+		const extK = std.mix(d.f32(EXT), std.max(d.f32(EXT), 2.4), softV);
+		const gain = std.mix(d.f32(HARD_GAIN), d.f32(SOFT_GAIN), softV);
+		const bodyR = std.max(__tsover_mul(prm.bodyR, __tsover_add(.55, __tsover_mul(.45, presence))), 1e-6);
+		const extSq = __tsover_mul(__tsover_add(__tsover_mul(bodyR, extK), __tsover_mul(AA_W, 2)), __tsover_add(__tsover_mul(bodyR, extK), __tsover_mul(AA_W, 2)));
+		const txf = __tsover_mul(__tsover_div(pos.x, prm.aspect), d.f32(RES));
+		const tyf = __tsover_mul(pos.y, d.f32(RES));
+		const cxi = d.i32(std.floor(txf));
+		const cyi = d.i32(std.floor(tyf));
+		for (let ky = 0; ky < SPLAT_WIN; ky++) for (let kx = 0; kx < SPLAT_WIN; kx++) {
+			const px = __tsover_sub(__tsover_add(cxi, kx), SPLAT_R);
+			const py = __tsover_sub(__tsover_add(cyi, ky), SPLAT_R);
+			if (px >= 0 && px < RES && py >= 0 && py < RES) {
+				const offX = __tsover_sub(__tsover_mul(__tsover_mul(__tsover_add(d.f32(px), .5), INV_RES), prm.aspect), pos.x);
+				const offY = __tsover_sub(__tsover_mul(__tsover_add(d.f32(py), .5), INV_RES), pos.y);
+				if (__tsover_add(__tsover_mul(offX, offX), __tsover_mul(offY, offY)) < extSq) {
+					const w = __tsover_mul(weightFn(offX, offY, bodyR, AA_W, softV), bright);
+					const e = d.u32(__tsover_mul(w, gain));
+					if (e > d.u32(0)) {
+						const idx = d.u32(__tsover_add(__tsover_mul(py, RES), px));
+						std.atomicAdd(simLayout.$.accumE[idx], e);
+					}
+				}
+			}
+		}
+	}), {
+		v: 1,
+		name: void 0,
+		ast: {
+			"params": [{
+				"type": "i",
+				"name": "i"
+			}],
+			"body": [0, [
+				[
+					13,
+					"prm",
+					[
+						7,
+						[
+							7,
+							"simLayout",
+							"$"
+						],
+						"params"
+					]
+				],
+				[
+					13,
+					"s4",
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"simLayout",
+								"$"
+							],
+							"motes"
+						],
+						"i"
+					]
+				],
+				[
+					13,
+					"fi",
+					[
+						6,
+						[
+							7,
+							"d",
+							"f32"
+						],
+						["i"]
+					]
+				],
+				[
+					13,
+					"pos",
+					[
+						6,
+						[
+							7,
+							[
+								6,
+								[
+									7,
+									"d",
+									"vec2f"
+								],
+								[[
+									7,
+									"s4",
+									"x"
+								], [
+									7,
+									"s4",
+									"y"
+								]]
+							],
+							"add"
+						],
+						[[
+							6,
+							"moteOrbit",
+							["fi"]
+						]]
+					]
+				],
+				[
+					13,
+					"presence",
+					[
+						6,
+						"motePresence",
+						["fi"]
+					]
+				],
+				[
+					13,
+					"ph",
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"noise",
+								"hash11"
+							],
+							[[
+								1,
+								[
+									1,
+									"fi",
+									"*",
+									[5, "3.7"]
+								],
+								"+",
+								[5, "0.93"]
+							]]
+						],
+						"*",
+						"TAU"
+					]
+				],
+				[
+					13,
+					"twk",
+					[
+						1,
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"std",
+									"sin"
+								],
+								[[
+									1,
+									[
+										1,
+										[
+											7,
+											"prm",
+											"time"
+										],
+										"*",
+										"TWINKLE_FREQ"
+									],
+									"+",
+									"ph"
+								]]
+							],
+							"*",
+							[5, "0.5"]
+						],
+						"+",
+						[5, "0.5"]
+					]
+				],
+				[
+					13,
+					"bright",
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"std",
+								"mix"
+							],
+							[
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									[[5, "1"]]
+								],
+								"twk",
+								[
+									7,
+									"prm",
+									"twinkle"
+								]
+							]
+						],
+						"*",
+						[
+							1,
+							[5, "0.4"],
+							"+",
+							[
+								1,
+								[5, "0.6"],
+								"*",
+								"presence"
+							]
+						]
+					]
+				],
+				[
+					13,
+					"softV",
+					[
+						6,
+						[
+							7,
+							"std",
+							"max"
+						],
+						[[
+							7,
+							"prm",
+							"softness"
+						], [
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							["FORCE_SOFT"]
+						]]
+					]
+				],
+				[
+					13,
+					"extK",
+					[
+						6,
+						[
+							7,
+							"std",
+							"mix"
+						],
+						[
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								["EXT"]
+							],
+							[
+								6,
+								[
+									7,
+									"std",
+									"max"
+								],
+								[[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									["EXT"]
+								], [5, "2.4"]]
+							],
+							"softV"
+						]
+					]
+				],
+				[
+					13,
+					"gain",
+					[
+						6,
+						[
+							7,
+							"std",
+							"mix"
+						],
+						[
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								["HARD_GAIN"]
+							],
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								["SOFT_GAIN"]
+							],
+							"softV"
+						]
+					]
+				],
+				[
+					13,
+					"bodyR",
+					[
+						6,
+						[
+							7,
+							"std",
+							"max"
+						],
+						[[
+							1,
+							[
+								7,
+								"prm",
+								"bodyR"
+							],
+							"*",
+							[
+								1,
+								[5, "0.55"],
+								"+",
+								[
+									1,
+									[5, "0.45"],
+									"*",
+									"presence"
+								]
+							]
+						], [5, "0.000001"]]
+					]
+				],
+				[
+					13,
+					"extSq",
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								"bodyR",
+								"*",
+								"extK"
+							],
+							"+",
+							[
+								1,
+								"AA_W",
+								"*",
+								[5, "2"]
+							]
+						],
+						"*",
+						[
+							1,
+							[
+								1,
+								"bodyR",
+								"*",
+								"extK"
+							],
+							"+",
+							[
+								1,
+								"AA_W",
+								"*",
+								[5, "2"]
+							]
+						]
+					]
+				],
+				[
+					13,
+					"txf",
+					[
+						1,
+						[
+							1,
+							[
+								7,
+								"pos",
+								"x"
+							],
+							"/",
+							[
+								7,
+								"prm",
+								"aspect"
+							]
+						],
+						"*",
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							["RES"]
+						]
+					]
+				],
+				[
+					13,
+					"tyf",
+					[
+						1,
+						[
+							7,
+							"pos",
+							"y"
+						],
+						"*",
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							["RES"]
+						]
+					]
+				],
+				[
+					13,
+					"cxi",
+					[
+						6,
+						[
+							7,
+							"d",
+							"i32"
+						],
+						[[
+							6,
+							[
+								7,
+								"std",
+								"floor"
+							],
+							["txf"]
+						]]
+					]
+				],
+				[
+					13,
+					"cyi",
+					[
+						6,
+						[
+							7,
+							"d",
+							"i32"
+						],
+						[[
+							6,
+							[
+								7,
+								"std",
+								"floor"
+							],
+							["tyf"]
+						]]
+					]
+				],
+				[
+					14,
+					[
+						12,
+						"ky",
+						[5, "0"]
+					],
+					[
+						1,
+						"ky",
+						"<",
+						"SPLAT_WIN"
+					],
+					[
+						102,
+						"++",
+						"ky"
+					],
+					[0, [[
+						14,
+						[
+							12,
+							"kx",
+							[5, "0"]
+						],
+						[
+							1,
+							"kx",
+							"<",
+							"SPLAT_WIN"
+						],
+						[
+							102,
+							"++",
+							"kx"
+						],
+						[0, [
+							[
+								13,
+								"px",
+								[
+									1,
+									[
+										1,
+										"cxi",
+										"+",
+										"kx"
+									],
+									"-",
+									"SPLAT_R"
+								]
+							],
+							[
+								13,
+								"py",
+								[
+									1,
+									[
+										1,
+										"cyi",
+										"+",
+										"ky"
+									],
+									"-",
+									"SPLAT_R"
+								]
+							],
+							[
+								11,
+								[
+									3,
+									[
+										3,
+										[
+											3,
+											[
+												1,
+												"px",
+												">=",
+												[5, "0"]
+											],
+											"&&",
+											[
+												1,
+												"px",
+												"<",
+												"RES"
+											]
+										],
+										"&&",
+										[
+											1,
+											"py",
+											">=",
+											[5, "0"]
+										]
+									],
+									"&&",
+									[
+										1,
+										"py",
+										"<",
+										"RES"
+									]
+								],
+								[0, [
+									[
+										13,
+										"offX",
+										[
+											1,
+											[
+												1,
+												[
+													1,
+													[
+														1,
+														[
+															6,
+															[
+																7,
+																"d",
+																"f32"
+															],
+															["px"]
+														],
+														"+",
+														[5, "0.5"]
+													],
+													"*",
+													"INV_RES"
+												],
+												"*",
+												[
+													7,
+													"prm",
+													"aspect"
+												]
+											],
+											"-",
+											[
+												7,
+												"pos",
+												"x"
+											]
+										]
+									],
+									[
+										13,
+										"offY",
+										[
+											1,
+											[
+												1,
+												[
+													1,
+													[
+														6,
+														[
+															7,
+															"d",
+															"f32"
+														],
+														["py"]
+													],
+													"+",
+													[5, "0.5"]
+												],
+												"*",
+												"INV_RES"
+											],
+											"-",
+											[
+												7,
+												"pos",
+												"y"
+											]
+										]
+									],
+									[
+										11,
+										[
+											1,
+											[
+												1,
+												[
+													1,
+													"offX",
+													"*",
+													"offX"
+												],
+												"+",
+												[
+													1,
+													"offY",
+													"*",
+													"offY"
+												]
+											],
+											"<",
+											"extSq"
+										],
+										[0, [
+											[
+												13,
+												"w",
+												[
+													1,
+													[
+														6,
+														"weightFn",
+														[
+															"offX",
+															"offY",
+															"bodyR",
+															"AA_W",
+															"softV"
+														]
+													],
+													"*",
+													"bright"
+												]
+											],
+											[
+												13,
+												"e",
+												[
+													6,
+													[
+														7,
+														"d",
+														"u32"
+													],
+													[[
+														1,
+														"w",
+														"*",
+														"gain"
+													]]
+												]
+											],
+											[
+												11,
+												[
+													1,
+													"e",
+													">",
+													[
+														6,
+														[
+															7,
+															"d",
+															"u32"
+														],
+														[[5, "0"]]
+													]
+												],
+												[0, [[
+													13,
+													"idx",
+													[
+														6,
+														[
+															7,
+															"d",
+															"u32"
+														],
+														[[
+															1,
+															[
+																1,
+																"py",
+																"*",
+																"RES"
+															],
+															"+",
+															"px"
+														]]
+													]
+												], [
+													6,
+													[
+														7,
+														"std",
+														"atomicAdd"
+													],
+													[[
+														8,
+														[
+															7,
+															[
+																7,
+																"simLayout",
+																"$"
+															],
+															"accumE"
+														],
+														"idx"
+													], "e"]
+												]]]
+											]
+										]]
+									]
+								]]
+							]
+						]]
+					]]]
+				]
+			]],
+			"externalNames": [
+				"simLayout",
+				"d",
+				"moteOrbit",
+				"motePresence",
+				"noise",
+				"TAU",
+				"std",
+				"TWINKLE_FREQ",
+				"FORCE_SOFT",
+				"EXT",
+				"HARD_GAIN",
+				"SOFT_GAIN",
+				"AA_W",
+				"RES",
+				"SPLAT_WIN",
+				"SPLAT_R",
+				"INV_RES",
+				"weightFn"
+			]
+		},
+		externals: () => ({
+			simLayout,
+			d,
+			moteOrbit,
+			motePresence,
+			noise: noise_exports,
+			TAU,
+			std,
+			TWINKLE_FREQ,
+			FORCE_SOFT,
+			EXT,
+			HARD_GAIN,
+			SOFT_GAIN,
+			AA_W,
+			RES,
+			SPLAT_WIN,
+			SPLAT_R,
+			INV_RES,
+			weightFn
+		})
+	}) && $.f)({})).$name("floatingParticlesSplat");
+}
+const floatingParticlesSplatKernel = makeFloatingParticlesSplatKernel("dot");
+const floatingParticlesResolveKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x, y) => {
+	"use gpu";
+	const prm = simLayout.$.params;
+	const idx = __tsover_add(__tsover_mul(y, d.u32(RES)), x);
+	const energy = __tsover_mul(d.f32(std.atomicLoad(simLayout.$.accumE[idx])), __tsover_div(1, 255));
+	const a = __tsover_mul(__tsover_sub(1, std.exp(__tsover_mul(energy, -1.6))), prm.color.w);
+	std.textureStore(simLayout.$.outTex, d.vec2u(x, y), d.vec4f(prm.color.x, prm.color.y, prm.color.z, a));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "x"
+		}, {
+			"type": "i",
+			"name": "y"
+		}],
+		"body": [0, [
+			[
+				13,
+				"prm",
+				[
+					7,
+					[
+						7,
+						"simLayout",
+						"$"
+					],
+					"params"
+				]
+			],
+			[
+				13,
+				"idx",
+				[
+					1,
+					[
+						1,
+						"y",
+						"*",
+						[
+							6,
+							[
+								7,
+								"d",
+								"u32"
+							],
+							["RES"]
+						]
+					],
+					"+",
+					"x"
+				]
+			],
+			[
+				13,
+				"energy",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"d",
+							"f32"
+						],
+						[[
+							6,
+							[
+								7,
+								"std",
+								"atomicLoad"
+							],
+							[[
+								8,
+								[
+									7,
+									[
+										7,
+										"simLayout",
+										"$"
+									],
+									"accumE"
+								],
+								"idx"
+							]]
+						]]
+					],
+					"*",
+					[
+						1,
+						[5, "1"],
+						"/",
+						[5, "255"]
+					]
+				]
+			],
+			[
+				13,
+				"a",
+				[
+					1,
+					[
+						1,
+						[5, "1"],
+						"-",
+						[
+							6,
+							[
+								7,
+								"std",
+								"exp"
+							],
+							[[
+								1,
+								"energy",
+								"*",
+								[
+									4,
+									"-",
+									[5, "1.6"]
+								]
+							]]
+						]
+					],
+					"*",
+					[
+						7,
+						[
+							7,
+							"prm",
+							"color"
+						],
+						"w"
+					]
+				]
+			],
+			[
+				6,
+				[
+					7,
+					"std",
+					"textureStore"
+				],
+				[
+					[
+						7,
+						[
+							7,
+							"simLayout",
+							"$"
+						],
+						"outTex"
+					],
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec2u"
+						],
+						["x", "y"]
+					],
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec4f"
+						],
+						[
+							[
+								7,
+								[
+									7,
+									"prm",
+									"color"
+								],
+								"x"
+							],
+							[
+								7,
+								[
+									7,
+									"prm",
+									"color"
+								],
+								"y"
+							],
+							[
+								7,
+								[
+									7,
+									"prm",
+									"color"
+								],
+								"z"
+							],
+							"a"
+						]
+					]
+				]
+			]
+		]],
+		"externalNames": [
+			"simLayout",
+			"d",
+			"RES",
+			"std"
+		]
+	},
+	externals: () => ({
+		simLayout,
+		d,
+		RES,
+		std
+	})
+}) && $.f)({})).$name("floatingParticlesResolve");
+const particleOverChild = tgpu.fn([d.vec4f, d.vec4f], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p, c) => {
+	"use gpu";
+	const pa = std.clamp(p.w, 0, 1);
+	const outA = __tsover_add(pa, __tsover_mul(c.w, __tsover_sub(1, pa)));
+	const rgb = p.xyz.mul(pa).add(c.xyz.mul(__tsover_mul(c.w, __tsover_sub(1, pa)))).div(std.max(outA, 1e-4));
+	return d.vec4f(rgb.x, rgb.y, rgb.z, outA);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "p"
+		}, {
+			"type": "i",
+			"name": "c"
+		}],
+		"body": [0, [
+			[
+				13,
+				"pa",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							7,
+							"p",
+							"w"
+						],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"outA",
+				[
+					1,
+					"pa",
+					"+",
+					[
+						1,
+						[
+							7,
+							"c",
+							"w"
+						],
+						"*",
+						[
+							1,
+							[5, "1"],
+							"-",
+							"pa"
+						]
+					]
+				]
+			],
+			[
+				13,
+				"rgb",
+				[
+					6,
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								[
+									6,
+									[
+										7,
+										[
+											7,
+											"p",
+											"xyz"
+										],
+										"mul"
+									],
+									["pa"]
+								],
+								"add"
+							],
+							[[
+								6,
+								[
+									7,
+									[
+										7,
+										"c",
+										"xyz"
+									],
+									"mul"
+								],
+								[[
+									1,
+									[
+										7,
+										"c",
+										"w"
+									],
+									"*",
+									[
+										1,
+										[5, "1"],
+										"-",
+										"pa"
+									]
+								]]
+							]]
+						],
+						"div"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"max"
+						],
+						["outA", [5, "0.0001"]]
+					]]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"d",
+					"vec4f"
+				],
+				[
+					[
+						7,
+						"rgb",
+						"x"
+					],
+					[
+						7,
+						"rgb",
+						"y"
+					],
+					[
+						7,
+						"rgb",
+						"z"
+					],
+					"outA"
+				]
+			]]
+		]],
+		"externalNames": ["std", "d"]
+	},
+	externals: () => ({
+		std,
+		d
+	})
+}) && $.f)({})).$name("floatingParticlesOverChild");
+const componentDefinition = {
+	name: "FloatingParticles",
+	boundingBoxDeclaration: { aspectRatio: null },
+	category: "Textures",
+	description: "Drifting, twinkling motes — thousands of real simulated particles floating in a shared heading with per-particle wander and variance, and a cursor that stirs the field with a gust that settles back into the drift",
+	requiresRTT: false,
+	requiresChild: false,
+	usesPointer: true,
+	props: {
+		particleColor: {
+			default: "#ffffff",
+			transform: transformColor,
+			description: "Color of the particles",
+			ui: {
+				type: "color",
+				label: "Particle Color",
+				group: "Colors"
+			}
+		},
+		shape: {
+			default: "dot",
+			compileTime: true,
+			description: "What each particle is drawn as — a crisp dot or square (softness still feathers them), or a soft glow puff",
+			ui: {
+				type: "select",
+				options: pointShapeOptions,
+				label: "Shape",
+				group: "Effect"
+			}
+		},
+		count: {
+			default: 1200,
+			description: "Number of particles",
+			ui: {
+				type: "range",
+				min: 100,
+				max: MAX_MOTES,
+				step: 100,
+				label: "Count",
+				group: "Effect"
+			}
+		},
+		particleSize: {
+			default: 1.2,
+			description: "Size of the particles (each also varies slightly for depth)",
+			ui: {
+				type: ["range", "map"],
+				min: .3,
+				max: 4,
+				step: .05,
+				label: "Particle Size",
+				group: "Effect"
+			}
+		},
+		softness: {
+			default: .1,
+			description: "Edge softness of each particle — 0 is a crisp shape, 1 a soft glow puff",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Softness",
+				group: "Effect"
+			}
+		},
+		speed: {
+			default: .25,
+			description: "Speed of the shared drift",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Speed",
+				group: "Animation"
+			}
+		},
+		angle: {
+			default: 90,
+			description: "Drift heading in degrees (0 = left, 90 = up, 180 = right, 270 = down — the classic default floats upward)",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Angle",
+				group: "Animation"
+			}
+		},
+		speedVariance: {
+			default: .3,
+			description: "Per-particle speed variance around the shared drift (0 = everything moves in lockstep)",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .05,
+				label: "Speed Variance",
+				group: "Animation"
+			}
+		},
+		angleVariance: {
+			default: 30,
+			description: "Per-particle heading variance in degrees (0 = one shared direction, 180 = every which way)",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 180,
+				step: 1,
+				label: "Angle Variance",
+				group: "Animation"
+			}
+		},
+		randomness: {
+			default: .25,
+			description: "Orbital wander — each particle circles lazily around its drift path instead of gliding straight",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .05,
+				label: "Randomness",
+				group: "Animation"
+			}
+		},
+		twinkle: {
+			default: .5,
+			description: "Intensity of the twinkle (0 = steady, 1 = full shimmer)",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .05,
+				label: "Twinkle",
+				group: "Animation"
+			}
+		},
+		cursorStrength: {
+			default: 0,
+			description: "How strongly the cursor stirs the field — 0 (default) leaves the drift undisturbed",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Cursor Gust",
+				group: "Interaction"
+			}
+		}
+	},
+	compute: (params) => {
+		const { gpu, getCpuValue, registerComputeTexture, onCleanup } = params;
+		const root = gpu?.root;
+		if (!root) return null;
+		const motes = createStateBuffer(root, d.vec4f, MAX_MOTES);
+		const accumE = createStateBuffer(root, d.atomic(d.u32), RES * RES);
+		const outTex = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
+			size: [RES, RES],
+			format: STATE_FORMAT
+		}).$usage("storage", "sampled"), "outTex");
+		onCleanup(() => outTex.destroy());
+		const particleTexture = registerComputeTexture(outTex);
+		const paramsU = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(SimParams), "paramsU");
+		const simBg = root.createBindGroup(simLayout, {
+			motes,
+			accumE,
+			params: paramsU.buffer,
+			outTex
+		});
+		const splatKernel = makeFloatingParticlesSplatKernel(getCpuValue("shape") || "dot");
+		const init = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
+			"use gpu";
+			floatingParticlesInitKernel(i);
+		}), {
+			v: 1,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "i"
+				}],
+				"body": [0, [[
+					6,
+					"floatingParticlesInitKernel",
+					["i"]
+				]]],
+				"externalNames": ["floatingParticlesInitKernel"]
+			},
+			externals: () => ({ floatingParticlesInitKernel })
+		}) && $.f)({})).with(simBg);
+		const clearAccum = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x, y) => {
+			"use gpu";
+			floatingParticlesClearAccumKernel(x, y);
+		}), {
+			v: 1,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "x"
+				}, {
+					"type": "i",
+					"name": "y"
+				}],
+				"body": [0, [[
+					6,
+					"floatingParticlesClearAccumKernel",
+					["x", "y"]
+				]]],
+				"externalNames": ["floatingParticlesClearAccumKernel"]
+			},
+			externals: () => ({ floatingParticlesClearAccumKernel })
+		}) && $.f)({}), { size: [RES, RES] }).with(simBg);
+		const update = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
+			"use gpu";
+			floatingParticlesUpdateKernel(i);
+		}), {
+			v: 1,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "i"
+				}],
+				"body": [0, [[
+					6,
+					"floatingParticlesUpdateKernel",
+					["i"]
+				]]],
+				"externalNames": ["floatingParticlesUpdateKernel"]
+			},
+			externals: () => ({ floatingParticlesUpdateKernel })
+		}) && $.f)({})).with(simBg);
+		const splat = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
+			"use gpu";
+			splatKernel(i);
+		}), {
+			v: 1,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "i"
+				}],
+				"body": [0, [[
+					6,
+					"splatKernel",
+					["i"]
+				]]],
+				"externalNames": ["splatKernel"]
+			},
+			externals: () => ({ splatKernel })
+		}) && $.f)({})).with(simBg);
+		const resolve = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x, y) => {
+			"use gpu";
+			floatingParticlesResolveKernel(x, y);
+		}), {
+			v: 1,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "x"
+				}, {
+					"type": "i",
+					"name": "y"
+				}],
+				"body": [0, [[
+					6,
+					"floatingParticlesResolveKernel",
+					["x", "y"]
+				]]],
+				"externalNames": ["floatingParticlesResolveKernel"]
+			},
+			externals: () => ({ floatingParticlesResolveKernel })
+		}) && $.f)({}), { size: [RES, RES] }).with(simBg);
+		let initialized = false;
+		let localTime = 0;
+		return {
+			outputs: { particleTexture },
+			getComputeNodes: (frameParams) => {
+				const fp = frameParams;
+				const dt = Math.min(Math.max(fp.deltaTime ?? .016, .001), .033);
+				localTime += dt;
+				const h = fp.dimensions?.height ?? 0;
+				const aspect = h > 0 ? (fp.dimensions?.width ?? 0) / h : 16 / 9;
+				const domainX = Math.max(aspect, .01);
+				const g = (key, fallback) => {
+					const v = getCpuValue(key);
+					return typeof v === "number" ? v : fallback;
+				};
+				const count = Math.min(Math.max(Math.round(g("count", 1200)), 16), MAX_MOTES);
+				const cursorX = (fp.pointer?.x ?? .5) * aspect;
+				const cursorY = fp.pointer?.y ?? .5;
+				const cursorRadius = .22;
+				const col = getCpuValue("particleColor");
+				const bodyR = Math.min(Math.max(g("particleSize", 1.2), .3), 4) * 2 * INV_RES;
+				paramsU.write({
+					color: d.vec4f(col?.x ?? 1, col?.y ?? 1, col?.z ?? 1, col?.w ?? 1),
+					count,
+					dt,
+					time: localTime,
+					aspect,
+					domainX,
+					driftBase: Math.min(Math.max(g("speed", .25), 0), 1.5) * BASE_DRIFT / .25,
+					angleRad: g("angle", 90) * DEG_TO_RAD + ANGLE_FLIP,
+					speedVar: Math.min(Math.max(g("speedVariance", .3), 0), 1),
+					angleVarRad: Math.min(Math.max(g("angleVariance", 30), 0), 180) * DEG_TO_RAD,
+					randomness: Math.min(Math.max(g("randomness", .25), 0), 1),
+					twinkle: Math.min(Math.max(g("twinkle", .5), 0), 1),
+					softness: Math.min(Math.max(g("softness", .1), 0), 1),
+					bodyR,
+					cursorX,
+					cursorY,
+					cursorRadSq: cursorRadius * cursorRadius,
+					cursorForce: Math.min(Math.max(g("cursorStrength", 0), 0), 1) * CURSOR_FORCE_K,
+					dragMul: Math.exp(-CURSOR_DRAG * dt)
+				});
+				const nodes = [];
+				if (!initialized) {
+					initialized = true;
+					nodes.push(() => init.dispatchThreads(MAX_MOTES));
+				}
+				nodes.push(clearAccum, () => update.dispatchThreads(count), () => splat.dispatchThreads(count), resolve);
+				return nodes;
+			}
+		};
+	},
+	fragment: ({ ctx, childNode, computeOutputs }) => {
+		const particleField = computeOutputs?.particleTexture;
+		if (!particleField) return childNode ?? ZERO;
+		const p = particleField.sample(ctx.uv, "linearClamp");
+		if (childNode) return call(particleOverChild, "particleOverChild", [p, childNode]);
+		return p;
+	}
+};
+var FloatingParticles_default = componentDefinition;
+export { floatingParticlesResolveKernel as a, makeFloatingParticlesSplatKernel as c, floatingParticlesInitKernel as i, particleOverChild as l, componentDefinition as n, floatingParticlesSplatKernel as o, floatingParticlesClearAccumKernel as r, floatingParticlesUpdateKernel as s, FloatingParticles_default as t };