shaders 3.1.462 → 3.2.464

package/dist/core/pointerFields-CaaXhvvu.js

@@ -0,0 +1,2339 @@
+import { $n as vec4f, K as createStateBuffer, Tn as clamp, W as createGuardedCompute, Xn as vec2u, _r as u32, ar as textureStorage2d, bn as select, hr as f32, kn as exp, mn as typegpu_default, or as arrayOf, sr as struct, vn as textureStore, xn as abs } from "./lower-z2vuXP8M.js";
+import { a as op, o as trackedViewport } from "./grids-BqY3o2yc.js";
+var STATE_FORMAT = "rgba16float";
+var SPLAT_MAX_CELLS = 16384;
+const clampSplatGridSize = (v) => Math.max(8, Math.min(128, Math.floor(v)));
+var splatUpdateLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.bindGroupLayout({
+	buffer: {
+		storage: arrayOf(vec4f, SPLAT_MAX_CELLS),
+		access: "mutable"
+	},
+	params: { uniform: /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+		cursorX: f32,
+		cursorY: f32,
+		mouseVelX: f32,
+		mouseVelY: f32,
+		dt: f32,
+		decay: f32,
+		intensity: f32,
+		radius: f32,
+		aspect: f32
+	}), "uniform") }
+}), "splatUpdateLayout");
+var splatOutputLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.bindGroupLayout({
+	buffer: {
+		storage: arrayOf(vec4f, SPLAT_MAX_CELLS),
+		access: "readonly"
+	},
+	dispTex: { storageTexture: textureStorage2d(STATE_FORMAT, "write-only") }
+}), "splatOutputLayout");
+function makeSplatUpdateKernel(gridSize) {
+	return typegpu_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+		"use gpu";
+		const p = splatUpdateLayout.$.params;
+		const idx = __tsover_add(__tsover_mul(cy, u32(gridSize)), cx);
+		const cell = splatUpdateLayout.$.buffer[idx];
+		let dx = __tsover_mul(cell.x, __tsover_sub(1, __tsover_mul(p.decay, p.dt)));
+		let dy = __tsover_mul(cell.y, __tsover_sub(1, __tsover_mul(p.decay, p.dt)));
+		const cellX = __tsover_div(__tsover_add(f32(cx), .5), f32(gridSize));
+		const cellY = __tsover_div(__tsover_add(f32(cy), .5), f32(gridSize));
+		const ddx = select(__tsover_sub(cellX, p.cursorX), __tsover_mul(__tsover_sub(cellX, p.cursorX), p.aspect), p.aspect >= 1);
+		const ddy = select(__tsover_div(__tsover_sub(cellY, p.cursorY), p.aspect), __tsover_sub(cellY, p.cursorY), p.aspect >= 1);
+		const distSq = __tsover_add(__tsover_mul(ddx, ddx), __tsover_mul(ddy, ddy));
+		const radius2 = __tsover_mul(p.radius, 2);
+		if (distSq < __tsover_mul(radius2, radius2) && __tsover_add(abs(p.mouseVelX), abs(p.mouseVelY)) > .01) {
+			const influence = exp(__tsover_mul(__tsover_div(distSq, __tsover_mul(p.radius, p.radius)), -1));
+			dx = __tsover_add(dx, __tsover_mul(__tsover_mul(__tsover_mul(__tsover_mul(p.mouseVelX, influence), p.intensity), p.dt), .5));
+			dy = __tsover_add(dy, __tsover_mul(__tsover_mul(__tsover_mul(__tsover_mul(p.mouseVelY, influence), p.intensity), p.dt), .5));
+		}
+		dx = clamp(dx, -1, 1);
+		dy = clamp(dy, -1, 1);
+		splatUpdateLayout.$.buffer[idx] = vec4f(dx, dy, 0, 0);
+	}), {
+		v: 2,
+		name: void 0,
+		ast: {
+			"params": [{
+				"type": "i",
+				"name": "cx"
+			}, {
+				"type": "i",
+				"name": "cy"
+			}],
+			"body": [0, [
+				[
+					13,
+					"p",
+					[
+						7,
+						[
+							7,
+							"splatUpdateLayout",
+							"$"
+						],
+						"params"
+					]
+				],
+				[
+					13,
+					"idx",
+					[
+						1,
+						[
+							1,
+							"cy",
+							"*",
+							[
+								6,
+								"d.u32",
+								["gridSize"]
+							]
+						],
+						"+",
+						"cx"
+					]
+				],
+				[
+					13,
+					"cell",
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"splatUpdateLayout",
+								"$"
+							],
+							"buffer"
+						],
+						"idx"
+					]
+				],
+				[
+					12,
+					"dx",
+					[
+						1,
+						[
+							7,
+							"cell",
+							"x"
+						],
+						"*",
+						[
+							1,
+							[5, "1"],
+							"-",
+							[
+								1,
+								[
+									7,
+									"p",
+									"decay"
+								],
+								"*",
+								[
+									7,
+									"p",
+									"dt"
+								]
+							]
+						]
+					]
+				],
+				[
+					12,
+					"dy",
+					[
+						1,
+						[
+							7,
+							"cell",
+							"y"
+						],
+						"*",
+						[
+							1,
+							[5, "1"],
+							"-",
+							[
+								1,
+								[
+									7,
+									"p",
+									"decay"
+								],
+								"*",
+								[
+									7,
+									"p",
+									"dt"
+								]
+							]
+						]
+					]
+				],
+				[
+					13,
+					"cellX",
+					[
+						1,
+						[
+							1,
+							[
+								6,
+								"d.f32",
+								["cx"]
+							],
+							"+",
+							[5, "0.5"]
+						],
+						"/",
+						[
+							6,
+							"d.f32",
+							["gridSize"]
+						]
+					]
+				],
+				[
+					13,
+					"cellY",
+					[
+						1,
+						[
+							1,
+							[
+								6,
+								"d.f32",
+								["cy"]
+							],
+							"+",
+							[5, "0.5"]
+						],
+						"/",
+						[
+							6,
+							"d.f32",
+							["gridSize"]
+						]
+					]
+				],
+				[
+					13,
+					"ddx",
+					[
+						6,
+						"std.select",
+						[
+							[
+								1,
+								"cellX",
+								"-",
+								[
+									7,
+									"p",
+									"cursorX"
+								]
+							],
+							[
+								1,
+								[
+									1,
+									"cellX",
+									"-",
+									[
+										7,
+										"p",
+										"cursorX"
+									]
+								],
+								"*",
+								[
+									7,
+									"p",
+									"aspect"
+								]
+							],
+							[
+								1,
+								[
+									7,
+									"p",
+									"aspect"
+								],
+								">=",
+								[5, "1"]
+							]
+						]
+					]
+				],
+				[
+					13,
+					"ddy",
+					[
+						6,
+						"std.select",
+						[
+							[
+								1,
+								[
+									1,
+									"cellY",
+									"-",
+									[
+										7,
+										"p",
+										"cursorY"
+									]
+								],
+								"/",
+								[
+									7,
+									"p",
+									"aspect"
+								]
+							],
+							[
+								1,
+								"cellY",
+								"-",
+								[
+									7,
+									"p",
+									"cursorY"
+								]
+							],
+							[
+								1,
+								[
+									7,
+									"p",
+									"aspect"
+								],
+								">=",
+								[5, "1"]
+							]
+						]
+					]
+				],
+				[
+					13,
+					"distSq",
+					[
+						1,
+						[
+							1,
+							"ddx",
+							"*",
+							"ddx"
+						],
+						"+",
+						[
+							1,
+							"ddy",
+							"*",
+							"ddy"
+						]
+					]
+				],
+				[
+					13,
+					"radius2",
+					[
+						1,
+						[
+							7,
+							"p",
+							"radius"
+						],
+						"*",
+						[5, "2"]
+					]
+				],
+				[
+					11,
+					[
+						3,
+						[
+							1,
+							"distSq",
+							"<",
+							[
+								1,
+								"radius2",
+								"*",
+								"radius2"
+							]
+						],
+						"&&",
+						[
+							1,
+							[
+								1,
+								[
+									6,
+									"std.abs",
+									[[
+										7,
+										"p",
+										"mouseVelX"
+									]]
+								],
+								"+",
+								[
+									6,
+									"std.abs",
+									[[
+										7,
+										"p",
+										"mouseVelY"
+									]]
+								]
+							],
+							">",
+							[5, "0.01"]
+						]
+					],
+					[0, [
+						[
+							13,
+							"influence",
+							[
+								6,
+								"std.exp",
+								[[
+									1,
+									[
+										1,
+										"distSq",
+										"/",
+										[
+											1,
+											[
+												7,
+												"p",
+												"radius"
+											],
+											"*",
+											[
+												7,
+												"p",
+												"radius"
+											]
+										]
+									],
+									"*",
+									[
+										4,
+										"-",
+										[5, "1"]
+									]
+								]]
+							]
+						],
+						[
+							2,
+							"dx",
+							"=",
+							[
+								1,
+								"dx",
+								"+",
+								[
+									1,
+									[
+										1,
+										[
+											1,
+											[
+												1,
+												[
+													7,
+													"p",
+													"mouseVelX"
+												],
+												"*",
+												"influence"
+											],
+											"*",
+											[
+												7,
+												"p",
+												"intensity"
+											]
+										],
+										"*",
+										[
+											7,
+											"p",
+											"dt"
+										]
+									],
+									"*",
+									[5, "0.5"]
+								]
+							]
+						],
+						[
+							2,
+							"dy",
+							"=",
+							[
+								1,
+								"dy",
+								"+",
+								[
+									1,
+									[
+										1,
+										[
+											1,
+											[
+												1,
+												[
+													7,
+													"p",
+													"mouseVelY"
+												],
+												"*",
+												"influence"
+											],
+											"*",
+											[
+												7,
+												"p",
+												"intensity"
+											]
+										],
+										"*",
+										[
+											7,
+											"p",
+											"dt"
+										]
+									],
+									"*",
+									[5, "0.5"]
+								]
+							]
+						]
+					]]
+				],
+				[
+					2,
+					"dx",
+					"=",
+					[
+						6,
+						"std.clamp",
+						[
+							"dx",
+							[
+								4,
+								"-",
+								[5, "1"]
+							],
+							[5, "1"]
+						]
+					]
+				],
+				[
+					2,
+					"dy",
+					"=",
+					[
+						6,
+						"std.clamp",
+						[
+							"dy",
+							[
+								4,
+								"-",
+								[5, "1"]
+							],
+							[5, "1"]
+						]
+					]
+				],
+				[
+					2,
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"splatUpdateLayout",
+								"$"
+							],
+							"buffer"
+						],
+						"idx"
+					],
+					"=",
+					[
+						6,
+						"d.vec4f",
+						[
+							"dx",
+							"dy",
+							[5, "0"],
+							[5, "0"]
+						]
+					]
+				]
+			]]
+		},
+		externals: {
+			"splatUpdateLayout": () => splatUpdateLayout,
+			"d.u32": () => u32,
+			"gridSize": () => gridSize,
+			"d.f32": () => f32,
+			"std.select": () => select,
+			"std.abs": () => abs,
+			"std.exp": () => exp,
+			"std.clamp": () => clamp,
+			"d.vec4f": () => vec4f
+		}
+	}) && $.f)({})).$name("pointerSplatUpdate");
+}
+function makeSplatOutputKernel(gridSize) {
+	return typegpu_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+		"use gpu";
+		const idx = __tsover_add(__tsover_mul(cy, u32(gridSize)), cx);
+		const cell = splatOutputLayout.$.buffer[idx];
+		textureStore(splatOutputLayout.$.dispTex, vec2u(cx, cy), vec4f(cell.x, cell.y, 0, 1));
+	}), {
+		v: 2,
+		name: void 0,
+		ast: {
+			"params": [{
+				"type": "i",
+				"name": "cx"
+			}, {
+				"type": "i",
+				"name": "cy"
+			}],
+			"body": [0, [
+				[
+					13,
+					"idx",
+					[
+						1,
+						[
+							1,
+							"cy",
+							"*",
+							[
+								6,
+								"d.u32",
+								["gridSize"]
+							]
+						],
+						"+",
+						"cx"
+					]
+				],
+				[
+					13,
+					"cell",
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"splatOutputLayout",
+								"$"
+							],
+							"buffer"
+						],
+						"idx"
+					]
+				],
+				[
+					6,
+					"std.textureStore",
+					[
+						[
+							7,
+							[
+								7,
+								"splatOutputLayout",
+								"$"
+							],
+							"dispTex"
+						],
+						[
+							6,
+							"d.vec2u",
+							["cx", "cy"]
+						],
+						[
+							6,
+							"d.vec4f",
+							[
+								[
+									7,
+									"cell",
+									"x"
+								],
+								[
+									7,
+									"cell",
+									"y"
+								],
+								[5, "0"],
+								[5, "1"]
+							]
+						]
+					]
+				]
+			]]
+		},
+		externals: {
+			"d.u32": () => u32,
+			"gridSize": () => gridSize,
+			"splatOutputLayout": () => splatOutputLayout,
+			"std.textureStore": () => textureStore,
+			"d.vec2u": () => vec2u,
+			"d.vec4f": () => vec4f
+		}
+	}) && $.f)({})).$name("pointerSplatOutput");
+}
+function pointerSplatField(slots) {
+	return (params, root) => {
+		const { getCpuValue, registerComputeTexture, onCleanup } = params;
+		const gridSize = clampSplatGridSize(getCpuValue(slots.gridSize.name) ?? 20);
+		const buffer = createStateBuffer(root, vec4f, SPLAT_MAX_CELLS);
+		const dispTex = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
+			size: [gridSize, gridSize],
+			format: STATE_FORMAT
+		}).$usage("storage", "sampled"), "dispTex");
+		onCleanup(() => dispTex.destroy());
+		const displacement = registerComputeTexture(dispTex);
+		const updateParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(struct({
+			cursorX: f32,
+			cursorY: f32,
+			mouseVelX: f32,
+			mouseVelY: f32,
+			dt: f32,
+			decay: f32,
+			intensity: f32,
+			radius: f32,
+			aspect: f32
+		})), "updateParams");
+		const viewport = trackedViewport(params);
+		const size = [gridSize, gridSize];
+		const updateKernel = makeSplatUpdateKernel(gridSize);
+		const outputKernel = makeSplatOutputKernel(gridSize);
+		const updateBg = root.createBindGroup(splatUpdateLayout, {
+			buffer,
+			params: updateParams.buffer
+		});
+		const outputBg = root.createBindGroup(splatOutputLayout, {
+			buffer,
+			dispTex
+		});
+		const update = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+			"use gpu";
+			updateKernel(cx, cy);
+		}), {
+			v: 2,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "cx"
+				}, {
+					"type": "i",
+					"name": "cy"
+				}],
+				"body": [0, [[
+					6,
+					"updateKernel",
+					["cx", "cy"]
+				]]]
+			},
+			externals: { "updateKernel": () => updateKernel }
+		}) && $.f)({}), {
+			size,
+			bindGroup: updateBg
+		});
+		const output = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+			"use gpu";
+			outputKernel(cx, cy);
+		}), {
+			v: 2,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "cx"
+				}, {
+					"type": "i",
+					"name": "cy"
+				}],
+				"body": [0, [[
+					6,
+					"outputKernel",
+					["cx", "cy"]
+				]]]
+			},
+			externals: { "outputKernel": () => outputKernel }
+		}) && $.f)({}), {
+			size,
+			bindGroup: outputBg
+		});
+		let prevX = .5;
+		let prevY = .5;
+		let smoothVelX = 0;
+		let smoothVelY = 0;
+		let px = .5;
+		let py = .5;
+		let active = false;
+		return {
+			outputs: { [slots.output]: displacement },
+			clampDt: .016,
+			stages: [
+				op.host("cursorVelocity", (f) => {
+					px = f.frameParams.pointer?.x ?? .5;
+					py = f.frameParams.pointer?.y ?? .5;
+					const velX = f.dt > 0 ? (px - prevX) / f.dt : 0;
+					const velY = f.dt > 0 ? (py - prevY) / f.dt : 0;
+					smoothVelX = smoothVelX * .85 + velX * .15;
+					smoothVelY = smoothVelY * .85 + velY * .15;
+					prevX = px;
+					prevY = py;
+					active = Math.abs(velX) + Math.abs(velY) > .01;
+				}),
+				op.settle({
+					activeWhen: () => active,
+					settleMs: (f) => {
+						const decayVal = f.num(slots.decay.name, 3);
+						return decayVal > 0 ? Math.min(3e4, Math.log(1e-4) / Math.log(Math.max(1e-6, 1 - decayVal * .016)) * 16.67) : 3e4;
+					}
+				}),
+				op.values("brush+decay", (f) => {
+					const safe = viewport.safe(f.frameParams);
+					updateParams.write({
+						cursorX: px,
+						cursorY: py,
+						mouseVelX: smoothVelX,
+						mouseVelY: smoothVelY,
+						dt: f.dt,
+						decay: f.num(slots.decay.name, 3),
+						intensity: f.num(slots.intensity.name, 1),
+						radius: f.num(slots.radius.name, 1) * .05,
+						aspect: safe.width / safe.height
+					});
+				}),
+				op.pass(update),
+				op.publish(() => output)
+			]
+		};
+	};
+}
+var LATTICE_GRID = 64;
+var LATTICE_CELLS = LATTICE_GRID * LATTICE_GRID;
+var LATTICE_MAX = LATTICE_GRID - 1;
+var latticeLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.bindGroupLayout({
+	readBuf: {
+		storage: arrayOf(vec4f, LATTICE_CELLS),
+		access: "readonly"
+	},
+	writeBuf: {
+		storage: arrayOf(vec4f, LATTICE_CELLS),
+		access: "mutable"
+	},
+	params: { uniform: /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+		cursorX: f32,
+		cursorY: f32,
+		dirX: f32,
+		dirY: f32,
+		clampedSpeed: f32,
+		dt: f32,
+		subDt: f32,
+		stiffness: f32,
+		dampFactor: f32,
+		radius: f32,
+		aspect: f32
+	}), "uniform") }
+}), "latticeLayout");
+var latticeOutputLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.bindGroupLayout({
+	srcBuf: {
+		storage: arrayOf(vec4f, LATTICE_CELLS),
+		access: "readonly"
+	},
+	dispTex: { storageTexture: textureStorage2d(STATE_FORMAT, "write-only") }
+}), "latticeOutputLayout");
+const springLatticeKernel = typegpu_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+	"use gpu";
+	if (cx > u32(0) && cx < u32(LATTICE_MAX) && cy > u32(0) && cy < u32(LATTICE_MAX)) {
+		const p = latticeLayout.$.params;
+		const gs = u32(LATTICE_GRID);
+		const idx = __tsover_add(__tsover_mul(cy, gs), cx);
+		const current = latticeLayout.$.readBuf[idx];
+		const dispX = current.x;
+		const dispY = current.y;
+		const velX = current.z;
+		const velY = current.w;
+		const nL = latticeLayout.$.readBuf[__tsover_sub(idx, u32(1))];
+		const nR = latticeLayout.$.readBuf[__tsover_add(idx, u32(1))];
+		const nU = latticeLayout.$.readBuf[__tsover_sub(idx, gs)];
+		const nD = latticeLayout.$.readBuf[__tsover_add(idx, gs)];
+		const nUL = latticeLayout.$.readBuf[__tsover_sub(__tsover_sub(idx, gs), u32(1))];
+		const nUR = latticeLayout.$.readBuf[__tsover_add(__tsover_sub(idx, gs), u32(1))];
+		const nDL = latticeLayout.$.readBuf[__tsover_sub(__tsover_add(idx, gs), u32(1))];
+		const nDR = latticeLayout.$.readBuf[__tsover_add(__tsover_add(idx, gs), u32(1))];
+		let fx = __tsover_mul(p.stiffness, __tsover_add(__tsover_add(__tsover_add(__tsover_sub(nL.x, dispX), __tsover_sub(nR.x, dispX)), __tsover_sub(nU.x, dispX)), __tsover_sub(nD.x, dispX)));
+		let fy = __tsover_mul(p.stiffness, __tsover_add(__tsover_add(__tsover_add(__tsover_sub(nL.y, dispY), __tsover_sub(nR.y, dispY)), __tsover_sub(nU.y, dispY)), __tsover_sub(nD.y, dispY)));
+		const shearK = __tsover_mul(p.stiffness, .35);
+		fx = __tsover_add(fx, __tsover_mul(shearK, __tsover_add(__tsover_add(__tsover_add(__tsover_sub(nUL.x, dispX), __tsover_sub(nUR.x, dispX)), __tsover_sub(nDL.x, dispX)), __tsover_sub(nDR.x, dispX))));
+		fy = __tsover_add(fy, __tsover_mul(shearK, __tsover_add(__tsover_add(__tsover_add(__tsover_sub(nUL.y, dispY), __tsover_sub(nUR.y, dispY)), __tsover_sub(nDL.y, dispY)), __tsover_sub(nDR.y, dispY))));
+		fx = __tsover_sub(fx, __tsover_mul(__tsover_mul(p.stiffness, .1), dispX));
+		fy = __tsover_sub(fy, __tsover_mul(__tsover_mul(p.stiffness, .1), dispY));
+		let newVelX = __tsover_add(__tsover_mul(velX, p.dampFactor), __tsover_mul(fx, p.subDt));
+		let newVelY = __tsover_add(__tsover_mul(velY, p.dampFactor), __tsover_mul(fy, p.subDt));
+		if (p.clampedSpeed > .01) {
+			const cellX = __tsover_div(__tsover_add(f32(cx), .5), f32(LATTICE_GRID));
+			const cellY = __tsover_div(__tsover_add(f32(cy), .5), f32(LATTICE_GRID));
+			const ddx = select(__tsover_sub(cellX, p.cursorX), __tsover_mul(__tsover_sub(cellX, p.cursorX), p.aspect), p.aspect >= 1);
+			const ddy = select(__tsover_div(__tsover_sub(cellY, p.cursorY), p.aspect), __tsover_sub(cellY, p.cursorY), p.aspect >= 1);
+			const distSq = __tsover_add(__tsover_mul(ddx, ddx), __tsover_mul(ddy, ddy));
+			const influenceRadius = __tsover_mul(p.radius, 3);
+			if (distSq < __tsover_mul(influenceRadius, influenceRadius)) {
+				const influence = exp(__tsover_mul(__tsover_div(distSq, __tsover_mul(p.radius, p.radius)), -1));
+				const forceMag = __tsover_mul(__tsover_mul(__tsover_mul(influence, p.clampedSpeed), p.dt), 2);
+				newVelX = __tsover_add(newVelX, __tsover_mul(p.dirX, forceMag));
+				newVelY = __tsover_add(newVelY, __tsover_mul(p.dirY, forceMag));
+			}
+		}
+		const newDispX = clamp(__tsover_add(dispX, __tsover_mul(newVelX, p.subDt)), -.5, .5);
+		const newDispY = clamp(__tsover_add(dispY, __tsover_mul(newVelY, p.subDt)), -.5, .5);
+		latticeLayout.$.writeBuf[idx] = vec4f(newDispX, newDispY, newVelX, newVelY);
+	}
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "cx"
+		}, {
+			"type": "i",
+			"name": "cy"
+		}],
+		"body": [0, [[
+			11,
+			[
+				3,
+				[
+					3,
+					[
+						3,
+						[
+							1,
+							"cx",
+							">",
+							[
+								6,
+								"d.u32",
+								[[5, "0"]]
+							]
+						],
+						"&&",
+						[
+							1,
+							"cx",
+							"<",
+							[
+								6,
+								"d.u32",
+								["LATTICE_MAX"]
+							]
+						]
+					],
+					"&&",
+					[
+						1,
+						"cy",
+						">",
+						[
+							6,
+							"d.u32",
+							[[5, "0"]]
+						]
+					]
+				],
+				"&&",
+				[
+					1,
+					"cy",
+					"<",
+					[
+						6,
+						"d.u32",
+						["LATTICE_MAX"]
+					]
+				]
+			],
+			[0, [
+				[
+					13,
+					"p",
+					[
+						7,
+						[
+							7,
+							"latticeLayout",
+							"$"
+						],
+						"params"
+					]
+				],
+				[
+					13,
+					"gs",
+					[
+						6,
+						"d.u32",
+						["LATTICE_GRID"]
+					]
+				],
+				[
+					13,
+					"idx",
+					[
+						1,
+						[
+							1,
+							"cy",
+							"*",
+							"gs"
+						],
+						"+",
+						"cx"
+					]
+				],
+				[
+					13,
+					"current",
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"latticeLayout",
+								"$"
+							],
+							"readBuf"
+						],
+						"idx"
+					]
+				],
+				[
+					13,
+					"dispX",
+					[
+						7,
+						"current",
+						"x"
+					]
+				],
+				[
+					13,
+					"dispY",
+					[
+						7,
+						"current",
+						"y"
+					]
+				],
+				[
+					13,
+					"velX",
+					[
+						7,
+						"current",
+						"z"
+					]
+				],
+				[
+					13,
+					"velY",
+					[
+						7,
+						"current",
+						"w"
+					]
+				],
+				[
+					13,
+					"nL",
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"latticeLayout",
+								"$"
+							],
+							"readBuf"
+						],
+						[
+							1,
+							"idx",
+							"-",
+							[
+								6,
+								"d.u32",
+								[[5, "1"]]
+							]
+						]
+					]
+				],
+				[
+					13,
+					"nR",
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"latticeLayout",
+								"$"
+							],
+							"readBuf"
+						],
+						[
+							1,
+							"idx",
+							"+",
+							[
+								6,
+								"d.u32",
+								[[5, "1"]]
+							]
+						]
+					]
+				],
+				[
+					13,
+					"nU",
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"latticeLayout",
+								"$"
+							],
+							"readBuf"
+						],
+						[
+							1,
+							"idx",
+							"-",
+							"gs"
+						]
+					]
+				],
+				[
+					13,
+					"nD",
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"latticeLayout",
+								"$"
+							],
+							"readBuf"
+						],
+						[
+							1,
+							"idx",
+							"+",
+							"gs"
+						]
+					]
+				],
+				[
+					13,
+					"nUL",
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"latticeLayout",
+								"$"
+							],
+							"readBuf"
+						],
+						[
+							1,
+							[
+								1,
+								"idx",
+								"-",
+								"gs"
+							],
+							"-",
+							[
+								6,
+								"d.u32",
+								[[5, "1"]]
+							]
+						]
+					]
+				],
+				[
+					13,
+					"nUR",
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"latticeLayout",
+								"$"
+							],
+							"readBuf"
+						],
+						[
+							1,
+							[
+								1,
+								"idx",
+								"-",
+								"gs"
+							],
+							"+",
+							[
+								6,
+								"d.u32",
+								[[5, "1"]]
+							]
+						]
+					]
+				],
+				[
+					13,
+					"nDL",
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"latticeLayout",
+								"$"
+							],
+							"readBuf"
+						],
+						[
+							1,
+							[
+								1,
+								"idx",
+								"+",
+								"gs"
+							],
+							"-",
+							[
+								6,
+								"d.u32",
+								[[5, "1"]]
+							]
+						]
+					]
+				],
+				[
+					13,
+					"nDR",
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"latticeLayout",
+								"$"
+							],
+							"readBuf"
+						],
+						[
+							1,
+							[
+								1,
+								"idx",
+								"+",
+								"gs"
+							],
+							"+",
+							[
+								6,
+								"d.u32",
+								[[5, "1"]]
+							]
+						]
+					]
+				],
+				[
+					12,
+					"fx",
+					[
+						1,
+						[
+							7,
+							"p",
+							"stiffness"
+						],
+						"*",
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									[
+										1,
+										[
+											7,
+											"nL",
+											"x"
+										],
+										"-",
+										"dispX"
+									],
+									"+",
+									[
+										1,
+										[
+											7,
+											"nR",
+											"x"
+										],
+										"-",
+										"dispX"
+									]
+								],
+								"+",
+								[
+									1,
+									[
+										7,
+										"nU",
+										"x"
+									],
+									"-",
+									"dispX"
+								]
+							],
+							"+",
+							[
+								1,
+								[
+									7,
+									"nD",
+									"x"
+								],
+								"-",
+								"dispX"
+							]
+						]
+					]
+				],
+				[
+					12,
+					"fy",
+					[
+						1,
+						[
+							7,
+							"p",
+							"stiffness"
+						],
+						"*",
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									[
+										1,
+										[
+											7,
+											"nL",
+											"y"
+										],
+										"-",
+										"dispY"
+									],
+									"+",
+									[
+										1,
+										[
+											7,
+											"nR",
+											"y"
+										],
+										"-",
+										"dispY"
+									]
+								],
+								"+",
+								[
+									1,
+									[
+										7,
+										"nU",
+										"y"
+									],
+									"-",
+									"dispY"
+								]
+							],
+							"+",
+							[
+								1,
+								[
+									7,
+									"nD",
+									"y"
+								],
+								"-",
+								"dispY"
+							]
+						]
+					]
+				],
+				[
+					13,
+					"shearK",
+					[
+						1,
+						[
+							7,
+							"p",
+							"stiffness"
+						],
+						"*",
+						[5, "0.35"]
+					]
+				],
+				[
+					2,
+					"fx",
+					"=",
+					[
+						1,
+						"fx",
+						"+",
+						[
+							1,
+							"shearK",
+							"*",
+							[
+								1,
+								[
+									1,
+									[
+										1,
+										[
+											1,
+											[
+												7,
+												"nUL",
+												"x"
+											],
+											"-",
+											"dispX"
+										],
+										"+",
+										[
+											1,
+											[
+												7,
+												"nUR",
+												"x"
+											],
+											"-",
+											"dispX"
+										]
+									],
+									"+",
+									[
+										1,
+										[
+											7,
+											"nDL",
+											"x"
+										],
+										"-",
+										"dispX"
+									]
+								],
+								"+",
+								[
+									1,
+									[
+										7,
+										"nDR",
+										"x"
+									],
+									"-",
+									"dispX"
+								]
+							]
+						]
+					]
+				],
+				[
+					2,
+					"fy",
+					"=",
+					[
+						1,
+						"fy",
+						"+",
+						[
+							1,
+							"shearK",
+							"*",
+							[
+								1,
+								[
+									1,
+									[
+										1,
+										[
+											1,
+											[
+												7,
+												"nUL",
+												"y"
+											],
+											"-",
+											"dispY"
+										],
+										"+",
+										[
+											1,
+											[
+												7,
+												"nUR",
+												"y"
+											],
+											"-",
+											"dispY"
+										]
+									],
+									"+",
+									[
+										1,
+										[
+											7,
+											"nDL",
+											"y"
+										],
+										"-",
+										"dispY"
+									]
+								],
+								"+",
+								[
+									1,
+									[
+										7,
+										"nDR",
+										"y"
+									],
+									"-",
+									"dispY"
+								]
+							]
+						]
+					]
+				],
+				[
+					2,
+					"fx",
+					"=",
+					[
+						1,
+						"fx",
+						"-",
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									"p",
+									"stiffness"
+								],
+								"*",
+								[5, "0.1"]
+							],
+							"*",
+							"dispX"
+						]
+					]
+				],
+				[
+					2,
+					"fy",
+					"=",
+					[
+						1,
+						"fy",
+						"-",
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									"p",
+									"stiffness"
+								],
+								"*",
+								[5, "0.1"]
+							],
+							"*",
+							"dispY"
+						]
+					]
+				],
+				[
+					12,
+					"newVelX",
+					[
+						1,
+						[
+							1,
+							"velX",
+							"*",
+							[
+								7,
+								"p",
+								"dampFactor"
+							]
+						],
+						"+",
+						[
+							1,
+							"fx",
+							"*",
+							[
+								7,
+								"p",
+								"subDt"
+							]
+						]
+					]
+				],
+				[
+					12,
+					"newVelY",
+					[
+						1,
+						[
+							1,
+							"velY",
+							"*",
+							[
+								7,
+								"p",
+								"dampFactor"
+							]
+						],
+						"+",
+						[
+							1,
+							"fy",
+							"*",
+							[
+								7,
+								"p",
+								"subDt"
+							]
+						]
+					]
+				],
+				[
+					11,
+					[
+						1,
+						[
+							7,
+							"p",
+							"clampedSpeed"
+						],
+						">",
+						[5, "0.01"]
+					],
+					[0, [
+						[
+							13,
+							"cellX",
+							[
+								1,
+								[
+									1,
+									[
+										6,
+										"d.f32",
+										["cx"]
+									],
+									"+",
+									[5, "0.5"]
+								],
+								"/",
+								[
+									6,
+									"d.f32",
+									["LATTICE_GRID"]
+								]
+							]
+						],
+						[
+							13,
+							"cellY",
+							[
+								1,
+								[
+									1,
+									[
+										6,
+										"d.f32",
+										["cy"]
+									],
+									"+",
+									[5, "0.5"]
+								],
+								"/",
+								[
+									6,
+									"d.f32",
+									["LATTICE_GRID"]
+								]
+							]
+						],
+						[
+							13,
+							"ddx",
+							[
+								6,
+								"std.select",
+								[
+									[
+										1,
+										"cellX",
+										"-",
+										[
+											7,
+											"p",
+											"cursorX"
+										]
+									],
+									[
+										1,
+										[
+											1,
+											"cellX",
+											"-",
+											[
+												7,
+												"p",
+												"cursorX"
+											]
+										],
+										"*",
+										[
+											7,
+											"p",
+											"aspect"
+										]
+									],
+									[
+										1,
+										[
+											7,
+											"p",
+											"aspect"
+										],
+										">=",
+										[5, "1"]
+									]
+								]
+							]
+						],
+						[
+							13,
+							"ddy",
+							[
+								6,
+								"std.select",
+								[
+									[
+										1,
+										[
+											1,
+											"cellY",
+											"-",
+											[
+												7,
+												"p",
+												"cursorY"
+											]
+										],
+										"/",
+										[
+											7,
+											"p",
+											"aspect"
+										]
+									],
+									[
+										1,
+										"cellY",
+										"-",
+										[
+											7,
+											"p",
+											"cursorY"
+										]
+									],
+									[
+										1,
+										[
+											7,
+											"p",
+											"aspect"
+										],
+										">=",
+										[5, "1"]
+									]
+								]
+							]
+						],
+						[
+							13,
+							"distSq",
+							[
+								1,
+								[
+									1,
+									"ddx",
+									"*",
+									"ddx"
+								],
+								"+",
+								[
+									1,
+									"ddy",
+									"*",
+									"ddy"
+								]
+							]
+						],
+						[
+							13,
+							"influenceRadius",
+							[
+								1,
+								[
+									7,
+									"p",
+									"radius"
+								],
+								"*",
+								[5, "3"]
+							]
+						],
+						[
+							11,
+							[
+								1,
+								"distSq",
+								"<",
+								[
+									1,
+									"influenceRadius",
+									"*",
+									"influenceRadius"
+								]
+							],
+							[0, [
+								[
+									13,
+									"influence",
+									[
+										6,
+										"std.exp",
+										[[
+											1,
+											[
+												1,
+												"distSq",
+												"/",
+												[
+													1,
+													[
+														7,
+														"p",
+														"radius"
+													],
+													"*",
+													[
+														7,
+														"p",
+														"radius"
+													]
+												]
+											],
+											"*",
+											[
+												4,
+												"-",
+												[5, "1"]
+											]
+										]]
+									]
+								],
+								[
+									13,
+									"forceMag",
+									[
+										1,
+										[
+											1,
+											[
+												1,
+												"influence",
+												"*",
+												[
+													7,
+													"p",
+													"clampedSpeed"
+												]
+											],
+											"*",
+											[
+												7,
+												"p",
+												"dt"
+											]
+										],
+										"*",
+										[5, "2"]
+									]
+								],
+								[
+									2,
+									"newVelX",
+									"=",
+									[
+										1,
+										"newVelX",
+										"+",
+										[
+											1,
+											[
+												7,
+												"p",
+												"dirX"
+											],
+											"*",
+											"forceMag"
+										]
+									]
+								],
+								[
+									2,
+									"newVelY",
+									"=",
+									[
+										1,
+										"newVelY",
+										"+",
+										[
+											1,
+											[
+												7,
+												"p",
+												"dirY"
+											],
+											"*",
+											"forceMag"
+										]
+									]
+								]
+							]]
+						]
+					]]
+				],
+				[
+					13,
+					"newDispX",
+					[
+						6,
+						"std.clamp",
+						[
+							[
+								1,
+								"dispX",
+								"+",
+								[
+									1,
+									"newVelX",
+									"*",
+									[
+										7,
+										"p",
+										"subDt"
+									]
+								]
+							],
+							[
+								4,
+								"-",
+								[5, "0.5"]
+							],
+							[5, "0.5"]
+						]
+					]
+				],
+				[
+					13,
+					"newDispY",
+					[
+						6,
+						"std.clamp",
+						[
+							[
+								1,
+								"dispY",
+								"+",
+								[
+									1,
+									"newVelY",
+									"*",
+									[
+										7,
+										"p",
+										"subDt"
+									]
+								]
+							],
+							[
+								4,
+								"-",
+								[5, "0.5"]
+							],
+							[5, "0.5"]
+						]
+					]
+				],
+				[
+					2,
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"latticeLayout",
+								"$"
+							],
+							"writeBuf"
+						],
+						"idx"
+					],
+					"=",
+					[
+						6,
+						"d.vec4f",
+						[
+							"newDispX",
+							"newDispY",
+							"newVelX",
+							"newVelY"
+						]
+					]
+				]
+			]]
+		]]]
+	},
+	externals: {
+		"d.u32": () => u32,
+		"LATTICE_MAX": () => LATTICE_MAX,
+		"latticeLayout": () => latticeLayout,
+		"LATTICE_GRID": () => LATTICE_GRID,
+		"d.f32": () => f32,
+		"std.select": () => select,
+		"std.exp": () => exp,
+		"std.clamp": () => clamp,
+		"d.vec4f": () => vec4f
+	}
+}) && $.f)({})).$name("springLatticeStep");
+const springLatticeOutputKernel = typegpu_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+	"use gpu";
+	const idx = __tsover_add(__tsover_mul(cy, u32(LATTICE_GRID)), cx);
+	const cell = latticeOutputLayout.$.srcBuf[idx];
+	textureStore(latticeOutputLayout.$.dispTex, vec2u(cx, cy), vec4f(cell.x, cell.y, 0, 1));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "cx"
+		}, {
+			"type": "i",
+			"name": "cy"
+		}],
+		"body": [0, [
+			[
+				13,
+				"idx",
+				[
+					1,
+					[
+						1,
+						"cy",
+						"*",
+						[
+							6,
+							"d.u32",
+							["LATTICE_GRID"]
+						]
+					],
+					"+",
+					"cx"
+				]
+			],
+			[
+				13,
+				"cell",
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"latticeOutputLayout",
+							"$"
+						],
+						"srcBuf"
+					],
+					"idx"
+				]
+			],
+			[
+				6,
+				"std.textureStore",
+				[
+					[
+						7,
+						[
+							7,
+							"latticeOutputLayout",
+							"$"
+						],
+						"dispTex"
+					],
+					[
+						6,
+						"d.vec2u",
+						["cx", "cy"]
+					],
+					[
+						6,
+						"d.vec4f",
+						[
+							[
+								7,
+								"cell",
+								"x"
+							],
+							[
+								7,
+								"cell",
+								"y"
+							],
+							[5, "0"],
+							[5, "1"]
+						]
+					]
+				]
+			]
+		]]
+	},
+	externals: {
+		"d.u32": () => u32,
+		"LATTICE_GRID": () => LATTICE_GRID,
+		"latticeOutputLayout": () => latticeOutputLayout,
+		"std.textureStore": () => textureStore,
+		"d.vec2u": () => vec2u,
+		"d.vec4f": () => vec4f
+	}
+}) && $.f)({})).$name("springLatticeOutput");
+function springLatticeField(slots) {
+	return (params, root) => {
+		const { registerComputeTexture, onCleanup } = params;
+		const bufferA = createStateBuffer(root, vec4f, LATTICE_CELLS);
+		const bufferB = createStateBuffer(root, vec4f, LATTICE_CELLS);
+		const dispTex = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
+			size: [LATTICE_GRID, LATTICE_GRID],
+			format: STATE_FORMAT
+		}).$usage("storage", "sampled"), "dispTex");
+		onCleanup(() => dispTex.destroy());
+		const displacement = registerComputeTexture(dispTex);
+		const springParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(struct({
+			cursorX: f32,
+			cursorY: f32,
+			dirX: f32,
+			dirY: f32,
+			clampedSpeed: f32,
+			dt: f32,
+			subDt: f32,
+			stiffness: f32,
+			dampFactor: f32,
+			radius: f32,
+			aspect: f32
+		})), "springParams");
+		const viewport = trackedViewport(params);
+		const size = [LATTICE_GRID, LATTICE_GRID];
+		const springBgAB = root.createBindGroup(latticeLayout, {
+			readBuf: bufferA,
+			writeBuf: bufferB,
+			params: springParams.buffer
+		});
+		const springBgBA = root.createBindGroup(latticeLayout, {
+			readBuf: bufferB,
+			writeBuf: bufferA,
+			params: springParams.buffer
+		});
+		const spring = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+			"use gpu";
+			springLatticeKernel(cx, cy);
+		}), {
+			v: 2,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "cx"
+				}, {
+					"type": "i",
+					"name": "cy"
+				}],
+				"body": [0, [[
+					6,
+					"springLatticeKernel",
+					["cx", "cy"]
+				]]]
+			},
+			externals: { "springLatticeKernel": () => springLatticeKernel }
+		}) && $.f)({}), { size });
+		const outputBgA = root.createBindGroup(latticeOutputLayout, {
+			srcBuf: bufferA,
+			dispTex
+		});
+		const output = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+			"use gpu";
+			springLatticeOutputKernel(cx, cy);
+		}), {
+			v: 2,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "cx"
+				}, {
+					"type": "i",
+					"name": "cy"
+				}],
+				"body": [0, [[
+					6,
+					"springLatticeOutputKernel",
+					["cx", "cy"]
+				]]]
+			},
+			externals: { "springLatticeOutputKernel": () => springLatticeOutputKernel }
+		}) && $.f)({}), {
+			size,
+			bindGroup: outputBgA
+		});
+		let prevX = .5;
+		let prevY = .5;
+		let px = .5;
+		let py = .5;
+		let rawVelX = 0;
+		let rawVelY = 0;
+		let speed = 0;
+		let clampedSpeed = 0;
+		return {
+			outputs: { [slots.output]: displacement },
+			clampDt: .016,
+			zeroDt: "skip",
+			stages: [
+				op.host("cursorImpulse", (f) => {
+					px = f.frameParams.pointer?.x ?? .5;
+					py = f.frameParams.pointer?.y ?? .5;
+					rawVelX = (px - prevX) / f.dt;
+					rawVelY = (py - prevY) / f.dt;
+					speed = Math.sqrt(rawVelX * rawVelX + rawVelY * rawVelY);
+					clampedSpeed = Math.min(speed, 3);
+					prevX = px;
+					prevY = py;
+				}),
+				op.settle({
+					activeWhen: () => clampedSpeed > .01,
+					settleMs: (f) => {
+						const damping = f.num(slots.damping.name, 3);
+						return damping > 0 ? Math.min(3e4, 5e3 / damping) : 3e4;
+					}
+				}),
+				op.values("springs+impulse", (f) => {
+					const safe = viewport.safe(f.frameParams);
+					const damping = f.num(slots.damping.name, 3);
+					const subDt = f.dt / 2;
+					springParams.write({
+						cursorX: px,
+						cursorY: py,
+						dirX: speed > .01 ? rawVelX / speed : 0,
+						dirY: speed > .01 ? rawVelY / speed : 0,
+						clampedSpeed,
+						dt: f.dt,
+						subDt,
+						stiffness: f.num(slots.stiffness.name, 3),
+						dampFactor: Math.max(0, Math.min(1, 1 - damping * subDt)),
+						radius: f.num(slots.radius.name, 1) * .08,
+						aspect: safe.width / safe.height
+					});
+				}),
+				op.pass(spring.with(springBgAB)),
+				op.pass(spring.with(springBgBA)),
+				op.publish(() => output)
+			]
+		};
+	};
+}
+export { pointerSplatField as n, springLatticeField as r, clampSplatGridSize as t };