shaders 3.1.463 → 3.2.464

package/dist/core/FloatingParticles-n4upxu-l.js

@@ -1,2321 +0,0 @@
-import { Dt as sin, Ft as vec3f, Gt as textureStorage2d, Kt as arrayOf, Lt as vec4f, Mt as vec2f, Pt as vec2u, Vt as atomic, _t as max, ct as clamp, d as ZERO, et as typegpu_default, ln as u32, lt as cos, m as call, mt as floor, qt as struct, sn as f32, yt as mix } from "./edges-CV-BHMpI.js";
-import { a as makeAgentWeightFn, c as resolveAgentShape, d as atomicStore, i as makeAgentTexelWeightFn, l as atomicAdd, r as cursorMagnet, s as pointShapeOptions, t as AGENT_SHAPES, u as atomicLoad } from "./agents-CxygFSH4.js";
-import { R as textureStore } from "./device-DKcu50_C.js";
-import { i as PI, o as TAU$1, t as DEG_TO_RAD$1 } from "./constants-BKlzQFdJ.js";
-import { _ as readAgentFrame, b as worldSplatWindow, f as SIZE_REF_RES, g as makeCpuValueGetter, m as energyCoverageAlpha, p as createAgentSystem, u as FIXED_POINT_GAINS, v as resolveRenderRes } from "./porters-j7yWJYy2.js";
-import { l as hash22, o as hash11, u as hash33 } from "./noise-eXd1Bfrw.js";
-import { a as transformColor } from "./transformations-u-UZrXjj.js";
-var MAX_MOTES = 8192;
-var COUNT_MAX_MOBILE = 3e3;
-var RES = resolveRenderRes({
-	desktop: 1024,
-	mobile: 512
-});
-var INV_RES = 1 / RES;
-var STATE_FORMAT = "rgba16float";
-var AA_W = .75 * INV_RES;
-var TAU = TAU$1;
-var DEG_TO_RAD = DEG_TO_RAD$1;
-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 = PI;
-var HARD_GAIN = FIXED_POINT_GAINS.HARD;
-var SOFT_GAIN = FIXED_POINT_GAINS.SOFT;
-var SimParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
-	color: vec4f,
-	count: f32,
-	dt: f32,
-	time: f32,
-	aspect: f32,
-	domainX: f32,
-	driftBase: f32,
-	angleRad: f32,
-	speedVar: f32,
-	angleVarRad: f32,
-	randomness: f32,
-	twinkle: f32,
-	softness: f32,
-	bodyR: f32,
-	cursorX: f32,
-	cursorY: f32,
-	cursorRadSq: f32,
-	cursorForce: f32,
-	dragMul: f32
-}), "SimParams");
-var simLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.bindGroupLayout({
-	motes: {
-		storage: arrayOf(vec4f, MAX_MOTES),
-		access: "mutable"
-	},
-	accumE: {
-		storage: arrayOf(atomic(u32), RES * RES),
-		access: "mutable"
-	},
-	params: { uniform: SimParams },
-	outTex: { storageTexture: textureStorage2d(STATE_FORMAT, "write-only") }
-}), "simLayout");
-var moteDrift = typegpu_default.fn([f32], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((fi) => {
-	"use gpu";
-	const prm = simLayout.$.params;
-	const h = hash22(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 vec2f(cos(ang), sin(ang)).mul(__tsover_mul(prm.driftBase, speedMul));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "fi"
-		}],
-		"body": [0, [
-			[
-				13,
-				"prm",
-				[
-					7,
-					[
-						7,
-						"simLayout",
-						"$"
-					],
-					"params"
-				]
-			],
-			[
-				13,
-				"h",
-				[
-					6,
-					"noise.hash22",
-					[[
-						6,
-						"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,
-						"d.vec2f",
-						[[
-							6,
-							"std.cos",
-							["ang"]
-						], [
-							6,
-							"std.sin",
-							["ang"]
-						]]
-					],
-					"mul"
-				],
-				[[
-					1,
-					[
-						7,
-						"prm",
-						"driftBase"
-					],
-					"*",
-					"speedMul"
-				]]
-			]]
-		]]
-	},
-	externals: {
-		"simLayout": () => simLayout,
-		"noise.hash22": () => hash22,
-		"d.vec2f": () => vec2f,
-		"std.cos": () => cos,
-		"std.sin": () => sin
-	}
-}) && $.f)({})).$name("moteDrift");
-var motePresence = typegpu_default.fn([f32], 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: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "fi"
-		}],
-		"body": [0, [[10, [
-			1,
-			[5, "0.55"],
-			"+",
-			[
-				1,
-				[
-					6,
-					"noise.hash11",
-					[[
-						1,
-						[
-							1,
-							"fi",
-							"*",
-							[5, "1.91"]
-						],
-						"+",
-						[5, "2.53"]
-					]]
-				],
-				"*",
-				[5, "0.7"]
-			]
-		]]]]
-	},
-	externals: { "noise.hash11": () => hash11 }
-}) && $.f)({})).$name("motePresence");
-var moteOrbit = typegpu_default.fn([f32], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((fi) => {
-	"use gpu";
-	const prm = simLayout.$.params;
-	const h = hash22(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 vec2f(cos(t), sin(t)).mul(rad);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "fi"
-		}],
-		"body": [0, [
-			[
-				13,
-				"prm",
-				[
-					7,
-					[
-						7,
-						"simLayout",
-						"$"
-					],
-					"params"
-				]
-			],
-			[
-				13,
-				"h",
-				[
-					6,
-					"noise.hash22",
-					[[
-						6,
-						"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,
-						"d.vec2f",
-						[[
-							6,
-							"std.cos",
-							["t"]
-						], [
-							6,
-							"std.sin",
-							["t"]
-						]]
-					],
-					"mul"
-				],
-				["rad"]
-			]]
-		]]
-	},
-	externals: {
-		"simLayout": () => simLayout,
-		"noise.hash22": () => hash22,
-		"d.vec2f": () => vec2f,
-		"ORBIT_RATE": () => ORBIT_RATE,
-		"TAU": () => TAU,
-		"ORBIT_RAD": () => ORBIT_RAD,
-		"std.cos": () => cos,
-		"std.sin": () => sin
-	}
-}) && $.f)({})).$name("moteOrbit");
-const floatingParticlesInitKernel = typegpu_default.fn([u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
-	"use gpu";
-	const prm = simLayout.$.params;
-	const fi = f32(i);
-	const r = hash33(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] = vec4f(__tsover_mul(r.x, prm.domainX), r.y, f32(0), f32(0));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "i"
-		}],
-		"body": [0, [
-			[
-				13,
-				"prm",
-				[
-					7,
-					[
-						7,
-						"simLayout",
-						"$"
-					],
-					"params"
-				]
-			],
-			[
-				13,
-				"fi",
-				[
-					6,
-					"d.f32",
-					["i"]
-				]
-			],
-			[
-				13,
-				"r",
-				[
-					6,
-					"noise.hash33",
-					[[
-						6,
-						"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,
-					"d.vec4f",
-					[
-						[
-							1,
-							[
-								7,
-								"r",
-								"x"
-							],
-							"*",
-							[
-								7,
-								"prm",
-								"domainX"
-							]
-						],
-						[
-							7,
-							"r",
-							"y"
-						],
-						[
-							6,
-							"d.f32",
-							[[5, "0"]]
-						],
-						[
-							6,
-							"d.f32",
-							[[5, "0"]]
-						]
-					]
-				]
-			]
-		]]
-	},
-	externals: {
-		"simLayout": () => simLayout,
-		"d.f32": () => f32,
-		"noise.hash33": () => hash33,
-		"d.vec3f": () => vec3f,
-		"d.vec4f": () => vec4f
-	}
-}) && $.f)({})).$name("floatingParticlesInit");
-const floatingParticlesUpdateKernel = typegpu_default.fn([u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
-	"use gpu";
-	const prm = simLayout.$.params;
-	const s = simLayout.$.motes[i];
-	const fi = f32(i);
-	const dt = prm.dt;
-	let pos = vec2f(s.x, s.y);
-	let gust = vec2f(s.z, s.w);
-	if (prm.cursorForce > 1e-5) {
-		const delta = pos.sub(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(floor(__tsover_div(pos.x, max(prm.domainX, 1e-4))), prm.domainX));
-	const wy = __tsover_sub(pos.y, floor(pos.y));
-	simLayout.$.motes[i] = vec4f(wx, wy, gust.x, gust.y);
-}), {
-	v: 2,
-	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,
-					"d.f32",
-					["i"]
-				]
-			],
-			[
-				13,
-				"dt",
-				[
-					7,
-					"prm",
-					"dt"
-				]
-			],
-			[
-				12,
-				"pos",
-				[
-					6,
-					"d.vec2f",
-					[[
-						7,
-						"s",
-						"x"
-					], [
-						7,
-						"s",
-						"y"
-					]]
-				]
-			],
-			[
-				12,
-				"gust",
-				[
-					6,
-					"d.vec2f",
-					[[
-						7,
-						"s",
-						"z"
-					], [
-						7,
-						"s",
-						"w"
-					]]
-				]
-			],
-			[
-				11,
-				[
-					1,
-					[
-						7,
-						"prm",
-						"cursorForce"
-					],
-					">",
-					[5, "0.00001"]
-				],
-				[0, [[
-					13,
-					"delta",
-					[
-						6,
-						[
-							7,
-							"pos",
-							"sub"
-						],
-						[[
-							6,
-							"d.vec2f",
-							[[
-								7,
-								"prm",
-								"cursorX"
-							], [
-								7,
-								"prm",
-								"cursorY"
-							]]
-						]]
-					]
-				], [
-					2,
-					"gust",
-					"=",
-					[
-						6,
-						[
-							7,
-							"gust",
-							"add"
-						],
-						[[
-							6,
-							[
-								7,
-								[
-									6,
-									"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,
-							"std.floor",
-							[[
-								1,
-								[
-									7,
-									"pos",
-									"x"
-								],
-								"/",
-								[
-									6,
-									"std.max",
-									[[
-										7,
-										"prm",
-										"domainX"
-									], [5, "0.0001"]]
-								]
-							]]
-						],
-						"*",
-						[
-							7,
-							"prm",
-							"domainX"
-						]
-					]
-				]
-			],
-			[
-				13,
-				"wy",
-				[
-					1,
-					[
-						7,
-						"pos",
-						"y"
-					],
-					"-",
-					[
-						6,
-						"std.floor",
-						[[
-							7,
-							"pos",
-							"y"
-						]]
-					]
-				]
-			],
-			[
-				2,
-				[
-					8,
-					[
-						7,
-						[
-							7,
-							"simLayout",
-							"$"
-						],
-						"motes"
-					],
-					"i"
-				],
-				"=",
-				[
-					6,
-					"d.vec4f",
-					[
-						"wx",
-						"wy",
-						[
-							7,
-							"gust",
-							"x"
-						],
-						[
-							7,
-							"gust",
-							"y"
-						]
-					]
-				]
-			]
-		]]
-	},
-	externals: {
-		"simLayout": () => simLayout,
-		"d.f32": () => f32,
-		"d.vec2f": () => vec2f,
-		"agents.cursorMagnet": () => cursorMagnet,
-		"moteDrift": () => moteDrift,
-		"std.floor": () => floor,
-		"std.max": () => max,
-		"d.vec4f": () => vec4f
-	}
-}) && $.f)({})).$name("floatingParticlesUpdate");
-function makeFloatingParticlesSplatKernel(shape) {
-	const name = resolveAgentShape(shape, "dot");
-	const s = AGENT_SHAPES[name];
-	const FORCE_SOFT = s.soft;
-	const EXT = s.ext;
-	const weightFn = s.soft === 1 ? (() => {
-		const fast = makeAgentTexelWeightFn(name);
-		return typegpu_default.fn([
-			f32,
-			f32,
-			f32,
-			f32,
-			f32,
-			f32
-		], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((q, t, n, bodyR, aaW, _soft) => {
-			"use gpu";
-			return fast(q, t, n, bodyR, aaW);
-		}), {
-			v: 2,
-			name: void 0,
-			ast: {
-				"params": [
-					{
-						"type": "i",
-						"name": "q"
-					},
-					{
-						"type": "i",
-						"name": "t"
-					},
-					{
-						"type": "i",
-						"name": "n"
-					},
-					{
-						"type": "i",
-						"name": "bodyR"
-					},
-					{
-						"type": "i",
-						"name": "aaW"
-					},
-					{
-						"type": "i",
-						"name": "_soft"
-					}
-				],
-				"body": [0, [[10, [
-					6,
-					"fast",
-					[
-						"q",
-						"t",
-						"n",
-						"bodyR",
-						"aaW"
-					]
-				]]]]
-			},
-			externals: { "fast": () => fast }
-		}) && $.f)({})).$name("floatingParticlesWeight");
-	})() : (() => {
-		const general = makeAgentWeightFn(name);
-		return typegpu_default.fn([
-			f32,
-			f32,
-			f32,
-			f32,
-			f32,
-			f32
-		], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((_q, t, n, bodyR, aaW, soft) => {
-			"use gpu";
-			return general(t, n, bodyR, aaW, soft);
-		}), {
-			v: 2,
-			name: void 0,
-			ast: {
-				"params": [
-					{
-						"type": "i",
-						"name": "_q"
-					},
-					{
-						"type": "i",
-						"name": "t"
-					},
-					{
-						"type": "i",
-						"name": "n"
-					},
-					{
-						"type": "i",
-						"name": "bodyR"
-					},
-					{
-						"type": "i",
-						"name": "aaW"
-					},
-					{
-						"type": "i",
-						"name": "soft"
-					}
-				],
-				"body": [0, [[10, [
-					6,
-					"general",
-					[
-						"t",
-						"n",
-						"bodyR",
-						"aaW",
-						"soft"
-					]
-				]]]]
-			},
-			externals: { "general": () => general }
-		}) && $.f)({})).$name("floatingParticlesWeight");
-	})();
-	return typegpu_default.fn([u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
-		"use gpu";
-		const prm = simLayout.$.params;
-		const s4 = simLayout.$.motes[i];
-		const fi = f32(i);
-		const pos = 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(sin(__tsover_add(__tsover_mul(prm.time, TWINKLE_FREQ), ph)), .5), .5);
-		const bright = __tsover_mul(mix(f32(1), twk, prm.twinkle), __tsover_add(.4, __tsover_mul(.6, presence)));
-		const aspect = max(prm.aspect, 1e-5);
-		const softV = max(prm.softness, f32(FORCE_SOFT));
-		const extK = mix(f32(EXT), max(f32(EXT), 2.4), softV);
-		const gain = mix(f32(HARD_GAIN), f32(SOFT_GAIN), softV);
-		const bodyR = max(__tsover_mul(prm.bodyR, __tsover_add(.55, __tsover_mul(.45, presence))), 1e-6);
-		const invBodyR = __tsover_div(1, bodyR);
-		const reach = __tsover_add(__tsover_mul(bodyR, extK), __tsover_mul(AA_W, 2));
-		const reachQ = __tsover_mul(__tsover_mul(reach, invBodyR), __tsover_mul(reach, invBodyR));
-		const win = worldSplatWindow(pos, reach, aspect, f32(RES));
-		for (let py = win.y0; py <= win.y1; py++) {
-			const offY = __tsover_sub(__tsover_mul(__tsover_add(f32(py), .5), INV_RES), pos.y);
-			for (let px = win.x0; px <= win.x1; px++) {
-				const offX = __tsover_sub(__tsover_mul(__tsover_mul(__tsover_add(f32(px), .5), INV_RES), aspect), pos.x);
-				const q = __tsover_mul(__tsover_mul(__tsover_add(__tsover_mul(offX, offX), __tsover_mul(offY, offY)), invBodyR), invBodyR);
-				if (q < reachQ) {
-					const w = __tsover_mul(weightFn(q, offX, offY, bodyR, AA_W, softV), bright);
-					const e = u32(__tsover_mul(w, gain));
-					if (e > u32(0)) {
-						const idx = u32(__tsover_add(__tsover_mul(py, RES), px));
-						atomicAdd(simLayout.$.accumE[idx], e);
-					}
-				}
-			}
-		}
-	}), {
-		v: 2,
-		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,
-						"d.f32",
-						["i"]
-					]
-				],
-				[
-					13,
-					"pos",
-					[
-						6,
-						[
-							7,
-							[
-								6,
-								"d.vec2f",
-								[[
-									7,
-									"s4",
-									"x"
-								], [
-									7,
-									"s4",
-									"y"
-								]]
-							],
-							"add"
-						],
-						[[
-							6,
-							"moteOrbit",
-							["fi"]
-						]]
-					]
-				],
-				[
-					13,
-					"presence",
-					[
-						6,
-						"motePresence",
-						["fi"]
-					]
-				],
-				[
-					13,
-					"ph",
-					[
-						1,
-						[
-							6,
-							"noise.hash11",
-							[[
-								1,
-								[
-									1,
-									"fi",
-									"*",
-									[5, "3.7"]
-								],
-								"+",
-								[5, "0.93"]
-							]]
-						],
-						"*",
-						"TAU"
-					]
-				],
-				[
-					13,
-					"twk",
-					[
-						1,
-						[
-							1,
-							[
-								6,
-								"std.sin",
-								[[
-									1,
-									[
-										1,
-										[
-											7,
-											"prm",
-											"time"
-										],
-										"*",
-										"TWINKLE_FREQ"
-									],
-									"+",
-									"ph"
-								]]
-							],
-							"*",
-							[5, "0.5"]
-						],
-						"+",
-						[5, "0.5"]
-					]
-				],
-				[
-					13,
-					"bright",
-					[
-						1,
-						[
-							6,
-							"std.mix",
-							[
-								[
-									6,
-									"d.f32",
-									[[5, "1"]]
-								],
-								"twk",
-								[
-									7,
-									"prm",
-									"twinkle"
-								]
-							]
-						],
-						"*",
-						[
-							1,
-							[5, "0.4"],
-							"+",
-							[
-								1,
-								[5, "0.6"],
-								"*",
-								"presence"
-							]
-						]
-					]
-				],
-				[
-					13,
-					"aspect",
-					[
-						6,
-						"std.max",
-						[[
-							7,
-							"prm",
-							"aspect"
-						], [5, "0.00001"]]
-					]
-				],
-				[
-					13,
-					"softV",
-					[
-						6,
-						"std.max",
-						[[
-							7,
-							"prm",
-							"softness"
-						], [
-							6,
-							"d.f32",
-							["FORCE_SOFT"]
-						]]
-					]
-				],
-				[
-					13,
-					"extK",
-					[
-						6,
-						"std.mix",
-						[
-							[
-								6,
-								"d.f32",
-								["EXT"]
-							],
-							[
-								6,
-								"std.max",
-								[[
-									6,
-									"d.f32",
-									["EXT"]
-								], [5, "2.4"]]
-							],
-							"softV"
-						]
-					]
-				],
-				[
-					13,
-					"gain",
-					[
-						6,
-						"std.mix",
-						[
-							[
-								6,
-								"d.f32",
-								["HARD_GAIN"]
-							],
-							[
-								6,
-								"d.f32",
-								["SOFT_GAIN"]
-							],
-							"softV"
-						]
-					]
-				],
-				[
-					13,
-					"bodyR",
-					[
-						6,
-						"std.max",
-						[[
-							1,
-							[
-								7,
-								"prm",
-								"bodyR"
-							],
-							"*",
-							[
-								1,
-								[5, "0.55"],
-								"+",
-								[
-									1,
-									[5, "0.45"],
-									"*",
-									"presence"
-								]
-							]
-						], [5, "0.000001"]]
-					]
-				],
-				[
-					13,
-					"invBodyR",
-					[
-						1,
-						[5, "1"],
-						"/",
-						"bodyR"
-					]
-				],
-				[
-					13,
-					"reach",
-					[
-						1,
-						[
-							1,
-							"bodyR",
-							"*",
-							"extK"
-						],
-						"+",
-						[
-							1,
-							"AA_W",
-							"*",
-							[5, "2"]
-						]
-					]
-				],
-				[
-					13,
-					"reachQ",
-					[
-						1,
-						[
-							1,
-							"reach",
-							"*",
-							"invBodyR"
-						],
-						"*",
-						[
-							1,
-							"reach",
-							"*",
-							"invBodyR"
-						]
-					]
-				],
-				[
-					13,
-					"win",
-					[
-						6,
-						"worldSplatWindow",
-						[
-							"pos",
-							"reach",
-							"aspect",
-							[
-								6,
-								"d.f32",
-								["RES"]
-							]
-						]
-					]
-				],
-				[
-					14,
-					[
-						12,
-						"py",
-						[
-							7,
-							"win",
-							"y0"
-						]
-					],
-					[
-						1,
-						"py",
-						"<=",
-						[
-							7,
-							"win",
-							"y1"
-						]
-					],
-					[
-						102,
-						"++",
-						"py"
-					],
-					[0, [[
-						13,
-						"offY",
-						[
-							1,
-							[
-								1,
-								[
-									1,
-									[
-										6,
-										"d.f32",
-										["py"]
-									],
-									"+",
-									[5, "0.5"]
-								],
-								"*",
-								"INV_RES"
-							],
-							"-",
-							[
-								7,
-								"pos",
-								"y"
-							]
-						]
-					], [
-						14,
-						[
-							12,
-							"px",
-							[
-								7,
-								"win",
-								"x0"
-							]
-						],
-						[
-							1,
-							"px",
-							"<=",
-							[
-								7,
-								"win",
-								"x1"
-							]
-						],
-						[
-							102,
-							"++",
-							"px"
-						],
-						[0, [
-							[
-								13,
-								"offX",
-								[
-									1,
-									[
-										1,
-										[
-											1,
-											[
-												1,
-												[
-													6,
-													"d.f32",
-													["px"]
-												],
-												"+",
-												[5, "0.5"]
-											],
-											"*",
-											"INV_RES"
-										],
-										"*",
-										"aspect"
-									],
-									"-",
-									[
-										7,
-										"pos",
-										"x"
-									]
-								]
-							],
-							[
-								13,
-								"q",
-								[
-									1,
-									[
-										1,
-										[
-											1,
-											[
-												1,
-												"offX",
-												"*",
-												"offX"
-											],
-											"+",
-											[
-												1,
-												"offY",
-												"*",
-												"offY"
-											]
-										],
-										"*",
-										"invBodyR"
-									],
-									"*",
-									"invBodyR"
-								]
-							],
-							[
-								11,
-								[
-									1,
-									"q",
-									"<",
-									"reachQ"
-								],
-								[0, [
-									[
-										13,
-										"w",
-										[
-											1,
-											[
-												6,
-												"weightFn",
-												[
-													"q",
-													"offX",
-													"offY",
-													"bodyR",
-													"AA_W",
-													"softV"
-												]
-											],
-											"*",
-											"bright"
-										]
-									],
-									[
-										13,
-										"e",
-										[
-											6,
-											"d.u32",
-											[[
-												1,
-												"w",
-												"*",
-												"gain"
-											]]
-										]
-									],
-									[
-										11,
-										[
-											1,
-											"e",
-											">",
-											[
-												6,
-												"d.u32",
-												[[5, "0"]]
-											]
-										],
-										[0, [[
-											13,
-											"idx",
-											[
-												6,
-												"d.u32",
-												[[
-													1,
-													[
-														1,
-														"py",
-														"*",
-														"RES"
-													],
-													"+",
-													"px"
-												]]
-											]
-										], [
-											6,
-											"std.atomicAdd",
-											[[
-												8,
-												[
-													7,
-													[
-														7,
-														"simLayout",
-														"$"
-													],
-													"accumE"
-												],
-												"idx"
-											], "e"]
-										]]]
-									]
-								]]
-							]
-						]]
-					]]]
-				]
-			]]
-		},
-		externals: {
-			"simLayout": () => simLayout,
-			"d.f32": () => f32,
-			"d.vec2f": () => vec2f,
-			"moteOrbit": () => moteOrbit,
-			"motePresence": () => motePresence,
-			"noise.hash11": () => hash11,
-			"TAU": () => TAU,
-			"std.sin": () => sin,
-			"TWINKLE_FREQ": () => TWINKLE_FREQ,
-			"std.mix": () => mix,
-			"std.max": () => max,
-			"FORCE_SOFT": () => FORCE_SOFT,
-			"EXT": () => EXT,
-			"HARD_GAIN": () => HARD_GAIN,
-			"SOFT_GAIN": () => SOFT_GAIN,
-			"AA_W": () => AA_W,
-			"worldSplatWindow": () => worldSplatWindow,
-			"RES": () => RES,
-			"INV_RES": () => INV_RES,
-			"weightFn": () => weightFn,
-			"d.u32": () => u32,
-			"std.atomicAdd": () => atomicAdd
-		}
-	}) && $.f)({})).$name("floatingParticlesSplat");
-}
-const floatingParticlesSplatKernel = makeFloatingParticlesSplatKernel("dot");
-const floatingParticlesResolveKernel = typegpu_default.fn([u32, 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, u32(RES)), x);
-	const energy = __tsover_mul(f32(atomicLoad(simLayout.$.accumE[idx])), __tsover_div(1, 255));
-	atomicStore(simLayout.$.accumE[idx], u32(0));
-	const a = __tsover_mul(energyCoverageAlpha(energy, 1.6), prm.color.w);
-	textureStore(simLayout.$.outTex, vec2u(x, y), vec4f(prm.color.x, prm.color.y, prm.color.z, a));
-}), {
-	v: 2,
-	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,
-							"d.u32",
-							["RES"]
-						]
-					],
-					"+",
-					"x"
-				]
-			],
-			[
-				13,
-				"energy",
-				[
-					1,
-					[
-						6,
-						"d.f32",
-						[[
-							6,
-							"std.atomicLoad",
-							[[
-								8,
-								[
-									7,
-									[
-										7,
-										"simLayout",
-										"$"
-									],
-									"accumE"
-								],
-								"idx"
-							]]
-						]]
-					],
-					"*",
-					[
-						1,
-						[5, "1"],
-						"/",
-						[5, "255"]
-					]
-				]
-			],
-			[
-				6,
-				"std.atomicStore",
-				[[
-					8,
-					[
-						7,
-						[
-							7,
-							"simLayout",
-							"$"
-						],
-						"accumE"
-					],
-					"idx"
-				], [
-					6,
-					"d.u32",
-					[[5, "0"]]
-				]]
-			],
-			[
-				13,
-				"a",
-				[
-					1,
-					[
-						6,
-						"energyCoverageAlpha",
-						["energy", [5, "1.6"]]
-					],
-					"*",
-					[
-						7,
-						[
-							7,
-							"prm",
-							"color"
-						],
-						"w"
-					]
-				]
-			],
-			[
-				6,
-				"std.textureStore",
-				[
-					[
-						7,
-						[
-							7,
-							"simLayout",
-							"$"
-						],
-						"outTex"
-					],
-					[
-						6,
-						"d.vec2u",
-						["x", "y"]
-					],
-					[
-						6,
-						"d.vec4f",
-						[
-							[
-								7,
-								[
-									7,
-									"prm",
-									"color"
-								],
-								"x"
-							],
-							[
-								7,
-								[
-									7,
-									"prm",
-									"color"
-								],
-								"y"
-							],
-							[
-								7,
-								[
-									7,
-									"prm",
-									"color"
-								],
-								"z"
-							],
-							"a"
-						]
-					]
-				]
-			]
-		]]
-	},
-	externals: {
-		"simLayout": () => simLayout,
-		"d.u32": () => u32,
-		"RES": () => RES,
-		"d.f32": () => f32,
-		"std.atomicLoad": () => atomicLoad,
-		"std.atomicStore": () => atomicStore,
-		"energyCoverageAlpha": () => energyCoverageAlpha,
-		"std.textureStore": () => textureStore,
-		"d.vec2u": () => vec2u,
-		"d.vec4f": () => vec4f
-	}
-}) && $.f)({})).$name("floatingParticlesResolve");
-const particleOverChild = typegpu_default.fn([vec4f, vec4f], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p, c) => {
-	"use gpu";
-	const pa = 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(max(outA, 1e-4));
-	return vec4f(rgb.x, rgb.y, rgb.z, outA);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "p"
-		}, {
-			"type": "i",
-			"name": "c"
-		}],
-		"body": [0, [
-			[
-				13,
-				"pa",
-				[
-					6,
-					"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,
-						"std.max",
-						["outA", [5, "0.0001"]]
-					]]
-				]
-			],
-			[10, [
-				6,
-				"d.vec4f",
-				[
-					[
-						7,
-						"rgb",
-						"x"
-					],
-					[
-						7,
-						"rgb",
-						"y"
-					],
-					[
-						7,
-						"rgb",
-						"z"
-					],
-					"outA"
-				]
-			]]
-		]]
-	},
-	externals: {
-		"std.clamp": () => clamp,
-		"std.max": () => max,
-		"d.vec4f": () => vec4f
-	}
-}) && $.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 { getCpuValue } = params;
-		if (!params.gpu?.root) return null;
-		const splatKernel = makeFloatingParticlesSplatKernel(getCpuValue("shape") || "dot");
-		const sys = createAgentSystem(params, {
-			layout: simLayout,
-			params: SimParams,
-			maxAgents: MAX_MOTES,
-			output: {
-				key: "outTex",
-				name: "particleTexture",
-				size: [RES, RES],
-				format: STATE_FORMAT
-			},
-			countCap: {
-				desktop: MAX_MOTES,
-				mobile: COUNT_MAX_MOBILE
-			},
-			pipelines: {
-				init: {
-					kernel: floatingParticlesInitKernel,
-					threads: "max"
-				},
-				update: {
-					kernel: floatingParticlesUpdateKernel,
-					threads: "agents"
-				},
-				splat: {
-					kernel: splatKernel,
-					threads: "agents"
-				},
-				resolve: {
-					kernel: floatingParticlesResolveKernel,
-					threads: "fixed",
-					size: [RES, RES]
-				}
-			},
-			initStep: "init",
-			program: [
-				"update",
-				"splat",
-				"resolve"
-			]
-		});
-		if (!sys) return null;
-		const g = makeCpuValueGetter(getCpuValue);
-		let localTime = 0;
-		return {
-			outputs: sys.outputs,
-			getComputeNodes: (frameParams) => {
-				const { dt, aspect, pointerX, pointerY } = readAgentFrame(frameParams);
-				localTime += dt;
-				const domainX = Math.max(aspect, .01);
-				const count = sys.resolveCount(g("count", 1200));
-				const cursorX = pointerX * aspect;
-				const cursorY = pointerY;
-				const cursorRadius = .22;
-				const col = getCpuValue("particleColor");
-				const bodyR = Math.min(Math.max(g("particleSize", 1.2), .3), 4) * 2 / SIZE_REF_RES;
-				sys.writeParams({
-					color: 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)
-				});
-				return sys.frame({ count });
-			}
-		};
-	},
-	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 { floatingParticlesSplatKernel as a, particleOverChild as c, floatingParticlesResolveKernel as i, componentDefinition as n, floatingParticlesUpdateKernel as o, floatingParticlesInitKernel as r, makeFloatingParticlesSplatKernel as s, FloatingParticles_default as t };