shaders 3.1.462 → 3.2.464

package/dist/core/Fog-Df_ScuGu.js

@@ -1,1992 +0,0 @@
-import { Dt as sin, Gt as textureStorage2d, I as colorMixing_exports, Kt as arrayOf, Lt as vec4f, Mt as vec2f, _t as max, b as vec4, ct as clamp, d as ZERO, et as typegpu_default, ht as fract, ln as u32, lt as cos, m as call, mt as floor, qt as struct, sn as f32, vt as min, yt as mix } from "./edges-CV-BHMpI.js";
-import { M as createGuardedCompute, P as createStateBuffer } from "./device-DKcu50_C.js";
-import { o as TAU$1 } from "./constants-BKlzQFdJ.js";
-import { a as gaussianBrushSq, c as createStableFluidsPasses, o as buildFluidOutputKernel, s as buildStableFluidsKernels } from "./porters-j7yWJYy2.js";
-import { o as hash11, s as hash12 } from "./noise-eXd1Bfrw.js";
-import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-u-UZrXjj.js";
-import { n as createPointerVelocityTracker } from "./pointer-DKBz1Qcc.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))(typegpu_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))(typegpu_default.bindGroupLayout({
-	dyeA: {
-		storage: arrayOf(vec4f, COUNT),
-		access: "readonly"
-	},
-	outTex: { storageTexture: textureStorage2d(STATE_FORMAT, "write-only") }
-}), "outputLayout");
-var hashFog = typegpu_default.fn([f32, f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((px, py) => {
-	"use gpu";
-	return hash12(vec2f(px, py));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "px"
-		}, {
-			"type": "i",
-			"name": "py"
-		}],
-		"body": [0, [[10, [
-			6,
-			"noise.hash12",
-			[[
-				6,
-				"d.vec2f",
-				["px", "py"]
-			]]
-		]]]]
-	},
-	externals: {
-		"noise.hash12": () => hash12,
-		"d.vec2f": () => vec2f
-	}
-}) && $.f)({}));
-var valueNoise2D = typegpu_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: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "nx"
-		}, {
-			"type": "i",
-			"name": "ny"
-		}],
-		"body": [0, [
-			[
-				13,
-				"ix",
-				[
-					6,
-					"std.floor",
-					["nx"]
-				]
-			],
-			[
-				13,
-				"iy",
-				[
-					6,
-					"std.floor",
-					["ny"]
-				]
-			],
-			[
-				13,
-				"sx",
-				[
-					6,
-					"std.fract",
-					["nx"]
-				]
-			],
-			[
-				13,
-				"sy",
-				[
-					6,
-					"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,
-				"std.mix",
-				[
-					[
-						6,
-						"std.mix",
-						[
-							[
-								6,
-								"hashFog",
-								["ix", "iy"]
-							],
-							[
-								6,
-								"hashFog",
-								[[
-									1,
-									"ix",
-									"+",
-									[5, "1"]
-								], "iy"]
-							],
-							"ux"
-						]
-					],
-					[
-						6,
-						"std.mix",
-						[
-							[
-								6,
-								"hashFog",
-								["ix", [
-									1,
-									"iy",
-									"+",
-									[5, "1"]
-								]]
-							],
-							[
-								6,
-								"hashFog",
-								[[
-									1,
-									"ix",
-									"+",
-									[5, "1"]
-								], [
-									1,
-									"iy",
-									"+",
-									[5, "1"]
-								]]
-							],
-							"ux"
-						]
-					],
-					"uy"
-				]
-			]]
-		]]
-	},
-	externals: {
-		"std.floor": () => floor,
-		"std.fract": () => fract,
-		"std.mix": () => mix,
-		"hashFog": () => hashFog
-	}
-}) && $.f)({}));
-var fbm = typegpu_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: 2,
-	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"]
-			]
-		]]]]
-	},
-	externals: { "valueNoise2D": () => valueNoise2D }
-}) && $.f)({}));
-const initKernel = typegpu_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(hash11(__tsover_mul(p.seed, 37.31)), 97);
-	const sdy = __tsover_mul(hash11(__tsover_mul(p.seed, 83.17)), 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: 2,
-	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,
-							"d.u32",
-							["N"]
-						]
-					],
-					"+",
-					"cx"
-				]
-			],
-			[
-				13,
-				"jf",
-				[
-					6,
-					"d.f32",
-					["cx"]
-				]
-			],
-			[
-				13,
-				"iF",
-				[
-					6,
-					"d.f32",
-					["cy"]
-				]
-			],
-			[
-				13,
-				"sdx",
-				[
-					1,
-					[
-						6,
-						"noise.hash11",
-						[[
-							1,
-							[
-								7,
-								"p",
-								"seed"
-							],
-							"*",
-							[5, "37.31"]
-						]]
-					],
-					"*",
-					[5, "97"]
-				]
-			],
-			[
-				13,
-				"sdy",
-				[
-					1,
-					[
-						6,
-						"noise.hash11",
-						[[
-							1,
-							[
-								7,
-								"p",
-								"seed"
-							],
-							"*",
-							[5, "83.17"]
-						]]
-					],
-					"*",
-					[5, "97"]
-				]
-			],
-			[
-				13,
-				"nx",
-				[
-					1,
-					[
-						1,
-						[
-							1,
-							"jf",
-							"/",
-							[
-								6,
-								"d.f32",
-								["N"]
-							]
-						],
-						"*",
-						[5, "3"]
-					],
-					"+",
-					"sdx"
-				]
-			],
-			[
-				13,
-				"ny",
-				[
-					1,
-					[
-						1,
-						[
-							1,
-							"iF",
-							"/",
-							[
-								6,
-								"d.f32",
-								["N"]
-							]
-						],
-						"*",
-						[5, "3"]
-					],
-					"+",
-					"sdy"
-				]
-			],
-			[
-				13,
-				"fogDens",
-				[
-					6,
-					"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,
-					"std.clamp",
-					[
-						[
-							6,
-							"fbm",
-							["nx", "ny"]
-						],
-						[5, "0"],
-						[5, "1"]
-					]
-				]
-			],
-			[
-				2,
-				[
-					8,
-					[
-						7,
-						[
-							7,
-							"fluidLayout",
-							"$"
-						],
-						"dyeA"
-					],
-					"idx"
-				],
-				"=",
-				[
-					6,
-					"d.vec4f",
-					[
-						"fogDens",
-						"colorVar",
-						[5, "0"],
-						[5, "0"]
-					]
-				]
-			],
-			[
-				2,
-				[
-					8,
-					[
-						7,
-						[
-							7,
-							"fluidLayout",
-							"$"
-						],
-						"dyeB"
-					],
-					"idx"
-				],
-				"=",
-				[
-					6,
-					"d.vec4f",
-					[
-						"fogDens",
-						"colorVar",
-						[5, "0"],
-						[5, "0"]
-					]
-				]
-			],
-			[
-				2,
-				[
-					8,
-					[
-						7,
-						[
-							7,
-							"fluidLayout",
-							"$"
-						],
-						"velA"
-					],
-					"idx"
-				],
-				"=",
-				[
-					6,
-					"d.vec4f",
-					[
-						[5, "0"],
-						[5, "0"],
-						[5, "0"],
-						[5, "0"]
-					]
-				]
-			],
-			[
-				2,
-				[
-					8,
-					[
-						7,
-						[
-							7,
-							"fluidLayout",
-							"$"
-						],
-						"velB"
-					],
-					"idx"
-				],
-				"=",
-				[
-					6,
-					"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"]
-			]
-		]]
-	},
-	externals: {
-		"fluidLayout": () => fluidLayout,
-		"d.u32": () => u32,
-		"N": () => N,
-		"d.f32": () => f32,
-		"noise.hash11": () => hash11,
-		"std.clamp": () => clamp,
-		"fbm": () => fbm,
-		"d.vec4f": () => vec4f
-	}
-}) && $.f)({})).$name("fogInit");
-const forceKernel = typegpu_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: 2,
-	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,
-							"d.u32",
-							["N"]
-						]
-					],
-					"+",
-					"cx"
-				]
-			],
-			[
-				13,
-				"jf",
-				[
-					1,
-					[
-						6,
-						"d.f32",
-						["cx"]
-					],
-					"+",
-					[5, "0.5"]
-				]
-			],
-			[
-				13,
-				"iF",
-				[
-					1,
-					[
-						6,
-						"d.f32",
-						["cy"]
-					],
-					"+",
-					[5, "0.5"]
-				]
-			],
-			[
-				13,
-				"x",
-				[
-					1,
-					[
-						1,
-						"jf",
-						"/",
-						[
-							6,
-							"d.f32",
-							["N"]
-						]
-					],
-					"*",
-					"TAU"
-				]
-			],
-			[
-				13,
-				"y",
-				[
-					1,
-					[
-						1,
-						"iF",
-						"/",
-						[
-							6,
-							"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,
-										"std.sin",
-										[[
-											1,
-											[
-												1,
-												"x",
-												"*",
-												[5, "2"]
-											],
-											"+",
-											[
-												1,
-												"t",
-												"*",
-												[5, "0.31"]
-											]
-										]]
-									],
-									"*",
-									[
-										6,
-										"std.cos",
-										[[
-											1,
-											[
-												1,
-												"y",
-												"*",
-												[5, "1.5"]
-											],
-											"+",
-											[
-												1,
-												"t",
-												"*",
-												[5, "0.23"]
-											]
-										]]
-									]
-								],
-								"+",
-								[
-									1,
-									[
-										6,
-										"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,
-										"std.cos",
-										[[
-											1,
-											[
-												1,
-												"x",
-												"*",
-												[5, "1.5"]
-											],
-											"+",
-											[
-												1,
-												"t",
-												"*",
-												[5, "0.27"]
-											]
-										]]
-									],
-									"*",
-									[
-										6,
-										"std.sin",
-										[[
-											1,
-											[
-												1,
-												"y",
-												"*",
-												[5, "2"]
-											],
-											"+",
-											[
-												1,
-												"t",
-												"*",
-												[5, "0.19"]
-											]
-										]]
-									]
-								],
-								"+",
-								[
-									1,
-									[
-										6,
-										"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,
-							"std.max",
-							[[
-								7,
-								"p",
-								"mouseRadSq"
-							], [
-								6,
-								"d.f32",
-								[[5, "1"]]
-							]]
-						]]
-					],
-					"*",
-					[
-						7,
-						"p",
-						"mouseActive"
-					]
-				]
-			],
-			[
-				2,
-				[
-					8,
-					[
-						7,
-						[
-							7,
-							"fluidLayout",
-							"$"
-						],
-						"velA"
-					],
-					"idx"
-				],
-				"=",
-				[
-					6,
-					"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"]
-					]
-				]
-			]
-		]]
-	},
-	externals: {
-		"fluidLayout": () => fluidLayout,
-		"d.u32": () => u32,
-		"N": () => N,
-		"d.f32": () => f32,
-		"TAU": () => TAU,
-		"std.sin": () => sin,
-		"std.cos": () => cos,
-		"gaussianBrushSq": () => gaussianBrushSq,
-		"std.max": () => max,
-		"d.vec4f": () => vec4f
-	}
-}) && $.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 = typegpu_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(hash11(__tsover_mul(p.seed, 37.31)), 97);
-	const sdy = __tsover_mul(hash11(__tsover_mul(p.seed, 83.17)), 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: 2,
-	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,
-							"d.u32",
-							["N"]
-						]
-					],
-					"+",
-					"cx"
-				]
-			],
-			[
-				13,
-				"jf",
-				[
-					6,
-					"d.f32",
-					["cx"]
-				]
-			],
-			[
-				13,
-				"iF",
-				[
-					6,
-					"d.f32",
-					["cy"]
-				]
-			],
-			[
-				13,
-				"sdx",
-				[
-					1,
-					[
-						6,
-						"noise.hash11",
-						[[
-							1,
-							[
-								7,
-								"p",
-								"seed"
-							],
-							"*",
-							[5, "37.31"]
-						]]
-					],
-					"*",
-					[5, "97"]
-				]
-			],
-			[
-				13,
-				"sdy",
-				[
-					1,
-					[
-						6,
-						"noise.hash11",
-						[[
-							1,
-							[
-								7,
-								"p",
-								"seed"
-							],
-							"*",
-							[5, "83.17"]
-						]]
-					],
-					"*",
-					[5, "97"]
-				]
-			],
-			[
-				13,
-				"nx",
-				[
-					1,
-					[
-						1,
-						[
-							1,
-							"jf",
-							"/",
-							[
-								6,
-								"d.f32",
-								["N"]
-							]
-						],
-						"*",
-						[5, "3"]
-					],
-					"+",
-					"sdx"
-				]
-			],
-			[
-				13,
-				"ny",
-				[
-					1,
-					[
-						1,
-						[
-							1,
-							"iF",
-							"/",
-							[
-								6,
-								"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,
-					"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,
-					"std.min",
-					[[
-						1,
-						[
-							1,
-							[
-								7,
-								"p",
-								"dt"
-							],
-							"*",
-							[5, "0.5"]
-						],
-						"*",
-						"rateMult"
-					], [5, "0.3"]]
-				]
-			],
-			[
-				2,
-				[
-					8,
-					[
-						7,
-						[
-							7,
-							"fluidLayout",
-							"$"
-						],
-						"dyeA"
-					],
-					"idx"
-				],
-				"=",
-				[
-					6,
-					"d.vec4f",
-					[
-						[
-							7,
-							"cell",
-							"x"
-						],
-						[
-							6,
-							"std.mix",
-							[
-								[
-									7,
-									"cell",
-									"y"
-								],
-								"refBoosted",
-								"blendRate"
-							]
-						],
-						[5, "0"],
-						[5, "0"]
-					]
-				]
-			]
-		]]
-	},
-	externals: {
-		"fluidLayout": () => fluidLayout,
-		"d.u32": () => u32,
-		"N": () => N,
-		"d.f32": () => f32,
-		"noise.hash11": () => hash11,
-		"fbm": () => fbm,
-		"std.clamp": () => clamp,
-		"std.min": () => min,
-		"d.vec4f": () => vec4f,
-		"std.mix": () => mix
-	}
-}) && $.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: 2,
-			name: void 0,
-			ast: {
-				"params": [{
-					"type": "i",
-					"name": "cx"
-				}, {
-					"type": "i",
-					"name": "cy"
-				}],
-				"body": [0, [[
-					6,
-					"kernel",
-					["cx", "cy"]
-				]]]
-			},
-			externals: { "kernel": () => 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: 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
-		});
-		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 };