shaders 3.0.441 → 3.0.443

package/dist/core/ParticleField-XypD7Eru.js

@@ -0,0 +1,4786 @@
+import { J as std, Rt as ZERO, X as createGuardedCompute, Z as createStateBuffer, a as cursorFalloff, bn as d, i as agents_exports, l as pointShapeOptions, n as tgpu, o as cursorMagnet, pt as noise_exports, r as AGENT_SHAPES, s as makeAgentWeightFn, st as hash12, u as resolveAgentShape, x as isMobileGpuViewport } from "./coords-0A7CojvN.js";
+var GRID_DIM_MAX = 256;
+var MAX_PARTICLES = GRID_DIM_MAX * GRID_DIM_MAX;
+var COUNT_MAX = 4e4;
+var OUT_MAX = isMobileGpuViewport() ? 768 : 1024;
+var OUT_CELLS = OUT_MAX * OUT_MAX;
+var SPLAT_R = 8;
+var SPLAT_WIN = 17;
+var STATE_FORMAT = "rgba16float";
+var FP = 2048;
+var WOBBLE_FREQ = 1.15;
+var ALPHA_K = 2.6;
+var TAU = 6.28318530718;
+var PERSP_K = 1.1;
+var STIFF = 26;
+var DRAG = 4.2;
+var MAX_SPEED = 4;
+var CURSOR_FORCE_K = 10;
+var CURSOR_ZFORCE_K = 4;
+var SimParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(d.struct({
+	rowX: d.vec4f,
+	rowY: d.vec4f,
+	rowZ: d.vec4f,
+	dt: d.f32,
+	time: d.f32,
+	snap: d.f32,
+	gridW: d.f32,
+	gridH: d.f32,
+	outW: d.f32,
+	outH: d.f32,
+	depth: d.f32,
+	dragMul: d.f32,
+	wobbleAmp: d.f32,
+	depthShading: d.f32,
+	spacing: d.f32,
+	particleSize: d.f32,
+	aspect: d.f32,
+	zoom: d.f32,
+	transX: d.f32,
+	transY: d.f32,
+	pointerX: d.f32,
+	pointerY: d.f32,
+	cursorForce: d.f32,
+	cursorZForce: d.f32,
+	cursorRadSq: d.f32
+}), "SimParams");
+var fieldLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+	pos: {
+		storage: d.arrayOf(d.vec4f, MAX_PARTICLES),
+		access: "mutable"
+	},
+	vel: {
+		storage: d.arrayOf(d.vec4f, MAX_PARTICLES),
+		access: "mutable"
+	},
+	col: {
+		storage: d.arrayOf(d.vec4f, MAX_PARTICLES),
+		access: "mutable"
+	},
+	accumR: {
+		storage: d.arrayOf(d.atomic(d.u32), OUT_CELLS),
+		access: "mutable"
+	},
+	accumG: {
+		storage: d.arrayOf(d.atomic(d.u32), OUT_CELLS),
+		access: "mutable"
+	},
+	accumB: {
+		storage: d.arrayOf(d.atomic(d.u32), OUT_CELLS),
+		access: "mutable"
+	},
+	accumW: {
+		storage: d.arrayOf(d.atomic(d.u32), OUT_CELLS),
+		access: "mutable"
+	},
+	params: { uniform: SimParams },
+	src: { texture: d.texture2d(d.f32) },
+	outTex: { storageTexture: d.textureStorage2d(STATE_FORMAT, "write-only") }
+}), "fieldLayout");
+var channelLuminance = tgpu.fn([d.vec3f, d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((rgb, _a) => {
+	"use gpu";
+	return std.dot(rgb, d.vec3f(.299, .587, .114));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "rgb"
+		}, {
+			"type": "i",
+			"name": "_a"
+		}],
+		"body": [0, [[10, [
+			6,
+			[
+				7,
+				"std",
+				"dot"
+			],
+			["rgb", [
+				6,
+				[
+					7,
+					"d",
+					"vec3f"
+				],
+				[
+					[5, "0.299"],
+					[5, "0.587"],
+					[5, "0.114"]
+				]
+			]]
+		]]]],
+		"externalNames": ["std", "d"]
+	},
+	externals: () => ({
+		std,
+		d
+	})
+}) && $.f)({}));
+var channelLuminanceInv = tgpu.fn([d.vec3f, d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((rgb, _a) => {
+	"use gpu";
+	return __tsover_sub(1, std.dot(rgb, d.vec3f(.299, .587, .114)));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "rgb"
+		}, {
+			"type": "i",
+			"name": "_a"
+		}],
+		"body": [0, [[10, [
+			1,
+			[5, "1"],
+			"-",
+			[
+				6,
+				[
+					7,
+					"std",
+					"dot"
+				],
+				["rgb", [
+					6,
+					[
+						7,
+						"d",
+						"vec3f"
+					],
+					[
+						[5, "0.299"],
+						[5, "0.587"],
+						[5, "0.114"]
+					]
+				]]
+			]
+		]]]],
+		"externalNames": ["std", "d"]
+	},
+	externals: () => ({
+		std,
+		d
+	})
+}) && $.f)({}));
+var channelRed = tgpu.fn([d.vec3f, d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((rgb, _a) => {
+	"use gpu";
+	return rgb.x;
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "rgb"
+		}, {
+			"type": "i",
+			"name": "_a"
+		}],
+		"body": [0, [[10, [
+			7,
+			"rgb",
+			"x"
+		]]]],
+		"externalNames": []
+	},
+	externals: () => ({})
+}) && $.f)({}));
+var channelGreen = tgpu.fn([d.vec3f, d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((rgb, _a) => {
+	"use gpu";
+	return rgb.y;
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "rgb"
+		}, {
+			"type": "i",
+			"name": "_a"
+		}],
+		"body": [0, [[10, [
+			7,
+			"rgb",
+			"y"
+		]]]],
+		"externalNames": []
+	},
+	externals: () => ({})
+}) && $.f)({}));
+var channelBlue = tgpu.fn([d.vec3f, d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((rgb, _a) => {
+	"use gpu";
+	return rgb.z;
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "rgb"
+		}, {
+			"type": "i",
+			"name": "_a"
+		}],
+		"body": [0, [[10, [
+			7,
+			"rgb",
+			"z"
+		]]]],
+		"externalNames": []
+	},
+	externals: () => ({})
+}) && $.f)({}));
+var channelSaturation = tgpu.fn([d.vec3f, d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((rgb, _a) => {
+	"use gpu";
+	const mx = std.max(std.max(rgb.x, rgb.y), rgb.z);
+	const mn = std.min(std.min(rgb.x, rgb.y), rgb.z);
+	return __tsover_sub(mx, mn);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "rgb"
+		}, {
+			"type": "i",
+			"name": "_a"
+		}],
+		"body": [0, [
+			[
+				13,
+				"mx",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"max"
+						],
+						[[
+							7,
+							"rgb",
+							"x"
+						], [
+							7,
+							"rgb",
+							"y"
+						]]
+					], [
+						7,
+						"rgb",
+						"z"
+					]]
+				]
+			],
+			[
+				13,
+				"mn",
+				[
+					6,
+					[
+						7,
+						"std",
+						"min"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"min"
+						],
+						[[
+							7,
+							"rgb",
+							"x"
+						], [
+							7,
+							"rgb",
+							"y"
+						]]
+					], [
+						7,
+						"rgb",
+						"z"
+					]]
+				]
+			],
+			[10, [
+				1,
+				"mx",
+				"-",
+				"mn"
+			]]
+		]],
+		"externalNames": ["std"]
+	},
+	externals: () => ({ std })
+}) && $.f)({}));
+var channelAlpha = tgpu.fn([d.vec3f, d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((_rgb, a) => {
+	"use gpu";
+	return a;
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "_rgb"
+		}, {
+			"type": "i",
+			"name": "a"
+		}],
+		"body": [0, [[10, "a"]]],
+		"externalNames": []
+	},
+	externals: () => ({})
+}) && $.f)({}));
+var channelFns = {
+	0: channelLuminance,
+	1: channelLuminanceInv,
+	2: channelRed,
+	3: channelGreen,
+	4: channelBlue,
+	5: channelSaturation,
+	6: channelAlpha
+};
+var DEPTH_SOURCE_MODES = {
+	luminance: 0,
+	luminanceInverted: 1,
+	red: 2,
+	green: 3,
+	blue: 4,
+	saturation: 5,
+	alpha: 6
+};
+const particleFieldClearKernel = 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(fieldLayout.$.params.outW)), x);
+	std.atomicStore(fieldLayout.$.accumR[idx], d.u32(0));
+	std.atomicStore(fieldLayout.$.accumG[idx], d.u32(0));
+	std.atomicStore(fieldLayout.$.accumB[idx], d.u32(0));
+	std.atomicStore(fieldLayout.$.accumW[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"
+							],
+							[[
+								7,
+								[
+									7,
+									[
+										7,
+										"fieldLayout",
+										"$"
+									],
+									"params"
+								],
+								"outW"
+							]]
+						]
+					],
+					"+",
+					"x"
+				]
+			],
+			[
+				6,
+				[
+					7,
+					"std",
+					"atomicStore"
+				],
+				[[
+					8,
+					[
+						7,
+						[
+							7,
+							"fieldLayout",
+							"$"
+						],
+						"accumR"
+					],
+					"idx"
+				], [
+					6,
+					[
+						7,
+						"d",
+						"u32"
+					],
+					[[5, "0"]]
+				]]
+			],
+			[
+				6,
+				[
+					7,
+					"std",
+					"atomicStore"
+				],
+				[[
+					8,
+					[
+						7,
+						[
+							7,
+							"fieldLayout",
+							"$"
+						],
+						"accumG"
+					],
+					"idx"
+				], [
+					6,
+					[
+						7,
+						"d",
+						"u32"
+					],
+					[[5, "0"]]
+				]]
+			],
+			[
+				6,
+				[
+					7,
+					"std",
+					"atomicStore"
+				],
+				[[
+					8,
+					[
+						7,
+						[
+							7,
+							"fieldLayout",
+							"$"
+						],
+						"accumB"
+					],
+					"idx"
+				], [
+					6,
+					[
+						7,
+						"d",
+						"u32"
+					],
+					[[5, "0"]]
+				]]
+			],
+			[
+				6,
+				[
+					7,
+					"std",
+					"atomicStore"
+				],
+				[[
+					8,
+					[
+						7,
+						[
+							7,
+							"fieldLayout",
+							"$"
+						],
+						"accumW"
+					],
+					"idx"
+				], [
+					6,
+					[
+						7,
+						"d",
+						"u32"
+					],
+					[[5, "0"]]
+				]]
+			]
+		]],
+		"externalNames": [
+			"d",
+			"fieldLayout",
+			"std"
+		]
+	},
+	externals: () => ({
+		d,
+		fieldLayout,
+		std
+	})
+}) && $.f)({})).$name("particleFieldClear");
+function makeParticleFieldSimKernel(channelMode) {
+	const channelFn = channelFns[channelMode] ?? channelLuminance;
+	return tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((gx, gy) => {
+		"use gpu";
+		const P = fieldLayout.$.params;
+		const i = __tsover_add(__tsover_mul(gy, d.u32(P.gridW)), gx);
+		const homeU = __tsover_div(__tsover_add(d.f32(gx), .5), P.gridW);
+		const homeV = __tsover_div(__tsover_add(d.f32(gy), .5), P.gridH);
+		const dims = std.textureDimensions(fieldLayout.$.src);
+		const sw = d.f32(dims.x);
+		const sh = d.f32(dims.y);
+		const cu = __tsover_sub(__tsover_mul(homeU, sw), .5);
+		const cv = __tsover_sub(__tsover_mul(homeV, sh), .5);
+		const cx0 = std.floor(cu);
+		const cy0 = std.floor(cv);
+		const fx = __tsover_sub(cu, cx0);
+		const fy = __tsover_sub(cv, cy0);
+		const ix0 = d.u32(std.clamp(cx0, d.f32(0), __tsover_sub(sw, 1)));
+		const ix1 = d.u32(std.clamp(__tsover_add(cx0, 1), d.f32(0), __tsover_sub(sw, 1)));
+		const iy0 = d.u32(std.clamp(cy0, d.f32(0), __tsover_sub(sh, 1)));
+		const iy1 = d.u32(std.clamp(__tsover_add(cy0, 1), d.f32(0), __tsover_sub(sh, 1)));
+		const c00 = std.textureLoad(fieldLayout.$.src, d.vec2u(ix0, iy0), 0);
+		const c10 = std.textureLoad(fieldLayout.$.src, d.vec2u(ix1, iy0), 0);
+		const c01 = std.textureLoad(fieldLayout.$.src, d.vec2u(ix0, iy1), 0);
+		const c11 = std.textureLoad(fieldLayout.$.src, d.vec2u(ix1, iy1), 0);
+		const prem = std.mix(std.mix(c00, c10, fx), std.mix(c01, c11, fx), fy);
+		const a = prem.w;
+		const rgb = prem.xyz.div(std.max(a, d.f32(1e-4)));
+		fieldLayout.$.col[i] = d.vec4f(rgb.x, rgb.y, rgb.z, a);
+		const ch = channelFn(rgb, a);
+		const targetZ = __tsover_mul(__tsover_sub(ch, .5), P.depth);
+		const p4 = fieldLayout.$.pos[i];
+		const v4 = fieldLayout.$.vel[i];
+		const dt = P.dt;
+		const firstFrame = P.snap > .5;
+		const homeW = d.vec2f(__tsover_mul(__tsover_sub(homeU, .5), P.aspect), __tsover_sub(homeV, .5));
+		const off = d.vec2f(p4.x, p4.y);
+		const pw = d.vec3f(__tsover_add(homeW.x, off.x), __tsover_add(homeW.y, off.y), p4.z);
+		const rxv = __tsover_add(__tsover_add(__tsover_mul(P.rowX.x, pw.x), __tsover_mul(P.rowX.y, pw.y)), __tsover_mul(P.rowX.z, pw.z));
+		const ryv = __tsover_add(__tsover_add(__tsover_mul(P.rowY.x, pw.x), __tsover_mul(P.rowY.y, pw.y)), __tsover_mul(P.rowY.z, pw.z));
+		const rzv = __tsover_add(__tsover_add(__tsover_mul(P.rowZ.x, pw.x), __tsover_mul(P.rowZ.y, pw.y)), __tsover_mul(P.rowZ.z, pw.z));
+		const persp = __tsover_div(P.zoom, std.clamp(__tsover_sub(1, __tsover_mul(rzv, PERSP_K)), .35, 2.6));
+		const su = __tsover_add(__tsover_add(.5, __tsover_div(__tsover_mul(rxv, persp), P.aspect)), P.transX);
+		const sv = __tsover_add(__tsover_add(.5, __tsover_mul(ryv, persp)), P.transY);
+		const deltaS = d.vec2f(__tsover_mul(__tsover_sub(su, P.pointerX), P.aspect), __tsover_sub(sv, P.pointerY));
+		const mxy = cursorMagnet(deltaS, P.cursorRadSq, P.cursorForce);
+		const mz = __tsover_mul(cursorFalloff(deltaS, P.cursorRadSq), P.cursorZForce);
+		const cf = d.vec3f(__tsover_add(__tsover_add(__tsover_mul(P.rowX.x, mxy.x), __tsover_mul(P.rowY.x, mxy.y)), __tsover_mul(P.rowZ.x, mz)), __tsover_add(__tsover_add(__tsover_mul(P.rowX.y, mxy.x), __tsover_mul(P.rowY.y, mxy.y)), __tsover_mul(P.rowZ.y, mz)), __tsover_add(__tsover_add(__tsover_mul(P.rowX.z, mxy.x), __tsover_mul(P.rowY.z, mxy.y)), __tsover_mul(P.rowZ.z, mz)));
+		const F = d.vec3f(__tsover_mul(off.x, -STIFF), __tsover_mul(off.y, -STIFF), __tsover_mul(__tsover_sub(targetZ, p4.z), STIFF)).add(cf);
+		let v3 = d.vec3f(v4.x, v4.y, v4.z).add(F.mul(dt)).mul(P.dragMul);
+		const spd = std.length(v3);
+		v3 = v3.mul(__tsover_div(std.min(spd, d.f32(MAX_SPEED)), std.max(spd, 1e-5)));
+		let offN = off.add(d.vec2f(v3.x, v3.y).mul(dt));
+		let curZ = __tsover_add(p4.z, __tsover_mul(v3.z, dt));
+		offN = std.select(offN, d.vec2f(0, 0), firstFrame);
+		curZ = std.select(curZ, targetZ, firstFrame);
+		v3 = std.select(v3, d.vec3f(0, 0, 0), firstFrame);
+		const seed = hash12(d.vec2f(__tsover_add(d.f32(gx), .5), __tsover_add(d.f32(gy), .5)));
+		fieldLayout.$.pos[i] = d.vec4f(offN.x, offN.y, curZ, seed);
+		fieldLayout.$.vel[i] = d.vec4f(v3.x, v3.y, v3.z, 0);
+	}), {
+		v: 1,
+		name: void 0,
+		ast: {
+			"params": [{
+				"type": "i",
+				"name": "gx"
+			}, {
+				"type": "i",
+				"name": "gy"
+			}],
+			"body": [0, [
+				[
+					13,
+					"P",
+					[
+						7,
+						[
+							7,
+							"fieldLayout",
+							"$"
+						],
+						"params"
+					]
+				],
+				[
+					13,
+					"i",
+					[
+						1,
+						[
+							1,
+							"gy",
+							"*",
+							[
+								6,
+								[
+									7,
+									"d",
+									"u32"
+								],
+								[[
+									7,
+									"P",
+									"gridW"
+								]]
+							]
+						],
+						"+",
+						"gx"
+					]
+				],
+				[
+					13,
+					"homeU",
+					[
+						1,
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								["gx"]
+							],
+							"+",
+							[5, "0.5"]
+						],
+						"/",
+						[
+							7,
+							"P",
+							"gridW"
+						]
+					]
+				],
+				[
+					13,
+					"homeV",
+					[
+						1,
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								["gy"]
+							],
+							"+",
+							[5, "0.5"]
+						],
+						"/",
+						[
+							7,
+							"P",
+							"gridH"
+						]
+					]
+				],
+				[
+					13,
+					"dims",
+					[
+						6,
+						[
+							7,
+							"std",
+							"textureDimensions"
+						],
+						[[
+							7,
+							[
+								7,
+								"fieldLayout",
+								"$"
+							],
+							"src"
+						]]
+					]
+				],
+				[
+					13,
+					"sw",
+					[
+						6,
+						[
+							7,
+							"d",
+							"f32"
+						],
+						[[
+							7,
+							"dims",
+							"x"
+						]]
+					]
+				],
+				[
+					13,
+					"sh",
+					[
+						6,
+						[
+							7,
+							"d",
+							"f32"
+						],
+						[[
+							7,
+							"dims",
+							"y"
+						]]
+					]
+				],
+				[
+					13,
+					"cu",
+					[
+						1,
+						[
+							1,
+							"homeU",
+							"*",
+							"sw"
+						],
+						"-",
+						[5, "0.5"]
+					]
+				],
+				[
+					13,
+					"cv",
+					[
+						1,
+						[
+							1,
+							"homeV",
+							"*",
+							"sh"
+						],
+						"-",
+						[5, "0.5"]
+					]
+				],
+				[
+					13,
+					"cx0",
+					[
+						6,
+						[
+							7,
+							"std",
+							"floor"
+						],
+						["cu"]
+					]
+				],
+				[
+					13,
+					"cy0",
+					[
+						6,
+						[
+							7,
+							"std",
+							"floor"
+						],
+						["cv"]
+					]
+				],
+				[
+					13,
+					"fx",
+					[
+						1,
+						"cu",
+						"-",
+						"cx0"
+					]
+				],
+				[
+					13,
+					"fy",
+					[
+						1,
+						"cv",
+						"-",
+						"cy0"
+					]
+				],
+				[
+					13,
+					"ix0",
+					[
+						6,
+						[
+							7,
+							"d",
+							"u32"
+						],
+						[[
+							6,
+							[
+								7,
+								"std",
+								"clamp"
+							],
+							[
+								"cx0",
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									[[5, "0"]]
+								],
+								[
+									1,
+									"sw",
+									"-",
+									[5, "1"]
+								]
+							]
+						]]
+					]
+				],
+				[
+					13,
+					"ix1",
+					[
+						6,
+						[
+							7,
+							"d",
+							"u32"
+						],
+						[[
+							6,
+							[
+								7,
+								"std",
+								"clamp"
+							],
+							[
+								[
+									1,
+									"cx0",
+									"+",
+									[5, "1"]
+								],
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									[[5, "0"]]
+								],
+								[
+									1,
+									"sw",
+									"-",
+									[5, "1"]
+								]
+							]
+						]]
+					]
+				],
+				[
+					13,
+					"iy0",
+					[
+						6,
+						[
+							7,
+							"d",
+							"u32"
+						],
+						[[
+							6,
+							[
+								7,
+								"std",
+								"clamp"
+							],
+							[
+								"cy0",
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									[[5, "0"]]
+								],
+								[
+									1,
+									"sh",
+									"-",
+									[5, "1"]
+								]
+							]
+						]]
+					]
+				],
+				[
+					13,
+					"iy1",
+					[
+						6,
+						[
+							7,
+							"d",
+							"u32"
+						],
+						[[
+							6,
+							[
+								7,
+								"std",
+								"clamp"
+							],
+							[
+								[
+									1,
+									"cy0",
+									"+",
+									[5, "1"]
+								],
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									[[5, "0"]]
+								],
+								[
+									1,
+									"sh",
+									"-",
+									[5, "1"]
+								]
+							]
+						]]
+					]
+				],
+				[
+					13,
+					"c00",
+					[
+						6,
+						[
+							7,
+							"std",
+							"textureLoad"
+						],
+						[
+							[
+								7,
+								[
+									7,
+									"fieldLayout",
+									"$"
+								],
+								"src"
+							],
+							[
+								6,
+								[
+									7,
+									"d",
+									"vec2u"
+								],
+								["ix0", "iy0"]
+							],
+							[5, "0"]
+						]
+					]
+				],
+				[
+					13,
+					"c10",
+					[
+						6,
+						[
+							7,
+							"std",
+							"textureLoad"
+						],
+						[
+							[
+								7,
+								[
+									7,
+									"fieldLayout",
+									"$"
+								],
+								"src"
+							],
+							[
+								6,
+								[
+									7,
+									"d",
+									"vec2u"
+								],
+								["ix1", "iy0"]
+							],
+							[5, "0"]
+						]
+					]
+				],
+				[
+					13,
+					"c01",
+					[
+						6,
+						[
+							7,
+							"std",
+							"textureLoad"
+						],
+						[
+							[
+								7,
+								[
+									7,
+									"fieldLayout",
+									"$"
+								],
+								"src"
+							],
+							[
+								6,
+								[
+									7,
+									"d",
+									"vec2u"
+								],
+								["ix0", "iy1"]
+							],
+							[5, "0"]
+						]
+					]
+				],
+				[
+					13,
+					"c11",
+					[
+						6,
+						[
+							7,
+							"std",
+							"textureLoad"
+						],
+						[
+							[
+								7,
+								[
+									7,
+									"fieldLayout",
+									"$"
+								],
+								"src"
+							],
+							[
+								6,
+								[
+									7,
+									"d",
+									"vec2u"
+								],
+								["ix1", "iy1"]
+							],
+							[5, "0"]
+						]
+					]
+				],
+				[
+					13,
+					"prem",
+					[
+						6,
+						[
+							7,
+							"std",
+							"mix"
+						],
+						[
+							[
+								6,
+								[
+									7,
+									"std",
+									"mix"
+								],
+								[
+									"c00",
+									"c10",
+									"fx"
+								]
+							],
+							[
+								6,
+								[
+									7,
+									"std",
+									"mix"
+								],
+								[
+									"c01",
+									"c11",
+									"fx"
+								]
+							],
+							"fy"
+						]
+					]
+				],
+				[
+					13,
+					"a",
+					[
+						7,
+						"prem",
+						"w"
+					]
+				],
+				[
+					13,
+					"rgb",
+					[
+						6,
+						[
+							7,
+							[
+								7,
+								"prem",
+								"xyz"
+							],
+							"div"
+						],
+						[[
+							6,
+							[
+								7,
+								"std",
+								"max"
+							],
+							["a", [
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[5, "0.0001"]]
+							]]
+						]]
+					]
+				],
+				[
+					2,
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"fieldLayout",
+								"$"
+							],
+							"col"
+						],
+						"i"
+					],
+					"=",
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec4f"
+						],
+						[
+							[
+								7,
+								"rgb",
+								"x"
+							],
+							[
+								7,
+								"rgb",
+								"y"
+							],
+							[
+								7,
+								"rgb",
+								"z"
+							],
+							"a"
+						]
+					]
+				],
+				[
+					13,
+					"ch",
+					[
+						6,
+						"channelFn",
+						["rgb", "a"]
+					]
+				],
+				[
+					13,
+					"targetZ",
+					[
+						1,
+						[
+							1,
+							"ch",
+							"-",
+							[5, "0.5"]
+						],
+						"*",
+						[
+							7,
+							"P",
+							"depth"
+						]
+					]
+				],
+				[
+					13,
+					"p4",
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"fieldLayout",
+								"$"
+							],
+							"pos"
+						],
+						"i"
+					]
+				],
+				[
+					13,
+					"v4",
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"fieldLayout",
+								"$"
+							],
+							"vel"
+						],
+						"i"
+					]
+				],
+				[
+					13,
+					"dt",
+					[
+						7,
+						"P",
+						"dt"
+					]
+				],
+				[
+					13,
+					"firstFrame",
+					[
+						1,
+						[
+							7,
+							"P",
+							"snap"
+						],
+						">",
+						[5, "0.5"]
+					]
+				],
+				[
+					13,
+					"homeW",
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec2f"
+						],
+						[[
+							1,
+							[
+								1,
+								"homeU",
+								"-",
+								[5, "0.5"]
+							],
+							"*",
+							[
+								7,
+								"P",
+								"aspect"
+							]
+						], [
+							1,
+							"homeV",
+							"-",
+							[5, "0.5"]
+						]]
+					]
+				],
+				[
+					13,
+					"off",
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec2f"
+						],
+						[[
+							7,
+							"p4",
+							"x"
+						], [
+							7,
+							"p4",
+							"y"
+						]]
+					]
+				],
+				[
+					13,
+					"pw",
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec3f"
+						],
+						[
+							[
+								1,
+								[
+									7,
+									"homeW",
+									"x"
+								],
+								"+",
+								[
+									7,
+									"off",
+									"x"
+								]
+							],
+							[
+								1,
+								[
+									7,
+									"homeW",
+									"y"
+								],
+								"+",
+								[
+									7,
+									"off",
+									"y"
+								]
+							],
+							[
+								7,
+								"p4",
+								"z"
+							]
+						]
+					]
+				],
+				[
+					13,
+					"rxv",
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									[
+										7,
+										"P",
+										"rowX"
+									],
+									"x"
+								],
+								"*",
+								[
+									7,
+									"pw",
+									"x"
+								]
+							],
+							"+",
+							[
+								1,
+								[
+									7,
+									[
+										7,
+										"P",
+										"rowX"
+									],
+									"y"
+								],
+								"*",
+								[
+									7,
+									"pw",
+									"y"
+								]
+							]
+						],
+						"+",
+						[
+							1,
+							[
+								7,
+								[
+									7,
+									"P",
+									"rowX"
+								],
+								"z"
+							],
+							"*",
+							[
+								7,
+								"pw",
+								"z"
+							]
+						]
+					]
+				],
+				[
+					13,
+					"ryv",
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									[
+										7,
+										"P",
+										"rowY"
+									],
+									"x"
+								],
+								"*",
+								[
+									7,
+									"pw",
+									"x"
+								]
+							],
+							"+",
+							[
+								1,
+								[
+									7,
+									[
+										7,
+										"P",
+										"rowY"
+									],
+									"y"
+								],
+								"*",
+								[
+									7,
+									"pw",
+									"y"
+								]
+							]
+						],
+						"+",
+						[
+							1,
+							[
+								7,
+								[
+									7,
+									"P",
+									"rowY"
+								],
+								"z"
+							],
+							"*",
+							[
+								7,
+								"pw",
+								"z"
+							]
+						]
+					]
+				],
+				[
+					13,
+					"rzv",
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									[
+										7,
+										"P",
+										"rowZ"
+									],
+									"x"
+								],
+								"*",
+								[
+									7,
+									"pw",
+									"x"
+								]
+							],
+							"+",
+							[
+								1,
+								[
+									7,
+									[
+										7,
+										"P",
+										"rowZ"
+									],
+									"y"
+								],
+								"*",
+								[
+									7,
+									"pw",
+									"y"
+								]
+							]
+						],
+						"+",
+						[
+							1,
+							[
+								7,
+								[
+									7,
+									"P",
+									"rowZ"
+								],
+								"z"
+							],
+							"*",
+							[
+								7,
+								"pw",
+								"z"
+							]
+						]
+					]
+				],
+				[
+					13,
+					"persp",
+					[
+						1,
+						[
+							7,
+							"P",
+							"zoom"
+						],
+						"/",
+						[
+							6,
+							[
+								7,
+								"std",
+								"clamp"
+							],
+							[
+								[
+									1,
+									[5, "1"],
+									"-",
+									[
+										1,
+										"rzv",
+										"*",
+										"PERSP_K"
+									]
+								],
+								[5, "0.35"],
+								[5, "2.6"]
+							]
+						]
+					]
+				],
+				[
+					13,
+					"su",
+					[
+						1,
+						[
+							1,
+							[5, "0.5"],
+							"+",
+							[
+								1,
+								[
+									1,
+									"rxv",
+									"*",
+									"persp"
+								],
+								"/",
+								[
+									7,
+									"P",
+									"aspect"
+								]
+							]
+						],
+						"+",
+						[
+							7,
+							"P",
+							"transX"
+						]
+					]
+				],
+				[
+					13,
+					"sv",
+					[
+						1,
+						[
+							1,
+							[5, "0.5"],
+							"+",
+							[
+								1,
+								"ryv",
+								"*",
+								"persp"
+							]
+						],
+						"+",
+						[
+							7,
+							"P",
+							"transY"
+						]
+					]
+				],
+				[
+					13,
+					"deltaS",
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec2f"
+						],
+						[[
+							1,
+							[
+								1,
+								"su",
+								"-",
+								[
+									7,
+									"P",
+									"pointerX"
+								]
+							],
+							"*",
+							[
+								7,
+								"P",
+								"aspect"
+							]
+						], [
+							1,
+							"sv",
+							"-",
+							[
+								7,
+								"P",
+								"pointerY"
+							]
+						]]
+					]
+				],
+				[
+					13,
+					"mxy",
+					[
+						6,
+						[
+							7,
+							"agents",
+							"cursorMagnet"
+						],
+						[
+							"deltaS",
+							[
+								7,
+								"P",
+								"cursorRadSq"
+							],
+							[
+								7,
+								"P",
+								"cursorForce"
+							]
+						]
+					]
+				],
+				[
+					13,
+					"mz",
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"agents",
+								"cursorFalloff"
+							],
+							["deltaS", [
+								7,
+								"P",
+								"cursorRadSq"
+							]]
+						],
+						"*",
+						[
+							7,
+							"P",
+							"cursorZForce"
+						]
+					]
+				],
+				[
+					13,
+					"cf",
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec3f"
+						],
+						[
+							[
+								1,
+								[
+									1,
+									[
+										1,
+										[
+											7,
+											[
+												7,
+												"P",
+												"rowX"
+											],
+											"x"
+										],
+										"*",
+										[
+											7,
+											"mxy",
+											"x"
+										]
+									],
+									"+",
+									[
+										1,
+										[
+											7,
+											[
+												7,
+												"P",
+												"rowY"
+											],
+											"x"
+										],
+										"*",
+										[
+											7,
+											"mxy",
+											"y"
+										]
+									]
+								],
+								"+",
+								[
+									1,
+									[
+										7,
+										[
+											7,
+											"P",
+											"rowZ"
+										],
+										"x"
+									],
+									"*",
+									"mz"
+								]
+							],
+							[
+								1,
+								[
+									1,
+									[
+										1,
+										[
+											7,
+											[
+												7,
+												"P",
+												"rowX"
+											],
+											"y"
+										],
+										"*",
+										[
+											7,
+											"mxy",
+											"x"
+										]
+									],
+									"+",
+									[
+										1,
+										[
+											7,
+											[
+												7,
+												"P",
+												"rowY"
+											],
+											"y"
+										],
+										"*",
+										[
+											7,
+											"mxy",
+											"y"
+										]
+									]
+								],
+								"+",
+								[
+									1,
+									[
+										7,
+										[
+											7,
+											"P",
+											"rowZ"
+										],
+										"y"
+									],
+									"*",
+									"mz"
+								]
+							],
+							[
+								1,
+								[
+									1,
+									[
+										1,
+										[
+											7,
+											[
+												7,
+												"P",
+												"rowX"
+											],
+											"z"
+										],
+										"*",
+										[
+											7,
+											"mxy",
+											"x"
+										]
+									],
+									"+",
+									[
+										1,
+										[
+											7,
+											[
+												7,
+												"P",
+												"rowY"
+											],
+											"z"
+										],
+										"*",
+										[
+											7,
+											"mxy",
+											"y"
+										]
+									]
+								],
+								"+",
+								[
+									1,
+									[
+										7,
+										[
+											7,
+											"P",
+											"rowZ"
+										],
+										"z"
+									],
+									"*",
+									"mz"
+								]
+							]
+						]
+					]
+				],
+				[
+					13,
+					"F",
+					[
+						6,
+						[
+							7,
+							[
+								6,
+								[
+									7,
+									"d",
+									"vec3f"
+								],
+								[
+									[
+										1,
+										[
+											7,
+											"off",
+											"x"
+										],
+										"*",
+										[
+											4,
+											"-",
+											"STIFF"
+										]
+									],
+									[
+										1,
+										[
+											7,
+											"off",
+											"y"
+										],
+										"*",
+										[
+											4,
+											"-",
+											"STIFF"
+										]
+									],
+									[
+										1,
+										[
+											1,
+											"targetZ",
+											"-",
+											[
+												7,
+												"p4",
+												"z"
+											]
+										],
+										"*",
+										"STIFF"
+									]
+								]
+							],
+							"add"
+						],
+						["cf"]
+					]
+				],
+				[
+					12,
+					"v3",
+					[
+						6,
+						[
+							7,
+							[
+								6,
+								[
+									7,
+									[
+										6,
+										[
+											7,
+											"d",
+											"vec3f"
+										],
+										[
+											[
+												7,
+												"v4",
+												"x"
+											],
+											[
+												7,
+												"v4",
+												"y"
+											],
+											[
+												7,
+												"v4",
+												"z"
+											]
+										]
+									],
+									"add"
+								],
+								[[
+									6,
+									[
+										7,
+										"F",
+										"mul"
+									],
+									["dt"]
+								]]
+							],
+							"mul"
+						],
+						[[
+							7,
+							"P",
+							"dragMul"
+						]]
+					]
+				],
+				[
+					13,
+					"spd",
+					[
+						6,
+						[
+							7,
+							"std",
+							"length"
+						],
+						["v3"]
+					]
+				],
+				[
+					2,
+					"v3",
+					"=",
+					[
+						6,
+						[
+							7,
+							"v3",
+							"mul"
+						],
+						[[
+							1,
+							[
+								6,
+								[
+									7,
+									"std",
+									"min"
+								],
+								["spd", [
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									["MAX_SPEED"]
+								]]
+							],
+							"/",
+							[
+								6,
+								[
+									7,
+									"std",
+									"max"
+								],
+								["spd", [5, "0.00001"]]
+							]
+						]]
+					]
+				],
+				[
+					12,
+					"offN",
+					[
+						6,
+						[
+							7,
+							"off",
+							"add"
+						],
+						[[
+							6,
+							[
+								7,
+								[
+									6,
+									[
+										7,
+										"d",
+										"vec2f"
+									],
+									[[
+										7,
+										"v3",
+										"x"
+									], [
+										7,
+										"v3",
+										"y"
+									]]
+								],
+								"mul"
+							],
+							["dt"]
+						]]
+					]
+				],
+				[
+					12,
+					"curZ",
+					[
+						1,
+						[
+							7,
+							"p4",
+							"z"
+						],
+						"+",
+						[
+							1,
+							[
+								7,
+								"v3",
+								"z"
+							],
+							"*",
+							"dt"
+						]
+					]
+				],
+				[
+					2,
+					"offN",
+					"=",
+					[
+						6,
+						[
+							7,
+							"std",
+							"select"
+						],
+						[
+							"offN",
+							[
+								6,
+								[
+									7,
+									"d",
+									"vec2f"
+								],
+								[[5, "0"], [5, "0"]]
+							],
+							"firstFrame"
+						]
+					]
+				],
+				[
+					2,
+					"curZ",
+					"=",
+					[
+						6,
+						[
+							7,
+							"std",
+							"select"
+						],
+						[
+							"curZ",
+							"targetZ",
+							"firstFrame"
+						]
+					]
+				],
+				[
+					2,
+					"v3",
+					"=",
+					[
+						6,
+						[
+							7,
+							"std",
+							"select"
+						],
+						[
+							"v3",
+							[
+								6,
+								[
+									7,
+									"d",
+									"vec3f"
+								],
+								[
+									[5, "0"],
+									[5, "0"],
+									[5, "0"]
+								]
+							],
+							"firstFrame"
+						]
+					]
+				],
+				[
+					13,
+					"seed",
+					[
+						6,
+						[
+							7,
+							"noise",
+							"hash12"
+						],
+						[[
+							6,
+							[
+								7,
+								"d",
+								"vec2f"
+							],
+							[[
+								1,
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									["gx"]
+								],
+								"+",
+								[5, "0.5"]
+							], [
+								1,
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									["gy"]
+								],
+								"+",
+								[5, "0.5"]
+							]]
+						]]
+					]
+				],
+				[
+					2,
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"fieldLayout",
+								"$"
+							],
+							"pos"
+						],
+						"i"
+					],
+					"=",
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec4f"
+						],
+						[
+							[
+								7,
+								"offN",
+								"x"
+							],
+							[
+								7,
+								"offN",
+								"y"
+							],
+							"curZ",
+							"seed"
+						]
+					]
+				],
+				[
+					2,
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"fieldLayout",
+								"$"
+							],
+							"vel"
+						],
+						"i"
+					],
+					"=",
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec4f"
+						],
+						[
+							[
+								7,
+								"v3",
+								"x"
+							],
+							[
+								7,
+								"v3",
+								"y"
+							],
+							[
+								7,
+								"v3",
+								"z"
+							],
+							[5, "0"]
+						]
+					]
+				]
+			]],
+			"externalNames": [
+				"fieldLayout",
+				"d",
+				"std",
+				"channelFn",
+				"PERSP_K",
+				"agents",
+				"STIFF",
+				"MAX_SPEED",
+				"noise"
+			]
+		},
+		externals: () => ({
+			fieldLayout,
+			d,
+			std,
+			channelFn,
+			PERSP_K,
+			agents: agents_exports,
+			STIFF,
+			MAX_SPEED,
+			noise: noise_exports
+		})
+	}) && $.f)({})).$name("particleFieldSim");
+}
+function makeParticleFieldSplatKernel(shape) {
+	const name = resolveAgentShape(shape, "dot");
+	const s = AGENT_SHAPES[name];
+	const weightFn = makeAgentWeightFn(name);
+	const SOFT = s.soft;
+	const EXTQ = s.ext * s.ext + .75;
+	return tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((gx, gy) => {
+		"use gpu";
+		const P = fieldLayout.$.params;
+		const i = __tsover_add(__tsover_mul(gy, d.u32(P.gridW)), gx);
+		const p4 = fieldLayout.$.pos[i];
+		const col = fieldLayout.$.col[i];
+		const childA = col.w;
+		const homeU = __tsover_div(__tsover_add(d.f32(gx), .5), P.gridW);
+		const homeV = __tsover_div(__tsover_add(d.f32(gy), .5), P.gridH);
+		const ph = __tsover_mul(p4.w, TAU);
+		const wob = P.wobbleAmp;
+		const wx = __tsover_mul(__tsover_mul(std.sin(__tsover_add(__tsover_mul(P.time, WOBBLE_FREQ), ph)), wob), .012);
+		const wy = __tsover_mul(__tsover_mul(std.cos(__tsover_add(__tsover_mul(__tsover_mul(P.time, WOBBLE_FREQ), 1.13), __tsover_mul(ph, 1.7))), wob), .012);
+		const wz = __tsover_mul(__tsover_mul(std.sin(__tsover_add(__tsover_mul(__tsover_mul(P.time, WOBBLE_FREQ), .87), __tsover_mul(ph, 2.3))), wob), .06);
+		const pw = d.vec3f(__tsover_add(__tsover_add(__tsover_mul(__tsover_sub(homeU, .5), P.aspect), p4.x), wx), __tsover_add(__tsover_add(__tsover_sub(homeV, .5), p4.y), wy), __tsover_add(p4.z, wz));
+		const rx = __tsover_add(__tsover_add(__tsover_mul(P.rowX.x, pw.x), __tsover_mul(P.rowX.y, pw.y)), __tsover_mul(P.rowX.z, pw.z));
+		const ry = __tsover_add(__tsover_add(__tsover_mul(P.rowY.x, pw.x), __tsover_mul(P.rowY.y, pw.y)), __tsover_mul(P.rowY.z, pw.z));
+		const rz = __tsover_add(__tsover_add(__tsover_mul(P.rowZ.x, pw.x), __tsover_mul(P.rowZ.y, pw.y)), __tsover_mul(P.rowZ.z, pw.z));
+		const persp0 = __tsover_div(1, std.clamp(__tsover_sub(1, __tsover_mul(rz, PERSP_K)), .35, 2.6));
+		const persp = __tsover_mul(persp0, P.zoom);
+		const su = __tsover_add(__tsover_add(.5, __tsover_div(__tsover_mul(rx, persp), P.aspect)), P.transX);
+		const sv = __tsover_add(__tsover_add(.5, __tsover_mul(ry, persp)), P.transY);
+		const tx = __tsover_mul(su, P.outW);
+		const ty = __tsover_mul(sv, P.outH);
+		const dotR = std.clamp(__tsover_mul(__tsover_mul(__tsover_mul(P.particleSize, P.spacing), .5), persp), .5, d.f32(SPLAT_R));
+		const dr = std.max(P.depth, .001);
+		const near = std.smoothstep(__tsover_mul(dr, -1), dr, rz);
+		const shade = std.mix(d.f32(1), __tsover_add(.35, __tsover_mul(.65, near)), P.depthShading);
+		const depthWeight = __tsover_mul(__tsover_mul(persp0, persp0), shade);
+		const owI = d.i32(P.outW);
+		const ohI = d.i32(P.outH);
+		const owU = d.u32(P.outW);
+		const cxi = d.i32(std.floor(tx));
+		const cyi = d.i32(std.floor(ty));
+		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 < owI && py >= 0 && py < ohI) {
+				const ddx = __tsover_sub(__tsover_add(d.f32(px), .5), tx);
+				const ddy = __tsover_sub(__tsover_add(d.f32(py), .5), ty);
+				if (__tsover_div(__tsover_add(__tsover_mul(ddx, ddx), __tsover_mul(ddy, ddy)), std.max(__tsover_mul(dotR, dotR), .01)) < d.f32(EXTQ)) {
+					const w = weightFn(ddx, ddy, dotR, .75, d.f32(SOFT));
+					const wc = __tsover_mul(__tsover_mul(w, childA), depthWeight);
+					if (wc > 0) {
+						const idx = __tsover_add(__tsover_mul(d.u32(py), owU), d.u32(px));
+						std.atomicAdd(fieldLayout.$.accumR[idx], d.u32(__tsover_mul(__tsover_mul(col.x, wc), FP)));
+						std.atomicAdd(fieldLayout.$.accumG[idx], d.u32(__tsover_mul(__tsover_mul(col.y, wc), FP)));
+						std.atomicAdd(fieldLayout.$.accumB[idx], d.u32(__tsover_mul(__tsover_mul(col.z, wc), FP)));
+						std.atomicAdd(fieldLayout.$.accumW[idx], d.u32(__tsover_mul(wc, FP)));
+					}
+				}
+			}
+		}
+	}), {
+		v: 1,
+		name: void 0,
+		ast: {
+			"params": [{
+				"type": "i",
+				"name": "gx"
+			}, {
+				"type": "i",
+				"name": "gy"
+			}],
+			"body": [0, [
+				[
+					13,
+					"P",
+					[
+						7,
+						[
+							7,
+							"fieldLayout",
+							"$"
+						],
+						"params"
+					]
+				],
+				[
+					13,
+					"i",
+					[
+						1,
+						[
+							1,
+							"gy",
+							"*",
+							[
+								6,
+								[
+									7,
+									"d",
+									"u32"
+								],
+								[[
+									7,
+									"P",
+									"gridW"
+								]]
+							]
+						],
+						"+",
+						"gx"
+					]
+				],
+				[
+					13,
+					"p4",
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"fieldLayout",
+								"$"
+							],
+							"pos"
+						],
+						"i"
+					]
+				],
+				[
+					13,
+					"col",
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"fieldLayout",
+								"$"
+							],
+							"col"
+						],
+						"i"
+					]
+				],
+				[
+					13,
+					"childA",
+					[
+						7,
+						"col",
+						"w"
+					]
+				],
+				[
+					13,
+					"homeU",
+					[
+						1,
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								["gx"]
+							],
+							"+",
+							[5, "0.5"]
+						],
+						"/",
+						[
+							7,
+							"P",
+							"gridW"
+						]
+					]
+				],
+				[
+					13,
+					"homeV",
+					[
+						1,
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								["gy"]
+							],
+							"+",
+							[5, "0.5"]
+						],
+						"/",
+						[
+							7,
+							"P",
+							"gridH"
+						]
+					]
+				],
+				[
+					13,
+					"ph",
+					[
+						1,
+						[
+							7,
+							"p4",
+							"w"
+						],
+						"*",
+						"TAU"
+					]
+				],
+				[
+					13,
+					"wob",
+					[
+						7,
+						"P",
+						"wobbleAmp"
+					]
+				],
+				[
+					13,
+					"wx",
+					[
+						1,
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"std",
+									"sin"
+								],
+								[[
+									1,
+									[
+										1,
+										[
+											7,
+											"P",
+											"time"
+										],
+										"*",
+										"WOBBLE_FREQ"
+									],
+									"+",
+									"ph"
+								]]
+							],
+							"*",
+							"wob"
+						],
+						"*",
+						[5, "0.012"]
+					]
+				],
+				[
+					13,
+					"wy",
+					[
+						1,
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"std",
+									"cos"
+								],
+								[[
+									1,
+									[
+										1,
+										[
+											1,
+											[
+												7,
+												"P",
+												"time"
+											],
+											"*",
+											"WOBBLE_FREQ"
+										],
+										"*",
+										[5, "1.13"]
+									],
+									"+",
+									[
+										1,
+										"ph",
+										"*",
+										[5, "1.7"]
+									]
+								]]
+							],
+							"*",
+							"wob"
+						],
+						"*",
+						[5, "0.012"]
+					]
+				],
+				[
+					13,
+					"wz",
+					[
+						1,
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"std",
+									"sin"
+								],
+								[[
+									1,
+									[
+										1,
+										[
+											1,
+											[
+												7,
+												"P",
+												"time"
+											],
+											"*",
+											"WOBBLE_FREQ"
+										],
+										"*",
+										[5, "0.87"]
+									],
+									"+",
+									[
+										1,
+										"ph",
+										"*",
+										[5, "2.3"]
+									]
+								]]
+							],
+							"*",
+							"wob"
+						],
+						"*",
+						[5, "0.06"]
+					]
+				],
+				[
+					13,
+					"pw",
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec3f"
+						],
+						[
+							[
+								1,
+								[
+									1,
+									[
+										1,
+										[
+											1,
+											"homeU",
+											"-",
+											[5, "0.5"]
+										],
+										"*",
+										[
+											7,
+											"P",
+											"aspect"
+										]
+									],
+									"+",
+									[
+										7,
+										"p4",
+										"x"
+									]
+								],
+								"+",
+								"wx"
+							],
+							[
+								1,
+								[
+									1,
+									[
+										1,
+										"homeV",
+										"-",
+										[5, "0.5"]
+									],
+									"+",
+									[
+										7,
+										"p4",
+										"y"
+									]
+								],
+								"+",
+								"wy"
+							],
+							[
+								1,
+								[
+									7,
+									"p4",
+									"z"
+								],
+								"+",
+								"wz"
+							]
+						]
+					]
+				],
+				[
+					13,
+					"rx",
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									[
+										7,
+										"P",
+										"rowX"
+									],
+									"x"
+								],
+								"*",
+								[
+									7,
+									"pw",
+									"x"
+								]
+							],
+							"+",
+							[
+								1,
+								[
+									7,
+									[
+										7,
+										"P",
+										"rowX"
+									],
+									"y"
+								],
+								"*",
+								[
+									7,
+									"pw",
+									"y"
+								]
+							]
+						],
+						"+",
+						[
+							1,
+							[
+								7,
+								[
+									7,
+									"P",
+									"rowX"
+								],
+								"z"
+							],
+							"*",
+							[
+								7,
+								"pw",
+								"z"
+							]
+						]
+					]
+				],
+				[
+					13,
+					"ry",
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									[
+										7,
+										"P",
+										"rowY"
+									],
+									"x"
+								],
+								"*",
+								[
+									7,
+									"pw",
+									"x"
+								]
+							],
+							"+",
+							[
+								1,
+								[
+									7,
+									[
+										7,
+										"P",
+										"rowY"
+									],
+									"y"
+								],
+								"*",
+								[
+									7,
+									"pw",
+									"y"
+								]
+							]
+						],
+						"+",
+						[
+							1,
+							[
+								7,
+								[
+									7,
+									"P",
+									"rowY"
+								],
+								"z"
+							],
+							"*",
+							[
+								7,
+								"pw",
+								"z"
+							]
+						]
+					]
+				],
+				[
+					13,
+					"rz",
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									[
+										7,
+										"P",
+										"rowZ"
+									],
+									"x"
+								],
+								"*",
+								[
+									7,
+									"pw",
+									"x"
+								]
+							],
+							"+",
+							[
+								1,
+								[
+									7,
+									[
+										7,
+										"P",
+										"rowZ"
+									],
+									"y"
+								],
+								"*",
+								[
+									7,
+									"pw",
+									"y"
+								]
+							]
+						],
+						"+",
+						[
+							1,
+							[
+								7,
+								[
+									7,
+									"P",
+									"rowZ"
+								],
+								"z"
+							],
+							"*",
+							[
+								7,
+								"pw",
+								"z"
+							]
+						]
+					]
+				],
+				[
+					13,
+					"persp0",
+					[
+						1,
+						[5, "1"],
+						"/",
+						[
+							6,
+							[
+								7,
+								"std",
+								"clamp"
+							],
+							[
+								[
+									1,
+									[5, "1"],
+									"-",
+									[
+										1,
+										"rz",
+										"*",
+										"PERSP_K"
+									]
+								],
+								[5, "0.35"],
+								[5, "2.6"]
+							]
+						]
+					]
+				],
+				[
+					13,
+					"persp",
+					[
+						1,
+						"persp0",
+						"*",
+						[
+							7,
+							"P",
+							"zoom"
+						]
+					]
+				],
+				[
+					13,
+					"su",
+					[
+						1,
+						[
+							1,
+							[5, "0.5"],
+							"+",
+							[
+								1,
+								[
+									1,
+									"rx",
+									"*",
+									"persp"
+								],
+								"/",
+								[
+									7,
+									"P",
+									"aspect"
+								]
+							]
+						],
+						"+",
+						[
+							7,
+							"P",
+							"transX"
+						]
+					]
+				],
+				[
+					13,
+					"sv",
+					[
+						1,
+						[
+							1,
+							[5, "0.5"],
+							"+",
+							[
+								1,
+								"ry",
+								"*",
+								"persp"
+							]
+						],
+						"+",
+						[
+							7,
+							"P",
+							"transY"
+						]
+					]
+				],
+				[
+					13,
+					"tx",
+					[
+						1,
+						"su",
+						"*",
+						[
+							7,
+							"P",
+							"outW"
+						]
+					]
+				],
+				[
+					13,
+					"ty",
+					[
+						1,
+						"sv",
+						"*",
+						[
+							7,
+							"P",
+							"outH"
+						]
+					]
+				],
+				[
+					13,
+					"dotR",
+					[
+						6,
+						[
+							7,
+							"std",
+							"clamp"
+						],
+						[
+							[
+								1,
+								[
+									1,
+									[
+										1,
+										[
+											7,
+											"P",
+											"particleSize"
+										],
+										"*",
+										[
+											7,
+											"P",
+											"spacing"
+										]
+									],
+									"*",
+									[5, "0.5"]
+								],
+								"*",
+								"persp"
+							],
+							[5, "0.5"],
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								["SPLAT_R"]
+							]
+						]
+					]
+				],
+				[
+					13,
+					"dr",
+					[
+						6,
+						[
+							7,
+							"std",
+							"max"
+						],
+						[[
+							7,
+							"P",
+							"depth"
+						], [5, "0.001"]]
+					]
+				],
+				[
+					13,
+					"near",
+					[
+						6,
+						[
+							7,
+							"std",
+							"smoothstep"
+						],
+						[
+							[
+								1,
+								"dr",
+								"*",
+								[
+									4,
+									"-",
+									[5, "1"]
+								]
+							],
+							"dr",
+							"rz"
+						]
+					]
+				],
+				[
+					13,
+					"shade",
+					[
+						6,
+						[
+							7,
+							"std",
+							"mix"
+						],
+						[
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[5, "1"]]
+							],
+							[
+								1,
+								[5, "0.35"],
+								"+",
+								[
+									1,
+									[5, "0.65"],
+									"*",
+									"near"
+								]
+							],
+							[
+								7,
+								"P",
+								"depthShading"
+							]
+						]
+					]
+				],
+				[
+					13,
+					"depthWeight",
+					[
+						1,
+						[
+							1,
+							"persp0",
+							"*",
+							"persp0"
+						],
+						"*",
+						"shade"
+					]
+				],
+				[
+					13,
+					"owI",
+					[
+						6,
+						[
+							7,
+							"d",
+							"i32"
+						],
+						[[
+							7,
+							"P",
+							"outW"
+						]]
+					]
+				],
+				[
+					13,
+					"ohI",
+					[
+						6,
+						[
+							7,
+							"d",
+							"i32"
+						],
+						[[
+							7,
+							"P",
+							"outH"
+						]]
+					]
+				],
+				[
+					13,
+					"owU",
+					[
+						6,
+						[
+							7,
+							"d",
+							"u32"
+						],
+						[[
+							7,
+							"P",
+							"outW"
+						]]
+					]
+				],
+				[
+					13,
+					"cxi",
+					[
+						6,
+						[
+							7,
+							"d",
+							"i32"
+						],
+						[[
+							6,
+							[
+								7,
+								"std",
+								"floor"
+							],
+							["tx"]
+						]]
+					]
+				],
+				[
+					13,
+					"cyi",
+					[
+						6,
+						[
+							7,
+							"d",
+							"i32"
+						],
+						[[
+							6,
+							[
+								7,
+								"std",
+								"floor"
+							],
+							["ty"]
+						]]
+					]
+				],
+				[
+					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",
+												"<",
+												"owI"
+											]
+										],
+										"&&",
+										[
+											1,
+											"py",
+											">=",
+											[5, "0"]
+										]
+									],
+									"&&",
+									[
+										1,
+										"py",
+										"<",
+										"ohI"
+									]
+								],
+								[0, [
+									[
+										13,
+										"ddx",
+										[
+											1,
+											[
+												1,
+												[
+													6,
+													[
+														7,
+														"d",
+														"f32"
+													],
+													["px"]
+												],
+												"+",
+												[5, "0.5"]
+											],
+											"-",
+											"tx"
+										]
+									],
+									[
+										13,
+										"ddy",
+										[
+											1,
+											[
+												1,
+												[
+													6,
+													[
+														7,
+														"d",
+														"f32"
+													],
+													["py"]
+												],
+												"+",
+												[5, "0.5"]
+											],
+											"-",
+											"ty"
+										]
+									],
+									[
+										13,
+										"q",
+										[
+											1,
+											[
+												1,
+												[
+													1,
+													"ddx",
+													"*",
+													"ddx"
+												],
+												"+",
+												[
+													1,
+													"ddy",
+													"*",
+													"ddy"
+												]
+											],
+											"/",
+											[
+												6,
+												[
+													7,
+													"std",
+													"max"
+												],
+												[[
+													1,
+													"dotR",
+													"*",
+													"dotR"
+												], [5, "0.01"]]
+											]
+										]
+									],
+									[
+										11,
+										[
+											1,
+											"q",
+											"<",
+											[
+												6,
+												[
+													7,
+													"d",
+													"f32"
+												],
+												["EXTQ"]
+											]
+										],
+										[0, [
+											[
+												13,
+												"w",
+												[
+													6,
+													"weightFn",
+													[
+														"ddx",
+														"ddy",
+														"dotR",
+														[5, "0.75"],
+														[
+															6,
+															[
+																7,
+																"d",
+																"f32"
+															],
+															["SOFT"]
+														]
+													]
+												]
+											],
+											[
+												13,
+												"wc",
+												[
+													1,
+													[
+														1,
+														"w",
+														"*",
+														"childA"
+													],
+													"*",
+													"depthWeight"
+												]
+											],
+											[
+												11,
+												[
+													1,
+													"wc",
+													">",
+													[5, "0"]
+												],
+												[0, [
+													[
+														13,
+														"idx",
+														[
+															1,
+															[
+																1,
+																[
+																	6,
+																	[
+																		7,
+																		"d",
+																		"u32"
+																	],
+																	["py"]
+																],
+																"*",
+																"owU"
+															],
+															"+",
+															[
+																6,
+																[
+																	7,
+																	"d",
+																	"u32"
+																],
+																["px"]
+															]
+														]
+													],
+													[
+														6,
+														[
+															7,
+															"std",
+															"atomicAdd"
+														],
+														[[
+															8,
+															[
+																7,
+																[
+																	7,
+																	"fieldLayout",
+																	"$"
+																],
+																"accumR"
+															],
+															"idx"
+														], [
+															6,
+															[
+																7,
+																"d",
+																"u32"
+															],
+															[[
+																1,
+																[
+																	1,
+																	[
+																		7,
+																		"col",
+																		"x"
+																	],
+																	"*",
+																	"wc"
+																],
+																"*",
+																"FP"
+															]]
+														]]
+													],
+													[
+														6,
+														[
+															7,
+															"std",
+															"atomicAdd"
+														],
+														[[
+															8,
+															[
+																7,
+																[
+																	7,
+																	"fieldLayout",
+																	"$"
+																],
+																"accumG"
+															],
+															"idx"
+														], [
+															6,
+															[
+																7,
+																"d",
+																"u32"
+															],
+															[[
+																1,
+																[
+																	1,
+																	[
+																		7,
+																		"col",
+																		"y"
+																	],
+																	"*",
+																	"wc"
+																],
+																"*",
+																"FP"
+															]]
+														]]
+													],
+													[
+														6,
+														[
+															7,
+															"std",
+															"atomicAdd"
+														],
+														[[
+															8,
+															[
+																7,
+																[
+																	7,
+																	"fieldLayout",
+																	"$"
+																],
+																"accumB"
+															],
+															"idx"
+														], [
+															6,
+															[
+																7,
+																"d",
+																"u32"
+															],
+															[[
+																1,
+																[
+																	1,
+																	[
+																		7,
+																		"col",
+																		"z"
+																	],
+																	"*",
+																	"wc"
+																],
+																"*",
+																"FP"
+															]]
+														]]
+													],
+													[
+														6,
+														[
+															7,
+															"std",
+															"atomicAdd"
+														],
+														[[
+															8,
+															[
+																7,
+																[
+																	7,
+																	"fieldLayout",
+																	"$"
+																],
+																"accumW"
+															],
+															"idx"
+														], [
+															6,
+															[
+																7,
+																"d",
+																"u32"
+															],
+															[[
+																1,
+																"wc",
+																"*",
+																"FP"
+															]]
+														]]
+													]
+												]]
+											]
+										]]
+									]
+								]]
+							]
+						]]
+					]]]
+				]
+			]],
+			"externalNames": [
+				"fieldLayout",
+				"d",
+				"TAU",
+				"std",
+				"WOBBLE_FREQ",
+				"PERSP_K",
+				"SPLAT_R",
+				"SPLAT_WIN",
+				"EXTQ",
+				"weightFn",
+				"SOFT",
+				"FP"
+			]
+		},
+		externals: () => ({
+			fieldLayout,
+			d,
+			TAU,
+			std,
+			WOBBLE_FREQ,
+			PERSP_K,
+			SPLAT_R,
+			SPLAT_WIN,
+			EXTQ,
+			weightFn,
+			SOFT,
+			FP
+		})
+	}) && $.f)({})).$name("particleFieldSplat");
+}
+const particleFieldSplatKernel = makeParticleFieldSplatKernel("dot");
+const particleFieldResolveKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x, y) => {
+	"use gpu";
+	const P = fieldLayout.$.params;
+	const idx = __tsover_add(__tsover_mul(y, d.u32(P.outW)), x);
+	const wRaw = d.f32(std.atomicLoad(fieldLayout.$.accumW[idx]));
+	const rRaw = d.f32(std.atomicLoad(fieldLayout.$.accumR[idx]));
+	const gRaw = d.f32(std.atomicLoad(fieldLayout.$.accumG[idx]));
+	const bRaw = d.f32(std.atomicLoad(fieldLayout.$.accumB[idx]));
+	const denom = std.max(wRaw, d.f32(1));
+	const r = __tsover_div(rRaw, denom);
+	const g = __tsover_div(gRaw, denom);
+	const b = __tsover_div(bRaw, denom);
+	const alpha = __tsover_sub(1, std.exp(__tsover_mul(__tsover_mul(wRaw, __tsover_div(1, FP)), -ALPHA_K)));
+	std.textureStore(fieldLayout.$.outTex, d.vec2u(x, y), d.vec4f(r, g, b, alpha));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "x"
+		}, {
+			"type": "i",
+			"name": "y"
+		}],
+		"body": [0, [
+			[
+				13,
+				"P",
+				[
+					7,
+					[
+						7,
+						"fieldLayout",
+						"$"
+					],
+					"params"
+				]
+			],
+			[
+				13,
+				"idx",
+				[
+					1,
+					[
+						1,
+						"y",
+						"*",
+						[
+							6,
+							[
+								7,
+								"d",
+								"u32"
+							],
+							[[
+								7,
+								"P",
+								"outW"
+							]]
+						]
+					],
+					"+",
+					"x"
+				]
+			],
+			[
+				13,
+				"wRaw",
+				[
+					6,
+					[
+						7,
+						"d",
+						"f32"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"atomicLoad"
+						],
+						[[
+							8,
+							[
+								7,
+								[
+									7,
+									"fieldLayout",
+									"$"
+								],
+								"accumW"
+							],
+							"idx"
+						]]
+					]]
+				]
+			],
+			[
+				13,
+				"rRaw",
+				[
+					6,
+					[
+						7,
+						"d",
+						"f32"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"atomicLoad"
+						],
+						[[
+							8,
+							[
+								7,
+								[
+									7,
+									"fieldLayout",
+									"$"
+								],
+								"accumR"
+							],
+							"idx"
+						]]
+					]]
+				]
+			],
+			[
+				13,
+				"gRaw",
+				[
+					6,
+					[
+						7,
+						"d",
+						"f32"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"atomicLoad"
+						],
+						[[
+							8,
+							[
+								7,
+								[
+									7,
+									"fieldLayout",
+									"$"
+								],
+								"accumG"
+							],
+							"idx"
+						]]
+					]]
+				]
+			],
+			[
+				13,
+				"bRaw",
+				[
+					6,
+					[
+						7,
+						"d",
+						"f32"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"atomicLoad"
+						],
+						[[
+							8,
+							[
+								7,
+								[
+									7,
+									"fieldLayout",
+									"$"
+								],
+								"accumB"
+							],
+							"idx"
+						]]
+					]]
+				]
+			],
+			[
+				13,
+				"denom",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					["wRaw", [
+						6,
+						[
+							7,
+							"d",
+							"f32"
+						],
+						[[5, "1"]]
+					]]
+				]
+			],
+			[
+				13,
+				"r",
+				[
+					1,
+					"rRaw",
+					"/",
+					"denom"
+				]
+			],
+			[
+				13,
+				"g",
+				[
+					1,
+					"gRaw",
+					"/",
+					"denom"
+				]
+			],
+			[
+				13,
+				"b",
+				[
+					1,
+					"bRaw",
+					"/",
+					"denom"
+				]
+			],
+			[
+				13,
+				"alpha",
+				[
+					1,
+					[5, "1"],
+					"-",
+					[
+						6,
+						[
+							7,
+							"std",
+							"exp"
+						],
+						[[
+							1,
+							[
+								1,
+								"wRaw",
+								"*",
+								[
+									1,
+									[5, "1"],
+									"/",
+									"FP"
+								]
+							],
+							"*",
+							[
+								4,
+								"-",
+								"ALPHA_K"
+							]
+						]]
+					]
+				]
+			],
+			[
+				6,
+				[
+					7,
+					"std",
+					"textureStore"
+				],
+				[
+					[
+						7,
+						[
+							7,
+							"fieldLayout",
+							"$"
+						],
+						"outTex"
+					],
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec2u"
+						],
+						["x", "y"]
+					],
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec4f"
+						],
+						[
+							"r",
+							"g",
+							"b",
+							"alpha"
+						]
+					]
+				]
+			]
+		]],
+		"externalNames": [
+			"fieldLayout",
+			"d",
+			"std",
+			"FP",
+			"ALPHA_K"
+		]
+	},
+	externals: () => ({
+		fieldLayout,
+		d,
+		std,
+		FP,
+		ALPHA_K
+	})
+}) && $.f)({})).$name("particleFieldResolve");
+const componentDefinition = {
+	name: "ParticleField",
+	boundingBoxDeclaration: { aspectRatio: null },
+	category: "Stylize",
+	description: "Explodes the child content into a breathing 3D field of particles — bright areas float toward you and dark areas recede, the whole relief can be orbited with the camera rotations, and the cursor physically throws particles that spring back home",
+	requiresRTT: true,
+	requiresChild: true,
+	usesPointer: true,
+	props: {
+		count: {
+			default: 15e3,
+			description: "Number of particles — how finely the child is sampled into the field",
+			ui: {
+				type: "range",
+				min: 1e3,
+				max: COUNT_MAX,
+				step: 500,
+				label: "Count",
+				group: "Field"
+			}
+		},
+		depthSource: {
+			default: "luminance",
+			compileTime: true,
+			description: "Which channel of the child drives each particle's depth toward or away from the camera",
+			ui: {
+				type: "select",
+				options: [
+					{
+						value: "luminance",
+						label: "Luminance"
+					},
+					{
+						value: "luminanceInverted",
+						label: "Luminance (Inverted)"
+					},
+					{
+						value: "red",
+						label: "Red"
+					},
+					{
+						value: "green",
+						label: "Green"
+					},
+					{
+						value: "blue",
+						label: "Blue"
+					},
+					{
+						value: "saturation",
+						label: "Saturation"
+					},
+					{
+						value: "alpha",
+						label: "Alpha"
+					}
+				],
+				label: "Depth Source",
+				group: "Field"
+			}
+		},
+		depth: {
+			default: .7,
+			description: "Depth of the relief — how far bright and dark areas rise toward and sink away from the camera",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 2,
+				step: .01,
+				label: "Depth",
+				group: "Field"
+			}
+		},
+		particleShape: {
+			default: "dot",
+			compileTime: true,
+			description: "What each particle is drawn as — a crisp dot or square, or a soft glow puff",
+			ui: {
+				type: "select",
+				options: pointShapeOptions,
+				label: "Shape",
+				group: "Look"
+			}
+		},
+		particleSize: {
+			default: .75,
+			description: "Size of each particle relative to the grid spacing",
+			ui: {
+				type: ["range", "map"],
+				min: .3,
+				max: 3,
+				step: .01,
+				label: "Particle Size",
+				group: "Look"
+			}
+		},
+		depthShading: {
+			default: .6,
+			description: "How much far particles dim into the distance — the main cue that sells the 3D relief",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Depth Shading",
+				group: "Look"
+			}
+		},
+		wobble: {
+			default: .35,
+			description: "Gentle idle drift that keeps the field breathing even on a still image",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Wobble",
+				group: "Motion"
+			}
+		},
+		zoom: {
+			default: 1,
+			description: "Camera distance — dolly the whole field closer or further away",
+			ui: {
+				type: ["range", "map"],
+				min: .3,
+				max: 2.5,
+				step: .01,
+				label: "Zoom",
+				group: "Camera"
+			}
+		},
+		rotationX: {
+			default: 0,
+			description: "Camera orbit around the horizontal axis — tilt the relief toward or away from you",
+			ui: {
+				type: ["range", "map"],
+				min: -180,
+				max: 180,
+				step: 1,
+				label: "Rotate X",
+				group: "Camera"
+			}
+		},
+		rotationY: {
+			default: 0,
+			description: "Camera orbit around the vertical axis — view the particle extrusion from the side",
+			ui: {
+				type: ["range", "map"],
+				min: -180,
+				max: 180,
+				step: 1,
+				label: "Rotate Y",
+				group: "Camera"
+			}
+		},
+		rotationZ: {
+			default: 0,
+			description: "Camera roll around the view axis",
+			ui: {
+				type: ["range", "map"],
+				min: -180,
+				max: 180,
+				step: 1,
+				label: "Rotate Z",
+				group: "Camera"
+			}
+		},
+		offsetX: {
+			default: 0,
+			description: "Shift the whole field horizontally across the frame (in screen widths)",
+			ui: {
+				type: ["range", "map"],
+				min: -1,
+				max: 1,
+				step: .01,
+				label: "Offset X",
+				group: "Camera"
+			}
+		},
+		offsetY: {
+			default: 0,
+			description: "Shift the whole field vertically across the frame (in screen heights) — tilt it flat, then sink it toward the bottom like a ground plane",
+			ui: {
+				type: ["range", "map"],
+				min: -1,
+				max: 1,
+				step: .01,
+				label: "Offset Y",
+				group: "Camera"
+			}
+		},
+		cursorMode: {
+			default: "push",
+			description: "How the cursor disturbs the field — push throws particles away and toward you, pull gathers them in",
+			ui: {
+				type: "select",
+				options: [
+					{
+						value: "none",
+						label: "None"
+					},
+					{
+						value: "push",
+						label: "Push"
+					},
+					{
+						value: "pull",
+						label: "Pull"
+					}
+				],
+				label: "Cursor Mode",
+				group: "Interaction"
+			}
+		},
+		cursorStrength: {
+			default: .8,
+			description: "Strength of the cursor force — how hard particles get thrown before springing back",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 2,
+				step: .01,
+				label: "Cursor Strength",
+				group: "Interaction"
+			}
+		},
+		cursorRadius: {
+			default: .2,
+			description: "Reach of the cursor field, in screen units",
+			ui: {
+				type: "range",
+				min: .05,
+				max: 1,
+				step: .01,
+				label: "Cursor Radius",
+				group: "Interaction"
+			}
+		}
+	},
+	compute: (params) => {
+		const { childNode, gpu, registerComputeTexture, convertToTexture, getCpuValue, onCleanup, dimensions } = params;
+		if (!childNode) return null;
+		const root = gpu?.root;
+		if (!root) return null;
+		const childTexture = convertToTexture(childNode);
+		const aspect0 = dimensions.height > 0 ? dimensions.width / dimensions.height : 1;
+		let OUT_W = OUT_MAX;
+		let OUT_H = OUT_MAX;
+		if (aspect0 >= 1) OUT_H = Math.max(Math.round(OUT_MAX / aspect0), 1);
+		else OUT_W = Math.max(Math.round(OUT_MAX * aspect0), 1);
+		const posBuf = createStateBuffer(root, d.vec4f, MAX_PARTICLES);
+		const velBuf = createStateBuffer(root, d.vec4f, MAX_PARTICLES);
+		const colBuf = createStateBuffer(root, d.vec4f, MAX_PARTICLES);
+		const accumR = createStateBuffer(root, d.atomic(d.u32), OUT_CELLS);
+		const accumG = createStateBuffer(root, d.atomic(d.u32), OUT_CELLS);
+		const accumB = createStateBuffer(root, d.atomic(d.u32), OUT_CELLS);
+		const accumW = createStateBuffer(root, d.atomic(d.u32), OUT_CELLS);
+		const outTex = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
+			size: [OUT_W, OUT_H],
+			format: STATE_FORMAT
+		}).$usage("storage", "sampled"), "outTex");
+		onCleanup(() => outTex.destroy());
+		const field = registerComputeTexture(outTex);
+		const paramsU = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(SimParams), "paramsU");
+		const simKernel = makeParticleFieldSimKernel(DEPTH_SOURCE_MODES[getCpuValue("depthSource") || "luminance"] ?? 0);
+		const splatKernel = makeParticleFieldSplatKernel(getCpuValue("particleShape") || "dot");
+		const clearPipe = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x, y) => {
+			"use gpu";
+			particleFieldClearKernel(x, y);
+		}), {
+			v: 1,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "x"
+				}, {
+					"type": "i",
+					"name": "y"
+				}],
+				"body": [0, [[
+					6,
+					"particleFieldClearKernel",
+					["x", "y"]
+				]]],
+				"externalNames": ["particleFieldClearKernel"]
+			},
+			externals: () => ({ particleFieldClearKernel })
+		}) && $.f)({}), { size: [OUT_W, OUT_H] });
+		const simPipe = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((gx, gy) => {
+			"use gpu";
+			simKernel(gx, gy);
+		}), {
+			v: 1,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "gx"
+				}, {
+					"type": "i",
+					"name": "gy"
+				}],
+				"body": [0, [[
+					6,
+					"simKernel",
+					["gx", "gy"]
+				]]],
+				"externalNames": ["simKernel"]
+			},
+			externals: () => ({ simKernel })
+		}) && $.f)({}));
+		const splatPipe = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((gx, gy) => {
+			"use gpu";
+			splatKernel(gx, gy);
+		}), {
+			v: 1,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "gx"
+				}, {
+					"type": "i",
+					"name": "gy"
+				}],
+				"body": [0, [[
+					6,
+					"splatKernel",
+					["gx", "gy"]
+				]]],
+				"externalNames": ["splatKernel"]
+			},
+			externals: () => ({ splatKernel })
+		}) && $.f)({}));
+		const resolvePipe = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x, y) => {
+			"use gpu";
+			particleFieldResolveKernel(x, y);
+		}), {
+			v: 1,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "x"
+				}, {
+					"type": "i",
+					"name": "y"
+				}],
+				"body": [0, [[
+					6,
+					"particleFieldResolveKernel",
+					["x", "y"]
+				]]],
+				"externalNames": ["particleFieldResolveKernel"]
+			},
+			externals: () => ({ particleFieldResolveKernel })
+		}) && $.f)({}), { size: [OUT_W, OUT_H] });
+		let bg = null;
+		let localTime = 0;
+		let frameIdx = 0;
+		const DEG_TO_RAD = .017453292519943295;
+		return {
+			outputs: {
+				childTexture,
+				field
+			},
+			bindInputs: (resolve) => {
+				const src = resolve(childTexture.key);
+				if (!src) return;
+				bg = root.createBindGroup(fieldLayout, {
+					pos: posBuf,
+					vel: velBuf,
+					col: colBuf,
+					accumR,
+					accumG,
+					accumB,
+					accumW,
+					params: paramsU.buffer,
+					src: src.texture,
+					outTex
+				});
+			},
+			getComputeNodes: (frameParams) => {
+				if (!bg) return null;
+				const fp = frameParams;
+				const dt = Math.min(Math.max(fp.deltaTime ?? .016, .001), .033);
+				localTime += dt;
+				const g = (key, fallback) => {
+					const v = getCpuValue(key);
+					return typeof v === "number" ? v : fallback;
+				};
+				const h = fp.dimensions?.height ?? dimensions.height;
+				const aspect = h > 0 ? (fp.dimensions?.width ?? dimensions.width) / h : 1;
+				const count = Math.min(Math.max(Math.round(g("count", 15e3)), 500), COUNT_MAX);
+				let GW = Math.round(Math.sqrt(count * aspect));
+				GW = Math.min(Math.max(GW, 8), GRID_DIM_MAX);
+				let GH = Math.round(count / GW);
+				GH = Math.min(Math.max(GH, 8), GRID_DIM_MAX);
+				const cursorMode = getCpuValue("cursorMode") || "push";
+				const cursorSign = cursorMode === "pull" ? -1 : 1;
+				const cursorStrength = cursorMode === "none" ? 0 : g("cursorStrength", .5);
+				const cursorRadius = g("cursorRadius", .22);
+				const rxA = g("rotationX", 0) * DEG_TO_RAD;
+				const ryA = g("rotationY", 0) * DEG_TO_RAD;
+				const rzA = g("rotationZ", 0) * DEG_TO_RAD;
+				const cx = Math.cos(rxA), sx = Math.sin(rxA);
+				const cy = Math.cos(ryA), sy = Math.sin(ryA);
+				const cz = Math.cos(rzA), sz = Math.sin(rzA);
+				const m00 = cz * cy, m01 = cz * sy * sx - sz * cx, m02 = cz * sy * cx + sz * sx;
+				const m10 = sz * cy, m11 = sz * sy * sx + cz * cx, m12 = sz * sy * cx - cz * sx;
+				const m20 = -sy, m21 = cy * sx, m22 = cy * cx;
+				paramsU.write({
+					rowX: d.vec4f(m00, -m01, m02, 0),
+					rowY: d.vec4f(-m10, m11, -m12, 0),
+					rowZ: d.vec4f(m20, -m21, m22, 0),
+					dt,
+					time: localTime,
+					snap: frameIdx === 0 ? 1 : 0,
+					gridW: GW,
+					gridH: GH,
+					outW: OUT_W,
+					outH: OUT_H,
+					depth: g("depth", .7),
+					dragMul: Math.exp(-DRAG * dt),
+					wobbleAmp: g("wobble", .35),
+					depthShading: Math.min(Math.max(g("depthShading", .6), 0), 1),
+					spacing: OUT_W / GW,
+					particleSize: g("particleSize", 1.3),
+					aspect,
+					zoom: Math.min(Math.max(g("zoom", 1), .05), 10),
+					transX: g("offsetX", 0),
+					transY: g("offsetY", 0),
+					pointerX: fp.pointer?.x ?? .5,
+					pointerY: fp.pointer?.y ?? .5,
+					cursorForce: cursorSign * cursorStrength * CURSOR_FORCE_K,
+					cursorZForce: cursorSign * cursorStrength * CURSOR_ZFORCE_K,
+					cursorRadSq: cursorRadius * cursorRadius
+				});
+				frameIdx++;
+				return [
+					() => clearPipe.with(bg).dispatch(),
+					() => simPipe.with(bg).dispatchThreads(GW, GH),
+					() => splatPipe.with(bg).dispatchThreads(GW, GH),
+					() => resolvePipe.with(bg).dispatch()
+				];
+			}
+		};
+	},
+	fragment: ({ childNode, ctx, computeOutputs }) => {
+		if (!childNode) return ZERO;
+		const field = computeOutputs?.field;
+		if (!field) return childNode;
+		return field.sample(ctx.uv, "linearClamp");
+	}
+};
+var ParticleField_default = componentDefinition;
+export { particleFieldClearKernel as a, makeParticleFieldSplatKernel as i, componentDefinition as n, particleFieldResolveKernel as o, makeParticleFieldSimKernel as r, particleFieldSplatKernel as s, ParticleField_default as t };