shaders 3.0.453 → 3.1.455

package/dist/core/Fog-DvOvVKbF.js

@@ -0,0 +1,2261 @@
+import { At as max, Bt as sin, Dt as floor, Gt as data_exports, Mt as mix, Ot as fract, R as colorMixing_exports, St as cos, Yt as textureStorage2d, at as std_exports, cn as vec4f, en as struct, f as ZERO, fn as u32, h as call, jt as min, qt as arrayOf, rt as src_default, un as f32, x as vec4, xt as clamp } from "./edges-CD7gCAto.js";
+import { o as TAU$1 } from "./constants-DoOzbl5b.js";
+import { a as gaussianBrushSq, c as createStableFluidsPasses, o as buildFluidOutputKernel, s as buildStableFluidsKernels } from "./porters-DUtQounc.js";
+import { M as createGuardedCompute, P as createStateBuffer } from "./device-B0ZwBfOg.js";
+import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-B-zNWNdd.js";
+import { n as createPointerVelocityTracker } from "./pointer-DGDGF-yO.js";
+var N = 256;
+var COUNT = N * N;
+var JACOBI_ITERS = 10;
+var WARM_JACOBI_ITERS = 6;
+var WARM_STEPS = 50;
+var VELOCITY_DISSIPATION = .15;
+var INTERNAL_MAX_VEL = N * .6;
+var TAU = TAU$1;
+var STATE_FORMAT = "rgba16float";
+var cm = colorMixing_exports;
+var FogParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+	dt: f32,
+	time: f32,
+	seed: f32,
+	turbulence: f32,
+	curlStrength: f32,
+	velFade: f32,
+	blending: f32,
+	cursorX: f32,
+	cursorY: f32,
+	cursorVelX: f32,
+	cursorVelY: f32,
+	mouseActive: f32,
+	mouseRadSq: f32
+}), "FogParams");
+var fluidLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
+	velA: {
+		storage: arrayOf(vec4f, COUNT),
+		access: "mutable"
+	},
+	velB: {
+		storage: arrayOf(vec4f, COUNT),
+		access: "mutable"
+	},
+	dyeA: {
+		storage: arrayOf(vec4f, COUNT),
+		access: "mutable"
+	},
+	dyeB: {
+		storage: arrayOf(vec4f, COUNT),
+		access: "mutable"
+	},
+	pressure: {
+		storage: arrayOf(f32, COUNT),
+		access: "mutable"
+	},
+	divergence: {
+		storage: arrayOf(f32, COUNT),
+		access: "mutable"
+	},
+	params: { uniform: FogParams }
+}), "fluidLayout");
+var outputLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
+	dyeA: {
+		storage: arrayOf(vec4f, COUNT),
+		access: "readonly"
+	},
+	outTex: { storageTexture: textureStorage2d(STATE_FORMAT, "write-only") }
+}), "outputLayout");
+var hashFog = src_default.fn([f32, f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((px, py) => {
+	"use gpu";
+	return fract(__tsover_mul(sin(__tsover_add(__tsover_mul(px, 127.1), __tsover_mul(py, 311.7))), 43758.5453));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "px"
+		}, {
+			"type": "i",
+			"name": "py"
+		}],
+		"body": [0, [[10, [
+			6,
+			[
+				7,
+				"std",
+				"fract"
+			],
+			[[
+				1,
+				[
+					6,
+					[
+						7,
+						"std",
+						"sin"
+					],
+					[[
+						1,
+						[
+							1,
+							"px",
+							"*",
+							[5, "127.1"]
+						],
+						"+",
+						[
+							1,
+							"py",
+							"*",
+							[5, "311.7"]
+						]
+					]]
+				],
+				"*",
+				[5, "43758.5453"]
+			]]
+		]]]],
+		"externalNames": ["std"]
+	},
+	externals: () => ({ std: std_exports })
+}) && $.f)({}));
+var valueNoise2D = src_default.fn([f32, f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((nx, ny) => {
+	"use gpu";
+	const ix = floor(nx);
+	const iy = floor(ny);
+	const sx = fract(nx);
+	const sy = fract(ny);
+	const ux = __tsover_mul(__tsover_mul(sx, sx), __tsover_sub(3, __tsover_mul(sx, 2)));
+	const uy = __tsover_mul(__tsover_mul(sy, sy), __tsover_sub(3, __tsover_mul(sy, 2)));
+	return mix(mix(hashFog(ix, iy), hashFog(__tsover_add(ix, 1), iy), ux), mix(hashFog(ix, __tsover_add(iy, 1)), hashFog(__tsover_add(ix, 1), __tsover_add(iy, 1)), ux), uy);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "nx"
+		}, {
+			"type": "i",
+			"name": "ny"
+		}],
+		"body": [0, [
+			[
+				13,
+				"ix",
+				[
+					6,
+					[
+						7,
+						"std",
+						"floor"
+					],
+					["nx"]
+				]
+			],
+			[
+				13,
+				"iy",
+				[
+					6,
+					[
+						7,
+						"std",
+						"floor"
+					],
+					["ny"]
+				]
+			],
+			[
+				13,
+				"sx",
+				[
+					6,
+					[
+						7,
+						"std",
+						"fract"
+					],
+					["nx"]
+				]
+			],
+			[
+				13,
+				"sy",
+				[
+					6,
+					[
+						7,
+						"std",
+						"fract"
+					],
+					["ny"]
+				]
+			],
+			[
+				13,
+				"ux",
+				[
+					1,
+					[
+						1,
+						"sx",
+						"*",
+						"sx"
+					],
+					"*",
+					[
+						1,
+						[5, "3"],
+						"-",
+						[
+							1,
+							"sx",
+							"*",
+							[5, "2"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"uy",
+				[
+					1,
+					[
+						1,
+						"sy",
+						"*",
+						"sy"
+					],
+					"*",
+					[
+						1,
+						[5, "3"],
+						"-",
+						[
+							1,
+							"sy",
+							"*",
+							[5, "2"]
+						]
+					]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"std",
+					"mix"
+				],
+				[
+					[
+						6,
+						[
+							7,
+							"std",
+							"mix"
+						],
+						[
+							[
+								6,
+								"hashFog",
+								["ix", "iy"]
+							],
+							[
+								6,
+								"hashFog",
+								[[
+									1,
+									"ix",
+									"+",
+									[5, "1"]
+								], "iy"]
+							],
+							"ux"
+						]
+					],
+					[
+						6,
+						[
+							7,
+							"std",
+							"mix"
+						],
+						[
+							[
+								6,
+								"hashFog",
+								["ix", [
+									1,
+									"iy",
+									"+",
+									[5, "1"]
+								]]
+							],
+							[
+								6,
+								"hashFog",
+								[[
+									1,
+									"ix",
+									"+",
+									[5, "1"]
+								], [
+									1,
+									"iy",
+									"+",
+									[5, "1"]
+								]]
+							],
+							"ux"
+						]
+					],
+					"uy"
+				]
+			]]
+		]],
+		"externalNames": ["std", "hashFog"]
+	},
+	externals: () => ({
+		std: std_exports,
+		hashFog
+	})
+}) && $.f)({}));
+var fbm = src_default.fn([f32, f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((nx, ny) => {
+	"use gpu";
+	return __tsover_add(__tsover_add(__tsover_mul(valueNoise2D(nx, ny), .5), __tsover_mul(valueNoise2D(__tsover_add(__tsover_mul(nx, 2), 5.37), __tsover_add(__tsover_mul(ny, 2), 9.13)), .3)), __tsover_mul(valueNoise2D(__tsover_add(__tsover_mul(nx, 4), 1.79), __tsover_add(__tsover_mul(ny, 4), 3.51)), .2));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "nx"
+		}, {
+			"type": "i",
+			"name": "ny"
+		}],
+		"body": [0, [[10, [
+			1,
+			[
+				1,
+				[
+					1,
+					[
+						6,
+						"valueNoise2D",
+						["nx", "ny"]
+					],
+					"*",
+					[5, "0.5"]
+				],
+				"+",
+				[
+					1,
+					[
+						6,
+						"valueNoise2D",
+						[[
+							1,
+							[
+								1,
+								"nx",
+								"*",
+								[5, "2"]
+							],
+							"+",
+							[5, "5.37"]
+						], [
+							1,
+							[
+								1,
+								"ny",
+								"*",
+								[5, "2"]
+							],
+							"+",
+							[5, "9.13"]
+						]]
+					],
+					"*",
+					[5, "0.3"]
+				]
+			],
+			"+",
+			[
+				1,
+				[
+					6,
+					"valueNoise2D",
+					[[
+						1,
+						[
+							1,
+							"nx",
+							"*",
+							[5, "4"]
+						],
+						"+",
+						[5, "1.79"]
+					], [
+						1,
+						[
+							1,
+							"ny",
+							"*",
+							[5, "4"]
+						],
+						"+",
+						[5, "3.51"]
+					]]
+				],
+				"*",
+				[5, "0.2"]
+			]
+		]]]],
+		"externalNames": ["valueNoise2D"]
+	},
+	externals: () => ({ valueNoise2D })
+}) && $.f)({}));
+const initKernel = src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+	"use gpu";
+	const p = fluidLayout.$.params;
+	const idx = __tsover_add(__tsover_mul(cy, u32(N)), cx);
+	const jf = f32(cx);
+	const iF = f32(cy);
+	const sdx = __tsover_mul(fract(__tsover_mul(sin(__tsover_mul(p.seed, 37.31)), 43758.5453)), 97);
+	const sdy = __tsover_mul(fract(__tsover_mul(sin(__tsover_mul(p.seed, 83.17)), 43758.5453)), 97);
+	const nx = __tsover_add(__tsover_mul(__tsover_div(jf, f32(N)), 3), sdx);
+	const ny = __tsover_add(__tsover_mul(__tsover_div(iF, f32(N)), 3), sdy);
+	const fogDens = clamp(__tsover_add(__tsover_mul(fbm(__tsover_add(nx, 31.7), __tsover_add(ny, 53.3)), .75), .25), .15, .9);
+	const colorVar = clamp(fbm(nx, ny), 0, 1);
+	fluidLayout.$.dyeA[idx] = vec4f(fogDens, colorVar, 0, 0);
+	fluidLayout.$.dyeB[idx] = vec4f(fogDens, colorVar, 0, 0);
+	fluidLayout.$.velA[idx] = vec4f(0, 0, 0, 0);
+	fluidLayout.$.velB[idx] = vec4f(0, 0, 0, 0);
+	fluidLayout.$.pressure[idx] = 0;
+	fluidLayout.$.divergence[idx] = 0;
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "cx"
+		}, {
+			"type": "i",
+			"name": "cy"
+		}],
+		"body": [0, [
+			[
+				13,
+				"p",
+				[
+					7,
+					[
+						7,
+						"fluidLayout",
+						"$"
+					],
+					"params"
+				]
+			],
+			[
+				13,
+				"idx",
+				[
+					1,
+					[
+						1,
+						"cy",
+						"*",
+						[
+							6,
+							[
+								7,
+								"d",
+								"u32"
+							],
+							["N"]
+						]
+					],
+					"+",
+					"cx"
+				]
+			],
+			[
+				13,
+				"jf",
+				[
+					6,
+					[
+						7,
+						"d",
+						"f32"
+					],
+					["cx"]
+				]
+			],
+			[
+				13,
+				"iF",
+				[
+					6,
+					[
+						7,
+						"d",
+						"f32"
+					],
+					["cy"]
+				]
+			],
+			[
+				13,
+				"sdx",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"std",
+							"fract"
+						],
+						[[
+							1,
+							[
+								6,
+								[
+									7,
+									"std",
+									"sin"
+								],
+								[[
+									1,
+									[
+										7,
+										"p",
+										"seed"
+									],
+									"*",
+									[5, "37.31"]
+								]]
+							],
+							"*",
+							[5, "43758.5453"]
+						]]
+					],
+					"*",
+					[5, "97"]
+				]
+			],
+			[
+				13,
+				"sdy",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"std",
+							"fract"
+						],
+						[[
+							1,
+							[
+								6,
+								[
+									7,
+									"std",
+									"sin"
+								],
+								[[
+									1,
+									[
+										7,
+										"p",
+										"seed"
+									],
+									"*",
+									[5, "83.17"]
+								]]
+							],
+							"*",
+							[5, "43758.5453"]
+						]]
+					],
+					"*",
+					[5, "97"]
+				]
+			],
+			[
+				13,
+				"nx",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							"jf",
+							"/",
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								["N"]
+							]
+						],
+						"*",
+						[5, "3"]
+					],
+					"+",
+					"sdx"
+				]
+			],
+			[
+				13,
+				"ny",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							"iF",
+							"/",
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								["N"]
+							]
+						],
+						"*",
+						[5, "3"]
+					],
+					"+",
+					"sdy"
+				]
+			],
+			[
+				13,
+				"fogDens",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								1,
+								[
+									6,
+									"fbm",
+									[[
+										1,
+										"nx",
+										"+",
+										[5, "31.7"]
+									], [
+										1,
+										"ny",
+										"+",
+										[5, "53.3"]
+									]]
+								],
+								"*",
+								[5, "0.75"]
+							],
+							"+",
+							[5, "0.25"]
+						],
+						[5, "0.15"],
+						[5, "0.9"]
+					]
+				]
+			],
+			[
+				13,
+				"colorVar",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							6,
+							"fbm",
+							["nx", "ny"]
+						],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				2,
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"dyeA"
+					],
+					"idx"
+				],
+				"=",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec4f"
+					],
+					[
+						"fogDens",
+						"colorVar",
+						[5, "0"],
+						[5, "0"]
+					]
+				]
+			],
+			[
+				2,
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"dyeB"
+					],
+					"idx"
+				],
+				"=",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec4f"
+					],
+					[
+						"fogDens",
+						"colorVar",
+						[5, "0"],
+						[5, "0"]
+					]
+				]
+			],
+			[
+				2,
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"velA"
+					],
+					"idx"
+				],
+				"=",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec4f"
+					],
+					[
+						[5, "0"],
+						[5, "0"],
+						[5, "0"],
+						[5, "0"]
+					]
+				]
+			],
+			[
+				2,
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"velB"
+					],
+					"idx"
+				],
+				"=",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec4f"
+					],
+					[
+						[5, "0"],
+						[5, "0"],
+						[5, "0"],
+						[5, "0"]
+					]
+				]
+			],
+			[
+				2,
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"pressure"
+					],
+					"idx"
+				],
+				"=",
+				[5, "0"]
+			],
+			[
+				2,
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"divergence"
+					],
+					"idx"
+				],
+				"=",
+				[5, "0"]
+			]
+		]],
+		"externalNames": [
+			"fluidLayout",
+			"d",
+			"N",
+			"std",
+			"fbm"
+		]
+	},
+	externals: () => ({
+		fluidLayout,
+		d: data_exports,
+		N,
+		std: std_exports,
+		fbm
+	})
+}) && $.f)({})).$name("fogInit");
+const forceKernel = src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+	"use gpu";
+	const p = fluidLayout.$.params;
+	const idx = __tsover_add(__tsover_mul(cy, u32(N)), cx);
+	const jf = __tsover_add(f32(cx), .5);
+	const iF = __tsover_add(f32(cy), .5);
+	const x = __tsover_mul(__tsover_div(jf, f32(N)), TAU);
+	const y = __tsover_mul(__tsover_div(iF, f32(N)), TAU);
+	const t = p.time;
+	const vel = fluidLayout.$.velA[idx];
+	const fx = __tsover_mul(__tsover_mul(__tsover_mul(__tsover_add(__tsover_mul(sin(__tsover_add(__tsover_mul(x, 2), __tsover_mul(t, .31))), cos(__tsover_add(__tsover_mul(y, 1.5), __tsover_mul(t, .23)))), __tsover_mul(sin(__tsover_add(__tsover_add(__tsover_mul(x, .7), __tsover_mul(y, 1.3)), __tsover_mul(t, .17))), .4)), p.turbulence), __tsover_mul(N, .04)), p.dt);
+	const fy = __tsover_mul(__tsover_mul(__tsover_mul(__tsover_add(__tsover_mul(cos(__tsover_add(__tsover_mul(x, 1.5), __tsover_mul(t, .27))), sin(__tsover_add(__tsover_mul(y, 2), __tsover_mul(t, .19)))), __tsover_mul(cos(__tsover_add(__tsover_add(__tsover_mul(x, 1.1), __tsover_mul(y, .9)), __tsover_mul(t, .21))), .4)), p.turbulence), __tsover_mul(N, .04)), p.dt);
+	const cdx = __tsover_sub(jf, p.cursorX);
+	const cdy = __tsover_sub(iF, p.cursorY);
+	const cursorDistSq = __tsover_add(__tsover_mul(cdx, cdx), __tsover_mul(cdy, cdy));
+	const cursorInf = __tsover_mul(gaussianBrushSq(cursorDistSq, max(p.mouseRadSq, f32(1))), p.mouseActive);
+	fluidLayout.$.velA[idx] = vec4f(__tsover_add(__tsover_add(vel.x, fx), __tsover_mul(p.cursorVelX, cursorInf)), __tsover_add(__tsover_add(vel.y, fy), __tsover_mul(p.cursorVelY, cursorInf)), vel.z, 0);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "cx"
+		}, {
+			"type": "i",
+			"name": "cy"
+		}],
+		"body": [0, [
+			[
+				13,
+				"p",
+				[
+					7,
+					[
+						7,
+						"fluidLayout",
+						"$"
+					],
+					"params"
+				]
+			],
+			[
+				13,
+				"idx",
+				[
+					1,
+					[
+						1,
+						"cy",
+						"*",
+						[
+							6,
+							[
+								7,
+								"d",
+								"u32"
+							],
+							["N"]
+						]
+					],
+					"+",
+					"cx"
+				]
+			],
+			[
+				13,
+				"jf",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"d",
+							"f32"
+						],
+						["cx"]
+					],
+					"+",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"iF",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"d",
+							"f32"
+						],
+						["cy"]
+					],
+					"+",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"x",
+				[
+					1,
+					[
+						1,
+						"jf",
+						"/",
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							["N"]
+						]
+					],
+					"*",
+					"TAU"
+				]
+			],
+			[
+				13,
+				"y",
+				[
+					1,
+					[
+						1,
+						"iF",
+						"/",
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							["N"]
+						]
+					],
+					"*",
+					"TAU"
+				]
+			],
+			[
+				13,
+				"t",
+				[
+					7,
+					"p",
+					"time"
+				]
+			],
+			[
+				13,
+				"vel",
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"velA"
+					],
+					"idx"
+				]
+			],
+			[
+				13,
+				"fx",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									[
+										6,
+										[
+											7,
+											"std",
+											"sin"
+										],
+										[[
+											1,
+											[
+												1,
+												"x",
+												"*",
+												[5, "2"]
+											],
+											"+",
+											[
+												1,
+												"t",
+												"*",
+												[5, "0.31"]
+											]
+										]]
+									],
+									"*",
+									[
+										6,
+										[
+											7,
+											"std",
+											"cos"
+										],
+										[[
+											1,
+											[
+												1,
+												"y",
+												"*",
+												[5, "1.5"]
+											],
+											"+",
+											[
+												1,
+												"t",
+												"*",
+												[5, "0.23"]
+											]
+										]]
+									]
+								],
+								"+",
+								[
+									1,
+									[
+										6,
+										[
+											7,
+											"std",
+											"sin"
+										],
+										[[
+											1,
+											[
+												1,
+												[
+													1,
+													"x",
+													"*",
+													[5, "0.7"]
+												],
+												"+",
+												[
+													1,
+													"y",
+													"*",
+													[5, "1.3"]
+												]
+											],
+											"+",
+											[
+												1,
+												"t",
+												"*",
+												[5, "0.17"]
+											]
+										]]
+									],
+									"*",
+									[5, "0.4"]
+								]
+							],
+							"*",
+							[
+								7,
+								"p",
+								"turbulence"
+							]
+						],
+						"*",
+						[
+							1,
+							"N",
+							"*",
+							[5, "0.04"]
+						]
+					],
+					"*",
+					[
+						7,
+						"p",
+						"dt"
+					]
+				]
+			],
+			[
+				13,
+				"fy",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									[
+										6,
+										[
+											7,
+											"std",
+											"cos"
+										],
+										[[
+											1,
+											[
+												1,
+												"x",
+												"*",
+												[5, "1.5"]
+											],
+											"+",
+											[
+												1,
+												"t",
+												"*",
+												[5, "0.27"]
+											]
+										]]
+									],
+									"*",
+									[
+										6,
+										[
+											7,
+											"std",
+											"sin"
+										],
+										[[
+											1,
+											[
+												1,
+												"y",
+												"*",
+												[5, "2"]
+											],
+											"+",
+											[
+												1,
+												"t",
+												"*",
+												[5, "0.19"]
+											]
+										]]
+									]
+								],
+								"+",
+								[
+									1,
+									[
+										6,
+										[
+											7,
+											"std",
+											"cos"
+										],
+										[[
+											1,
+											[
+												1,
+												[
+													1,
+													"x",
+													"*",
+													[5, "1.1"]
+												],
+												"+",
+												[
+													1,
+													"y",
+													"*",
+													[5, "0.9"]
+												]
+											],
+											"+",
+											[
+												1,
+												"t",
+												"*",
+												[5, "0.21"]
+											]
+										]]
+									],
+									"*",
+									[5, "0.4"]
+								]
+							],
+							"*",
+							[
+								7,
+								"p",
+								"turbulence"
+							]
+						],
+						"*",
+						[
+							1,
+							"N",
+							"*",
+							[5, "0.04"]
+						]
+					],
+					"*",
+					[
+						7,
+						"p",
+						"dt"
+					]
+				]
+			],
+			[
+				13,
+				"cdx",
+				[
+					1,
+					"jf",
+					"-",
+					[
+						7,
+						"p",
+						"cursorX"
+					]
+				]
+			],
+			[
+				13,
+				"cdy",
+				[
+					1,
+					"iF",
+					"-",
+					[
+						7,
+						"p",
+						"cursorY"
+					]
+				]
+			],
+			[
+				13,
+				"cursorDistSq",
+				[
+					1,
+					[
+						1,
+						"cdx",
+						"*",
+						"cdx"
+					],
+					"+",
+					[
+						1,
+						"cdy",
+						"*",
+						"cdy"
+					]
+				]
+			],
+			[
+				13,
+				"cursorInf",
+				[
+					1,
+					[
+						6,
+						"gaussianBrushSq",
+						["cursorDistSq", [
+							6,
+							[
+								7,
+								"std",
+								"max"
+							],
+							[[
+								7,
+								"p",
+								"mouseRadSq"
+							], [
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[5, "1"]]
+							]]
+						]]
+					],
+					"*",
+					[
+						7,
+						"p",
+						"mouseActive"
+					]
+				]
+			],
+			[
+				2,
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"velA"
+					],
+					"idx"
+				],
+				"=",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec4f"
+					],
+					[
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									"vel",
+									"x"
+								],
+								"+",
+								"fx"
+							],
+							"+",
+							[
+								1,
+								[
+									7,
+									"p",
+									"cursorVelX"
+								],
+								"*",
+								"cursorInf"
+							]
+						],
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									"vel",
+									"y"
+								],
+								"+",
+								"fy"
+							],
+							"+",
+							[
+								1,
+								[
+									7,
+									"p",
+									"cursorVelY"
+								],
+								"*",
+								"cursorInf"
+							]
+						],
+						[
+							7,
+							"vel",
+							"z"
+						],
+						[5, "0"]
+					]
+				]
+			]
+		]],
+		"externalNames": [
+			"fluidLayout",
+			"d",
+			"N",
+			"TAU",
+			"std",
+			"gaussianBrushSq"
+		]
+	},
+	externals: () => ({
+		fluidLayout,
+		d: data_exports,
+		N,
+		TAU,
+		std: std_exports,
+		gaussianBrushSq
+	})
+}) && $.f)({})).$name("fogForce");
+var solverKernels = buildStableFluidsKernels(fluidLayout, {
+	n: N,
+	namePrefix: "fog",
+	boundary: "toroidal",
+	dye: "densityAge",
+	velocityCap: INTERNAL_MAX_VEL
+});
+const { curl: curlKernel, vorticity: vorticityKernel, divergence: divergenceKernel, jacobi: jacobiKernel, gradSubtract: gradSubtractKernel, advectVel: advectVelKernel, copyVel: copyVelKernel, advectDye: advectDensKernel, copyDye: copyDensKernel } = solverKernels;
+const colorRestoreKernel = src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+	"use gpu";
+	const p = fluidLayout.$.params;
+	const idx = __tsover_add(__tsover_mul(cy, u32(N)), cx);
+	const jf = f32(cx);
+	const iF = f32(cy);
+	const sdx = __tsover_mul(fract(__tsover_mul(sin(__tsover_mul(p.seed, 37.31)), 43758.5453)), 97);
+	const sdy = __tsover_mul(fract(__tsover_mul(sin(__tsover_mul(p.seed, 83.17)), 43758.5453)), 97);
+	const refRaw = fbm(__tsover_add(__tsover_mul(__tsover_div(jf, f32(N)), 3), sdx), __tsover_add(__tsover_mul(__tsover_div(iF, f32(N)), 3), sdy));
+	const invBlend = __tsover_sub(1, p.blending);
+	const contrastBoost = __tsover_add(1, __tsover_mul(invBlend, 5));
+	const refBoosted = clamp(__tsover_add(__tsover_mul(__tsover_sub(refRaw, .5), contrastBoost), .5), 0, 1);
+	const cell = fluidLayout.$.dyeA[idx];
+	const rateMult = __tsover_add(1, __tsover_mul(invBlend, 2.5));
+	const blendRate = min(__tsover_mul(__tsover_mul(p.dt, .5), rateMult), .3);
+	fluidLayout.$.dyeA[idx] = vec4f(cell.x, mix(cell.y, refBoosted, blendRate), 0, 0);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "cx"
+		}, {
+			"type": "i",
+			"name": "cy"
+		}],
+		"body": [0, [
+			[
+				13,
+				"p",
+				[
+					7,
+					[
+						7,
+						"fluidLayout",
+						"$"
+					],
+					"params"
+				]
+			],
+			[
+				13,
+				"idx",
+				[
+					1,
+					[
+						1,
+						"cy",
+						"*",
+						[
+							6,
+							[
+								7,
+								"d",
+								"u32"
+							],
+							["N"]
+						]
+					],
+					"+",
+					"cx"
+				]
+			],
+			[
+				13,
+				"jf",
+				[
+					6,
+					[
+						7,
+						"d",
+						"f32"
+					],
+					["cx"]
+				]
+			],
+			[
+				13,
+				"iF",
+				[
+					6,
+					[
+						7,
+						"d",
+						"f32"
+					],
+					["cy"]
+				]
+			],
+			[
+				13,
+				"sdx",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"std",
+							"fract"
+						],
+						[[
+							1,
+							[
+								6,
+								[
+									7,
+									"std",
+									"sin"
+								],
+								[[
+									1,
+									[
+										7,
+										"p",
+										"seed"
+									],
+									"*",
+									[5, "37.31"]
+								]]
+							],
+							"*",
+							[5, "43758.5453"]
+						]]
+					],
+					"*",
+					[5, "97"]
+				]
+			],
+			[
+				13,
+				"sdy",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"std",
+							"fract"
+						],
+						[[
+							1,
+							[
+								6,
+								[
+									7,
+									"std",
+									"sin"
+								],
+								[[
+									1,
+									[
+										7,
+										"p",
+										"seed"
+									],
+									"*",
+									[5, "83.17"]
+								]]
+							],
+							"*",
+							[5, "43758.5453"]
+						]]
+					],
+					"*",
+					[5, "97"]
+				]
+			],
+			[
+				13,
+				"nx",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							"jf",
+							"/",
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								["N"]
+							]
+						],
+						"*",
+						[5, "3"]
+					],
+					"+",
+					"sdx"
+				]
+			],
+			[
+				13,
+				"ny",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							"iF",
+							"/",
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								["N"]
+							]
+						],
+						"*",
+						[5, "3"]
+					],
+					"+",
+					"sdy"
+				]
+			],
+			[
+				13,
+				"refRaw",
+				[
+					6,
+					"fbm",
+					["nx", "ny"]
+				]
+			],
+			[
+				13,
+				"invBlend",
+				[
+					1,
+					[5, "1"],
+					"-",
+					[
+						7,
+						"p",
+						"blending"
+					]
+				]
+			],
+			[
+				13,
+				"contrastBoost",
+				[
+					1,
+					[5, "1"],
+					"+",
+					[
+						1,
+						"invBlend",
+						"*",
+						[5, "5"]
+					]
+				]
+			],
+			[
+				13,
+				"refBoosted",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									"refRaw",
+									"-",
+									[5, "0.5"]
+								],
+								"*",
+								"contrastBoost"
+							],
+							"+",
+							[5, "0.5"]
+						],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"cell",
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"dyeA"
+					],
+					"idx"
+				]
+			],
+			[
+				13,
+				"rateMult",
+				[
+					1,
+					[5, "1"],
+					"+",
+					[
+						1,
+						"invBlend",
+						"*",
+						[5, "2.5"]
+					]
+				]
+			],
+			[
+				13,
+				"blendRate",
+				[
+					6,
+					[
+						7,
+						"std",
+						"min"
+					],
+					[[
+						1,
+						[
+							1,
+							[
+								7,
+								"p",
+								"dt"
+							],
+							"*",
+							[5, "0.5"]
+						],
+						"*",
+						"rateMult"
+					], [5, "0.3"]]
+				]
+			],
+			[
+				2,
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"dyeA"
+					],
+					"idx"
+				],
+				"=",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec4f"
+					],
+					[
+						[
+							7,
+							"cell",
+							"x"
+						],
+						[
+							6,
+							[
+								7,
+								"std",
+								"mix"
+							],
+							[
+								[
+									7,
+									"cell",
+									"y"
+								],
+								"refBoosted",
+								"blendRate"
+							]
+						],
+						[5, "0"],
+						[5, "0"]
+					]
+				]
+			]
+		]],
+		"externalNames": [
+			"fluidLayout",
+			"d",
+			"N",
+			"std",
+			"fbm"
+		]
+	},
+	externals: () => ({
+		fluidLayout,
+		d: data_exports,
+		N,
+		std: std_exports,
+		fbm
+	})
+}) && $.f)({})).$name("fogColorRestore");
+const outputKernel = buildFluidOutputKernel(outputLayout, {
+	n: N,
+	namePrefix: "fog",
+	dye: "densityAge"
+});
+const componentDefinition = {
+	name: "Fog",
+	boundingBoxDeclaration: { aspectRatio: null },
+	category: "Interactive",
+	description: "Fog that fills the screen and interacts with the mouse",
+	usesPointer: true,
+	props: {
+		colorA: {
+			default: "#e0e0e0",
+			transform: transformColor,
+			description: "Primary fog color",
+			ui: {
+				type: "color",
+				label: "Color A",
+				group: "Colors"
+			}
+		},
+		colorB: {
+			default: "#888888",
+			transform: transformColor,
+			description: "Secondary fog color — creates variation across the field",
+			ui: {
+				type: "color",
+				label: "Color B",
+				group: "Colors"
+			}
+		},
+		seed: {
+			default: 0,
+			description: "Deterministic starting pattern — different seeds produce different fog configurations",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 999,
+				step: 1,
+				label: "Seed",
+				group: "Field"
+			}
+		},
+		speed: {
+			default: 1,
+			description: "Simulation speed multiplier",
+			ui: {
+				type: "range",
+				min: .1,
+				max: 3,
+				step: .1,
+				label: "Speed",
+				group: "Field"
+			}
+		},
+		turbulence: {
+			default: 1,
+			description: "Ambient motion strength",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 3,
+				step: .01,
+				label: "Turbulence",
+				group: "Field"
+			}
+		},
+		detail: {
+			default: 15,
+			description: "Fine-scale swirling structure — higher values produce more intricate wisps and vortices",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 50,
+				step: 1,
+				label: "Detail",
+				group: "Field"
+			}
+		},
+		blending: {
+			default: .3,
+			description: "How much the two colors blend together — 0 behaves like oil & water (colors stay distinct with sharp boundaries), 1 behaves like food coloring (colors fully mix)",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Blending",
+				group: "Field"
+			}
+		},
+		mouseInfluence: {
+			default: .1,
+			description: "Strength of cursor influence — move the cursor to push fog",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 2,
+				step: .01,
+				label: "Cursor Influence",
+				group: "Interaction"
+			}
+		},
+		mouseRadius: {
+			default: .1,
+			description: "Radius of cursor influence area",
+			ui: {
+				type: "range",
+				min: .02,
+				max: .5,
+				step: .01,
+				label: "Cursor Radius",
+				group: "Interaction"
+			}
+		},
+		colorSpace: {
+			default: "linear",
+			transform: transformColorSpace,
+			compileTime: true,
+			description: "Color space for color interpolation",
+			ui: {
+				type: "select",
+				options: colorSpaceOptions,
+				label: "Color Space",
+				group: "Colors"
+			}
+		}
+	},
+	compute: (params) => {
+		const { gpu, getCpuValue, registerComputeTexture, onCleanup } = params;
+		const root = gpu?.root;
+		if (!root) return null;
+		const velA = createStateBuffer(root, vec4f, COUNT);
+		const velB = createStateBuffer(root, vec4f, COUNT);
+		const dyeA = createStateBuffer(root, vec4f, COUNT);
+		const dyeB = createStateBuffer(root, vec4f, COUNT);
+		const pressure = createStateBuffer(root, f32, COUNT);
+		const divergence = createStateBuffer(root, f32, COUNT);
+		const outTex = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
+			size: [N, N],
+			format: STATE_FORMAT
+		}).$usage("storage", "sampled"), "outTex");
+		onCleanup(() => outTex.destroy());
+		const fogTexture = registerComputeTexture(outTex);
+		const paramsU = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(FogParams), "paramsU");
+		const size = [N, N];
+		const fluidBg = root.createBindGroup(fluidLayout, {
+			velA,
+			velB,
+			dyeA,
+			dyeB,
+			pressure,
+			divergence,
+			params: paramsU.buffer
+		});
+		const outputBg = root.createBindGroup(outputLayout, {
+			dyeA,
+			outTex
+		});
+		const mk = (kernel) => createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+			"use gpu";
+			kernel(cx, cy);
+		}), {
+			v: 1,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "cx"
+				}, {
+					"type": "i",
+					"name": "cy"
+				}],
+				"body": [0, [[
+					6,
+					"kernel",
+					["cx", "cy"]
+				]]],
+				"externalNames": ["kernel"]
+			},
+			externals: () => ({ kernel })
+		}) && $.f)({}), {
+			size,
+			bindGroup: fluidBg
+		});
+		const initPass = mk(initKernel);
+		const force = mk(forceKernel);
+		const colorRestore = mk(colorRestoreKernel);
+		const solver = createStableFluidsPasses(root, solverKernels, {
+			n: N,
+			bindGroup: fluidBg
+		});
+		const output = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+			"use gpu";
+			outputKernel(cx, cy);
+		}), {
+			v: 1,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "cx"
+				}, {
+					"type": "i",
+					"name": "cy"
+				}],
+				"body": [0, [[
+					6,
+					"outputKernel",
+					["cx", "cy"]
+				]]],
+				"externalNames": ["outputKernel"]
+			},
+			externals: () => ({ outputKernel })
+		}) && $.f)({}), {
+			size,
+			bindGroup: outputBg
+		});
+		const solve = (nodes, jacobiIters) => {
+			nodes.push(force, ...solver.solveSteps({ jacobiIters }), colorRestore);
+		};
+		let lastTime = Date.now();
+		let elapsed = 0;
+		let lastSeed = -1;
+		let initialized = false;
+		const pointer = createPointerVelocityTracker({ minDrag: 5e-4 });
+		return {
+			outputs: { fogTexture },
+			getComputeNodes: (frameParams) => {
+				const fp = frameParams;
+				const now = Date.now();
+				const rawDt = Math.min(fp.deltaTime ?? (now - lastTime) / 1e3, .033);
+				lastTime = now;
+				if (rawDt < .001) return null;
+				const num = (key, fallback) => {
+					const v = getCpuValue(key);
+					return typeof v === "number" ? v : fallback;
+				};
+				const dt = rawDt * num("speed", 1);
+				elapsed += rawDt;
+				const turbulence = num("turbulence", 1);
+				const curlStrength = num("detail", 15);
+				const blending = num("blending", .3);
+				const seed = num("seed", 0);
+				const nodes = [];
+				if (!initialized || seed !== lastSeed) {
+					initialized = true;
+					lastSeed = seed;
+					nodes.push(() => paramsU.write({
+						dt: .1,
+						time: 0,
+						seed,
+						turbulence,
+						curlStrength,
+						velFade: VELOCITY_DISSIPATION,
+						blending,
+						cursorX: 0,
+						cursorY: 0,
+						cursorVelX: 0,
+						cursorVelY: 0,
+						mouseActive: 0,
+						mouseRadSq: 1
+					}));
+					nodes.push(initPass);
+					let warmTime = Math.random() * 60;
+					for (let w = 0; w < WARM_STEPS; w++) {
+						const wt = warmTime;
+						warmTime += .1;
+						nodes.push(() => paramsU.write({
+							dt: .1,
+							time: wt,
+							seed,
+							turbulence,
+							curlStrength,
+							velFade: VELOCITY_DISSIPATION,
+							blending,
+							cursorX: 0,
+							cursorY: 0,
+							cursorVelX: 0,
+							cursorVelY: 0,
+							mouseActive: 0,
+							mouseRadSq: 1
+						}));
+						solve(nodes, WARM_JACOBI_ITERS);
+					}
+					elapsed = warmTime;
+				}
+				const mouseInf = num("mouseInfluence", .1);
+				const mouseRadGrid = num("mouseRadius", .1) * N;
+				const ptr = pointer.update(fp.pointer, rawDt);
+				const active = ptr.moving && mouseInf > 0;
+				nodes.push(() => paramsU.write({
+					dt,
+					time: elapsed,
+					seed,
+					turbulence,
+					curlStrength,
+					velFade: VELOCITY_DISSIPATION,
+					blending,
+					cursorX: active ? ptr.x * N : 0,
+					cursorY: active ? ptr.y * N : 0,
+					cursorVelX: active ? ptr.dx * N * 15 * mouseInf : 0,
+					cursorVelY: active ? ptr.dy * N * 15 * mouseInf : 0,
+					mouseActive: active ? 1 : 0,
+					mouseRadSq: mouseRadGrid * mouseRadGrid
+				}));
+				solve(nodes, JACOBI_ITERS);
+				nodes.push(output);
+				return nodes;
+			}
+		};
+	},
+	fragment: ({ ctx, computeOutputs, propValues, uniforms }) => {
+		const fogField = computeOutputs?.fogTexture;
+		if (!fogField) return ZERO;
+		const s = fogField.sample(ctx.uv, "linearClamp");
+		const fogDensity = s.member("x");
+		const colorVar = s.member("y");
+		const colorSpaceMode = propValues.colorSpace ?? 0;
+		const fogColor = call(cm.mixColorsVariants[colorSpaceMode] ?? cm.mixColorsLinear, "mixColors", [
+			uniforms.colorA,
+			uniforms.colorB,
+			colorVar
+		]);
+		return vec4(fogColor.member("rgb"), fogColor.member("a").mul(fogDensity));
+	}
+};
+var Fog_default = componentDefinition;
+export { componentDefinition as a, curlKernel as c, gradSubtractKernel as d, initKernel as f, vorticityKernel as h, colorRestoreKernel as i, divergenceKernel as l, outputKernel as m, advectDensKernel as n, copyDensKernel as o, jacobiKernel as p, advectVelKernel as r, copyVelKernel as s, Fog_default as t, forceKernel as u };