shaders 3.0.453 → 3.1.455

package/dist/core/SmokeFill-DOQpTlCv.js

@@ -0,0 +1,3192 @@
+import { At as max, Bt as sin, Gt as data_exports, Ht as sqrt, Jt as texture2d, Mt as mix, R as colorMixing_exports, St as cos, Tt as exp, Yt as textureStorage2d, an as vec2u, at as std_exports, cn as vec4f, dn as i32, en as struct, f as ZERO, fn as u32, gt as select, h as call, jt as min, kt as length, qt as arrayOf, rn as vec2f, rt as src_default, st as textureLoad, un as f32, x as vec4, xt as clamp } from "./edges-CD7gCAto.js";
+import { c as createStableFluidsPasses, o as buildFluidOutputKernel, s as buildStableFluidsKernels } from "./porters-DUtQounc.js";
+import { C as sdf_exports, M as createGuardedCompute, P as createStateBuffer } from "./device-B0ZwBfOg.js";
+import { i as shapeEffectBoundingBoxDeclaration, n as sdf3d_exports, r as resolveShapeType } from "./sdf3d-CP87OlsQ.js";
+import { n as glass_exports } from "./glass-D8xs_kIG.js";
+import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-B-zNWNdd.js";
+import { n as createPointerVelocityTracker } from "./pointer-DGDGF-yO.js";
+var { sdfSpaceUV } = glass_exports;
+var { createSvgSdfSampler, createSdfDataTexture, SVG_SDF_SIZE, createAnalyticSdfSampler, driveAnalyticSubProps, ANALYTIC_SDF_EXTRA_FIELDS, buildAnalyticSdfFn } = sdf_exports;
+var { createVolumetricFieldComputeNode, buildVolumetricFieldSampler, VOLUMETRIC_FIELD_EXTRA_FIELDS } = sdf3d_exports;
+var DEFAULT_SHAPE_CONFIG = JSON.stringify({
+	type: "circleSDF",
+	radius: .35
+});
+var N = 256;
+var COUNT = N * N;
+var JACOBI_ITERS = 10;
+var VELOCITY_DISSIPATION = .2;
+var STATE_FORMAT = "rgba16float";
+var cm = colorMixing_exports;
+var FillParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+	dt: f32,
+	emitX: f32,
+	emitY: f32,
+	emitVelX: f32,
+	emitVelY: f32,
+	perpDirX: f32,
+	perpDirY: f32,
+	spreadFactor: f32,
+	emitRad: f32,
+	emitIntensity: f32,
+	dyeFade: f32,
+	velFade: f32,
+	curlStrength: f32,
+	gravity: f32,
+	colorDecay: f32,
+	centerX: f32,
+	centerY: f32,
+	scale: f32,
+	rotation: f32,
+	aspect: f32,
+	cursorX: f32,
+	cursorY: f32,
+	cursorVelX: f32,
+	cursorVelY: f32,
+	mouseActive: f32,
+	mouseRadSq: f32,
+	saRadius: f32,
+	saSides: f32,
+	saRounding: f32,
+	saInnerRatio: f32,
+	saRotation: f32,
+	saHeight: f32,
+	saOffset: f32,
+	saAperture: f32,
+	vfOriginX: f32,
+	vfOriginY: f32,
+	vfSpanX: f32,
+	vfSpanY: f32,
+	vfActiveRes: f32
+}), "FillParams");
+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"
+	},
+	maskBuf: {
+		storage: arrayOf(vec4f, COUNT),
+		access: "readonly"
+	},
+	params: { uniform: FillParams }
+}), "fluidLayout");
+var maskLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
+	maskBuf: {
+		storage: arrayOf(vec4f, COUNT),
+		access: "mutable"
+	},
+	params: { uniform: FillParams }
+}), "maskLayout");
+var maskSvgLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
+	maskBuf: {
+		storage: arrayOf(vec4f, COUNT),
+		access: "mutable"
+	},
+	params: { uniform: FillParams },
+	sdfSource: { texture: texture2d(f32) }
+}), "maskSvgLayout");
+var maskVfLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
+	maskBuf: {
+		storage: arrayOf(vec4f, COUNT),
+		access: "mutable"
+	},
+	params: { uniform: FillParams },
+	fieldTex: {
+		texture: texture2d(f32),
+		sampleType: "unfilterable-float"
+	}
+}), "maskVfLayout");
+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");
+function makeMaskKernel(shapeType) {
+	const sdfFn = buildAnalyticSdfFn(shapeType);
+	return src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+		"use gpu";
+		const p = maskLayout.$.params;
+		const idx = __tsover_add(__tsover_mul(cy, u32(N)), cx);
+		const u = __tsover_div(__tsover_add(f32(cx), .5), f32(N));
+		const v = __tsover_div(__tsover_add(f32(cy), .5), f32(N));
+		const dxAc = __tsover_mul(__tsover_sub(u, p.centerX), p.aspect);
+		const dy = __tsover_sub(v, p.centerY);
+		const cosR = cos(p.rotation);
+		const sinR = sin(p.rotation);
+		const rdx = __tsover_add(__tsover_mul(dxAc, cosR), __tsover_mul(dy, sinR));
+		const rdy = __tsover_sub(__tsover_mul(dy, cosR), __tsover_mul(dxAc, sinR));
+		const res = sdfFn(vec2f(__tsover_add(__tsover_div(rdx, p.scale), .5), __tsover_add(__tsover_div(rdy, p.scale), .5)), p.saRadius, p.saSides, p.saRounding, p.saInnerRatio, p.saRotation, p.saHeight, p.saOffset, p.saAperture);
+		const inside = select(f32(0), f32(1), res.x < 0);
+		maskLayout.$.maskBuf[idx] = vec4f(inside, res.x, 0, 0);
+	}), {
+		v: 1,
+		name: void 0,
+		ast: {
+			"params": [{
+				"type": "i",
+				"name": "cx"
+			}, {
+				"type": "i",
+				"name": "cy"
+			}],
+			"body": [0, [
+				[
+					13,
+					"p",
+					[
+						7,
+						[
+							7,
+							"maskLayout",
+							"$"
+						],
+						"params"
+					]
+				],
+				[
+					13,
+					"idx",
+					[
+						1,
+						[
+							1,
+							"cy",
+							"*",
+							[
+								6,
+								[
+									7,
+									"d",
+									"u32"
+								],
+								["N"]
+							]
+						],
+						"+",
+						"cx"
+					]
+				],
+				[
+					13,
+					"u",
+					[
+						1,
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								["cx"]
+							],
+							"+",
+							[5, "0.5"]
+						],
+						"/",
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							["N"]
+						]
+					]
+				],
+				[
+					13,
+					"v",
+					[
+						1,
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								["cy"]
+							],
+							"+",
+							[5, "0.5"]
+						],
+						"/",
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							["N"]
+						]
+					]
+				],
+				[
+					13,
+					"dxAc",
+					[
+						1,
+						[
+							1,
+							"u",
+							"-",
+							[
+								7,
+								"p",
+								"centerX"
+							]
+						],
+						"*",
+						[
+							7,
+							"p",
+							"aspect"
+						]
+					]
+				],
+				[
+					13,
+					"dy",
+					[
+						1,
+						"v",
+						"-",
+						[
+							7,
+							"p",
+							"centerY"
+						]
+					]
+				],
+				[
+					13,
+					"cosR",
+					[
+						6,
+						[
+							7,
+							"std",
+							"cos"
+						],
+						[[
+							7,
+							"p",
+							"rotation"
+						]]
+					]
+				],
+				[
+					13,
+					"sinR",
+					[
+						6,
+						[
+							7,
+							"std",
+							"sin"
+						],
+						[[
+							7,
+							"p",
+							"rotation"
+						]]
+					]
+				],
+				[
+					13,
+					"rdx",
+					[
+						1,
+						[
+							1,
+							"dxAc",
+							"*",
+							"cosR"
+						],
+						"+",
+						[
+							1,
+							"dy",
+							"*",
+							"sinR"
+						]
+					]
+				],
+				[
+					13,
+					"rdy",
+					[
+						1,
+						[
+							1,
+							"dy",
+							"*",
+							"cosR"
+						],
+						"-",
+						[
+							1,
+							"dxAc",
+							"*",
+							"sinR"
+						]
+					]
+				],
+				[
+					13,
+					"sdfUV",
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec2f"
+						],
+						[[
+							1,
+							[
+								1,
+								"rdx",
+								"/",
+								[
+									7,
+									"p",
+									"scale"
+								]
+							],
+							"+",
+							[5, "0.5"]
+						], [
+							1,
+							[
+								1,
+								"rdy",
+								"/",
+								[
+									7,
+									"p",
+									"scale"
+								]
+							],
+							"+",
+							[5, "0.5"]
+						]]
+					]
+				],
+				[
+					13,
+					"res",
+					[
+						6,
+						"sdfFn",
+						[
+							"sdfUV",
+							[
+								7,
+								"p",
+								"saRadius"
+							],
+							[
+								7,
+								"p",
+								"saSides"
+							],
+							[
+								7,
+								"p",
+								"saRounding"
+							],
+							[
+								7,
+								"p",
+								"saInnerRatio"
+							],
+							[
+								7,
+								"p",
+								"saRotation"
+							],
+							[
+								7,
+								"p",
+								"saHeight"
+							],
+							[
+								7,
+								"p",
+								"saOffset"
+							],
+							[
+								7,
+								"p",
+								"saAperture"
+							]
+						]
+					]
+				],
+				[
+					13,
+					"inside",
+					[
+						6,
+						[
+							7,
+							"std",
+							"select"
+						],
+						[
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[5, "0"]]
+							],
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[5, "1"]]
+							],
+							[
+								1,
+								[
+									7,
+									"res",
+									"x"
+								],
+								"<",
+								[5, "0"]
+							]
+						]
+					]
+				],
+				[
+					2,
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"maskLayout",
+								"$"
+							],
+							"maskBuf"
+						],
+						"idx"
+					],
+					"=",
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec4f"
+						],
+						[
+							"inside",
+							[
+								7,
+								"res",
+								"x"
+							],
+							[5, "0"],
+							[5, "0"]
+						]
+					]
+				]
+			]],
+			"externalNames": [
+				"maskLayout",
+				"d",
+				"N",
+				"std",
+				"sdfFn"
+			]
+		},
+		externals: () => ({
+			maskLayout,
+			d: data_exports,
+			N,
+			std: std_exports,
+			sdfFn
+		})
+	}) && $.f)({})).$name("smokeFillMask");
+}
+const svgMaskKernel = src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+	"use gpu";
+	const p = maskSvgLayout.$.params;
+	const idx = __tsover_add(__tsover_mul(cy, u32(N)), cx);
+	const u = __tsover_div(__tsover_add(f32(cx), .5), f32(N));
+	const v = __tsover_div(__tsover_add(f32(cy), .5), f32(N));
+	const dxAc = __tsover_mul(__tsover_sub(u, p.centerX), p.aspect);
+	const dy = __tsover_sub(v, p.centerY);
+	const cosR = cos(p.rotation);
+	const sinR = sin(p.rotation);
+	const rdx = __tsover_add(__tsover_mul(dxAc, cosR), __tsover_mul(dy, sinR));
+	const rdy = __tsover_sub(__tsover_mul(dy, cosR), __tsover_mul(dxAc, sinR));
+	const sdfUV = vec2f(__tsover_add(__tsover_div(rdx, p.scale), .5), __tsover_add(__tsover_div(rdy, p.scale), .5));
+	const sizeM1 = __tsover_sub(SVG_SDF_SIZE, 1);
+	const tx = clamp(i32(__tsover_mul(sdfUV.x, SVG_SDF_SIZE)), 0, sizeM1);
+	const ty = clamp(i32(__tsover_mul(sdfUV.y, SVG_SDF_SIZE)), 0, sizeM1);
+	const dist = textureLoad(maskSvgLayout.$.sdfSource, vec2u(u32(tx), u32(ty)), 0).x;
+	const inside = select(f32(0), f32(1), dist < 0);
+	maskSvgLayout.$.maskBuf[idx] = vec4f(inside, dist, 0, 0);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "cx"
+		}, {
+			"type": "i",
+			"name": "cy"
+		}],
+		"body": [0, [
+			[
+				13,
+				"p",
+				[
+					7,
+					[
+						7,
+						"maskSvgLayout",
+						"$"
+					],
+					"params"
+				]
+			],
+			[
+				13,
+				"idx",
+				[
+					1,
+					[
+						1,
+						"cy",
+						"*",
+						[
+							6,
+							[
+								7,
+								"d",
+								"u32"
+							],
+							["N"]
+						]
+					],
+					"+",
+					"cx"
+				]
+			],
+			[
+				13,
+				"u",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							["cx"]
+						],
+						"+",
+						[5, "0.5"]
+					],
+					"/",
+					[
+						6,
+						[
+							7,
+							"d",
+							"f32"
+						],
+						["N"]
+					]
+				]
+			],
+			[
+				13,
+				"v",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							["cy"]
+						],
+						"+",
+						[5, "0.5"]
+					],
+					"/",
+					[
+						6,
+						[
+							7,
+							"d",
+							"f32"
+						],
+						["N"]
+					]
+				]
+			],
+			[
+				13,
+				"dxAc",
+				[
+					1,
+					[
+						1,
+						"u",
+						"-",
+						[
+							7,
+							"p",
+							"centerX"
+						]
+					],
+					"*",
+					[
+						7,
+						"p",
+						"aspect"
+					]
+				]
+			],
+			[
+				13,
+				"dy",
+				[
+					1,
+					"v",
+					"-",
+					[
+						7,
+						"p",
+						"centerY"
+					]
+				]
+			],
+			[
+				13,
+				"cosR",
+				[
+					6,
+					[
+						7,
+						"std",
+						"cos"
+					],
+					[[
+						7,
+						"p",
+						"rotation"
+					]]
+				]
+			],
+			[
+				13,
+				"sinR",
+				[
+					6,
+					[
+						7,
+						"std",
+						"sin"
+					],
+					[[
+						7,
+						"p",
+						"rotation"
+					]]
+				]
+			],
+			[
+				13,
+				"rdx",
+				[
+					1,
+					[
+						1,
+						"dxAc",
+						"*",
+						"cosR"
+					],
+					"+",
+					[
+						1,
+						"dy",
+						"*",
+						"sinR"
+					]
+				]
+			],
+			[
+				13,
+				"rdy",
+				[
+					1,
+					[
+						1,
+						"dy",
+						"*",
+						"cosR"
+					],
+					"-",
+					[
+						1,
+						"dxAc",
+						"*",
+						"sinR"
+					]
+				]
+			],
+			[
+				13,
+				"sdfUV",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec2f"
+					],
+					[[
+						1,
+						[
+							1,
+							"rdx",
+							"/",
+							[
+								7,
+								"p",
+								"scale"
+							]
+						],
+						"+",
+						[5, "0.5"]
+					], [
+						1,
+						[
+							1,
+							"rdy",
+							"/",
+							[
+								7,
+								"p",
+								"scale"
+							]
+						],
+						"+",
+						[5, "0.5"]
+					]]
+				]
+			],
+			[
+				13,
+				"sizeM1",
+				[
+					1,
+					"SVG_SDF_SIZE",
+					"-",
+					[5, "1"]
+				]
+			],
+			[
+				13,
+				"tx",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"d",
+								"i32"
+							],
+							[[
+								1,
+								[
+									7,
+									"sdfUV",
+									"x"
+								],
+								"*",
+								"SVG_SDF_SIZE"
+							]]
+						],
+						[5, "0"],
+						"sizeM1"
+					]
+				]
+			],
+			[
+				13,
+				"ty",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"d",
+								"i32"
+							],
+							[[
+								1,
+								[
+									7,
+									"sdfUV",
+									"y"
+								],
+								"*",
+								"SVG_SDF_SIZE"
+							]]
+						],
+						[5, "0"],
+						"sizeM1"
+					]
+				]
+			],
+			[
+				13,
+				"dist",
+				[
+					7,
+					[
+						6,
+						[
+							7,
+							"std",
+							"textureLoad"
+						],
+						[
+							[
+								7,
+								[
+									7,
+									"maskSvgLayout",
+									"$"
+								],
+								"sdfSource"
+							],
+							[
+								6,
+								[
+									7,
+									"d",
+									"vec2u"
+								],
+								[[
+									6,
+									[
+										7,
+										"d",
+										"u32"
+									],
+									["tx"]
+								], [
+									6,
+									[
+										7,
+										"d",
+										"u32"
+									],
+									["ty"]
+								]]
+							],
+							[5, "0"]
+						]
+					],
+					"x"
+				]
+			],
+			[
+				13,
+				"inside",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "0"]]
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "1"]]
+						],
+						[
+							1,
+							"dist",
+							"<",
+							[5, "0"]
+						]
+					]
+				]
+			],
+			[
+				2,
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"maskSvgLayout",
+							"$"
+						],
+						"maskBuf"
+					],
+					"idx"
+				],
+				"=",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec4f"
+					],
+					[
+						"inside",
+						"dist",
+						[5, "0"],
+						[5, "0"]
+					]
+				]
+			]
+		]],
+		"externalNames": [
+			"maskSvgLayout",
+			"d",
+			"N",
+			"std",
+			"SVG_SDF_SIZE"
+		]
+	},
+	externals: () => ({
+		maskSvgLayout,
+		d: data_exports,
+		N,
+		std: std_exports,
+		SVG_SDF_SIZE
+	})
+}) && $.f)({})).$name("smokeFillSvgMask");
+const vfMaskKernel = src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+	"use gpu";
+	const p = maskVfLayout.$.params;
+	const idx = __tsover_add(__tsover_mul(cy, u32(N)), cx);
+	const u = __tsover_div(__tsover_add(f32(cx), .5), f32(N));
+	const v = __tsover_div(__tsover_add(f32(cy), .5), f32(N));
+	const dxAc = __tsover_mul(__tsover_sub(u, p.centerX), p.aspect);
+	const dy = __tsover_sub(v, p.centerY);
+	const cosR = cos(p.rotation);
+	const sinR = sin(p.rotation);
+	const rdx = __tsover_add(__tsover_mul(dxAc, cosR), __tsover_mul(dy, sinR));
+	const rdy = __tsover_sub(__tsover_mul(dy, cosR), __tsover_mul(dxAc, sinR));
+	const sdfUV = vec2f(__tsover_add(__tsover_div(rdx, p.scale), .5), __tsover_add(__tsover_div(rdy, p.scale), .5));
+	const uxc = clamp(sdfUV.x, p.vfOriginX, __tsover_add(p.vfOriginX, p.vfSpanX));
+	const uyc = clamp(sdfUV.y, p.vfOriginY, __tsover_add(p.vfOriginY, p.vfSpanY));
+	const outsideDist = length(vec2f(__tsover_sub(sdfUV.x, uxc), __tsover_sub(sdfUV.y, uyc)));
+	const maxT = __tsover_sub(p.vfActiveRes, 1);
+	const tx = clamp(__tsover_sub(__tsover_mul(__tsover_div(__tsover_sub(uxc, p.vfOriginX), p.vfSpanX), p.vfActiveRes), .5), f32(0), maxT);
+	const ty = clamp(__tsover_sub(__tsover_mul(__tsover_div(__tsover_sub(uyc, p.vfOriginY), p.vfSpanY), p.vfActiveRes), .5), f32(0), maxT);
+	const dist = __tsover_add(textureLoad(maskVfLayout.$.fieldTex, vec2u(u32(tx), u32(ty)), 0).x, outsideDist);
+	const inside = select(f32(0), f32(1), dist < 0);
+	maskVfLayout.$.maskBuf[idx] = vec4f(inside, dist, 0, 0);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "cx"
+		}, {
+			"type": "i",
+			"name": "cy"
+		}],
+		"body": [0, [
+			[
+				13,
+				"p",
+				[
+					7,
+					[
+						7,
+						"maskVfLayout",
+						"$"
+					],
+					"params"
+				]
+			],
+			[
+				13,
+				"idx",
+				[
+					1,
+					[
+						1,
+						"cy",
+						"*",
+						[
+							6,
+							[
+								7,
+								"d",
+								"u32"
+							],
+							["N"]
+						]
+					],
+					"+",
+					"cx"
+				]
+			],
+			[
+				13,
+				"u",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							["cx"]
+						],
+						"+",
+						[5, "0.5"]
+					],
+					"/",
+					[
+						6,
+						[
+							7,
+							"d",
+							"f32"
+						],
+						["N"]
+					]
+				]
+			],
+			[
+				13,
+				"v",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							["cy"]
+						],
+						"+",
+						[5, "0.5"]
+					],
+					"/",
+					[
+						6,
+						[
+							7,
+							"d",
+							"f32"
+						],
+						["N"]
+					]
+				]
+			],
+			[
+				13,
+				"dxAc",
+				[
+					1,
+					[
+						1,
+						"u",
+						"-",
+						[
+							7,
+							"p",
+							"centerX"
+						]
+					],
+					"*",
+					[
+						7,
+						"p",
+						"aspect"
+					]
+				]
+			],
+			[
+				13,
+				"dy",
+				[
+					1,
+					"v",
+					"-",
+					[
+						7,
+						"p",
+						"centerY"
+					]
+				]
+			],
+			[
+				13,
+				"cosR",
+				[
+					6,
+					[
+						7,
+						"std",
+						"cos"
+					],
+					[[
+						7,
+						"p",
+						"rotation"
+					]]
+				]
+			],
+			[
+				13,
+				"sinR",
+				[
+					6,
+					[
+						7,
+						"std",
+						"sin"
+					],
+					[[
+						7,
+						"p",
+						"rotation"
+					]]
+				]
+			],
+			[
+				13,
+				"rdx",
+				[
+					1,
+					[
+						1,
+						"dxAc",
+						"*",
+						"cosR"
+					],
+					"+",
+					[
+						1,
+						"dy",
+						"*",
+						"sinR"
+					]
+				]
+			],
+			[
+				13,
+				"rdy",
+				[
+					1,
+					[
+						1,
+						"dy",
+						"*",
+						"cosR"
+					],
+					"-",
+					[
+						1,
+						"dxAc",
+						"*",
+						"sinR"
+					]
+				]
+			],
+			[
+				13,
+				"sdfUV",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec2f"
+					],
+					[[
+						1,
+						[
+							1,
+							"rdx",
+							"/",
+							[
+								7,
+								"p",
+								"scale"
+							]
+						],
+						"+",
+						[5, "0.5"]
+					], [
+						1,
+						[
+							1,
+							"rdy",
+							"/",
+							[
+								7,
+								"p",
+								"scale"
+							]
+						],
+						"+",
+						[5, "0.5"]
+					]]
+				]
+			],
+			[
+				13,
+				"uxc",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							7,
+							"sdfUV",
+							"x"
+						],
+						[
+							7,
+							"p",
+							"vfOriginX"
+						],
+						[
+							1,
+							[
+								7,
+								"p",
+								"vfOriginX"
+							],
+							"+",
+							[
+								7,
+								"p",
+								"vfSpanX"
+							]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"uyc",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							7,
+							"sdfUV",
+							"y"
+						],
+						[
+							7,
+							"p",
+							"vfOriginY"
+						],
+						[
+							1,
+							[
+								7,
+								"p",
+								"vfOriginY"
+							],
+							"+",
+							[
+								7,
+								"p",
+								"vfSpanY"
+							]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"outsideDist",
+				[
+					6,
+					[
+						7,
+						"std",
+						"length"
+					],
+					[[
+						6,
+						[
+							7,
+							"d",
+							"vec2f"
+						],
+						[[
+							1,
+							[
+								7,
+								"sdfUV",
+								"x"
+							],
+							"-",
+							"uxc"
+						], [
+							1,
+							[
+								7,
+								"sdfUV",
+								"y"
+							],
+							"-",
+							"uyc"
+						]]
+					]]
+				]
+			],
+			[
+				13,
+				"maxT",
+				[
+					1,
+					[
+						7,
+						"p",
+						"vfActiveRes"
+					],
+					"-",
+					[5, "1"]
+				]
+			],
+			[
+				13,
+				"tx",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									[
+										1,
+										"uxc",
+										"-",
+										[
+											7,
+											"p",
+											"vfOriginX"
+										]
+									],
+									"/",
+									[
+										7,
+										"p",
+										"vfSpanX"
+									]
+								],
+								"*",
+								[
+									7,
+									"p",
+									"vfActiveRes"
+								]
+							],
+							"-",
+							[5, "0.5"]
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "0"]]
+						],
+						"maxT"
+					]
+				]
+			],
+			[
+				13,
+				"ty",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									[
+										1,
+										"uyc",
+										"-",
+										[
+											7,
+											"p",
+											"vfOriginY"
+										]
+									],
+									"/",
+									[
+										7,
+										"p",
+										"vfSpanY"
+									]
+								],
+								"*",
+								[
+									7,
+									"p",
+									"vfActiveRes"
+								]
+							],
+							"-",
+							[5, "0.5"]
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "0"]]
+						],
+						"maxT"
+					]
+				]
+			],
+			[
+				13,
+				"dist",
+				[
+					1,
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								"std",
+								"textureLoad"
+							],
+							[
+								[
+									7,
+									[
+										7,
+										"maskVfLayout",
+										"$"
+									],
+									"fieldTex"
+								],
+								[
+									6,
+									[
+										7,
+										"d",
+										"vec2u"
+									],
+									[[
+										6,
+										[
+											7,
+											"d",
+											"u32"
+										],
+										["tx"]
+									], [
+										6,
+										[
+											7,
+											"d",
+											"u32"
+										],
+										["ty"]
+									]]
+								],
+								[5, "0"]
+							]
+						],
+						"x"
+					],
+					"+",
+					"outsideDist"
+				]
+			],
+			[
+				13,
+				"inside",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "0"]]
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "1"]]
+						],
+						[
+							1,
+							"dist",
+							"<",
+							[5, "0"]
+						]
+					]
+				]
+			],
+			[
+				2,
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"maskVfLayout",
+							"$"
+						],
+						"maskBuf"
+					],
+					"idx"
+				],
+				"=",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec4f"
+					],
+					[
+						"inside",
+						"dist",
+						[5, "0"],
+						[5, "0"]
+					]
+				]
+			]
+		]],
+		"externalNames": [
+			"maskVfLayout",
+			"d",
+			"N",
+			"std"
+		]
+	},
+	externals: () => ({
+		maskVfLayout,
+		d: data_exports,
+		N,
+		std: std_exports
+	})
+}) && $.f)({})).$name("smokeFillVfMask");
+const splatKernel = 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 mask = fluidLayout.$.maskBuf[idx].x;
+	const cellX = __tsover_add(f32(cx), .5);
+	const cellY = __tsover_add(f32(cy), .5);
+	const dx = __tsover_sub(cellX, p.emitX);
+	const dy = __tsover_sub(cellY, p.emitY);
+	const distSq = __tsover_add(__tsover_mul(dx, dx), __tsover_mul(dy, dy));
+	const radSq = max(__tsover_mul(p.emitRad, p.emitRad), f32(1));
+	const influence = __tsover_mul(exp(__tsover_mul(__tsover_div(distSq, radSq), -1)), mask);
+	const cell = fluidLayout.$.dyeA[idx];
+	const oldDens = cell.x;
+	const addDens = __tsover_mul(__tsover_mul(__tsover_mul(p.emitIntensity, influence), p.dt), 8);
+	const newDens = min(__tsover_add(oldDens, addDens), 1);
+	const rejuvenate = __tsover_div(addDens, max(newDens, f32(.001)));
+	fluidLayout.$.dyeA[idx] = vec4f(newDens, __tsover_mul(cell.y, __tsover_sub(1, min(rejuvenate, 1))), 0, 0);
+	const vel = fluidLayout.$.velA[idx];
+	const perpOff = __tsover_div(__tsover_add(__tsover_mul(dx, p.perpDirX), __tsover_mul(dy, p.perpDirY)), max(p.emitRad, f32(1)));
+	const vmSq = max(__tsover_add(__tsover_mul(p.emitVelX, p.emitVelX), __tsover_mul(p.emitVelY, p.emitVelY)), f32(1));
+	const tvx = __tsover_add(p.emitVelX, __tsover_mul(__tsover_mul(__tsover_mul(p.perpDirX, perpOff), p.spreadFactor), sqrt(vmSq)));
+	const tvy = __tsover_add(p.emitVelY, __tsover_mul(__tsover_mul(__tsover_mul(p.perpDirY, perpOff), p.spreadFactor), sqrt(vmSq)));
+	const br = min(__tsover_mul(__tsover_mul(influence, p.dt), 3), 1);
+	const gravForce = __tsover_mul(__tsover_mul(__tsover_mul(__tsover_mul(p.gravity, oldDens), p.dt), __tsover_mul(N, .08)), mask);
+	const cursorDX = __tsover_sub(cellX, p.cursorX);
+	const cursorDY = __tsover_sub(cellY, p.cursorY);
+	const cursorDistSq = __tsover_add(__tsover_mul(cursorDX, cursorDX), __tsover_mul(cursorDY, cursorDY));
+	const cursorInf = __tsover_mul(__tsover_mul(exp(__tsover_mul(__tsover_div(cursorDistSq, max(p.mouseRadSq, f32(1))), -1)), p.mouseActive), mask);
+	fluidLayout.$.velA[idx] = vec4f(__tsover_add(mix(vel.x, tvx, br), __tsover_mul(p.cursorVelX, cursorInf)), __tsover_add(__tsover_add(mix(vel.y, tvy, br), gravForce), __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,
+				"mask",
+				[
+					7,
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"fluidLayout",
+								"$"
+							],
+							"maskBuf"
+						],
+						"idx"
+					],
+					"x"
+				]
+			],
+			[
+				13,
+				"cellX",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"d",
+							"f32"
+						],
+						["cx"]
+					],
+					"+",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"cellY",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"d",
+							"f32"
+						],
+						["cy"]
+					],
+					"+",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"dx",
+				[
+					1,
+					"cellX",
+					"-",
+					[
+						7,
+						"p",
+						"emitX"
+					]
+				]
+			],
+			[
+				13,
+				"dy",
+				[
+					1,
+					"cellY",
+					"-",
+					[
+						7,
+						"p",
+						"emitY"
+					]
+				]
+			],
+			[
+				13,
+				"distSq",
+				[
+					1,
+					[
+						1,
+						"dx",
+						"*",
+						"dx"
+					],
+					"+",
+					[
+						1,
+						"dy",
+						"*",
+						"dy"
+					]
+				]
+			],
+			[
+				13,
+				"radSq",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					[[
+						1,
+						[
+							7,
+							"p",
+							"emitRad"
+						],
+						"*",
+						[
+							7,
+							"p",
+							"emitRad"
+						]
+					], [
+						6,
+						[
+							7,
+							"d",
+							"f32"
+						],
+						[[5, "1"]]
+					]]
+				]
+			],
+			[
+				13,
+				"influence",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"std",
+							"exp"
+						],
+						[[
+							1,
+							[
+								1,
+								"distSq",
+								"/",
+								"radSq"
+							],
+							"*",
+							[
+								4,
+								"-",
+								[5, "1"]
+							]
+						]]
+					],
+					"*",
+					"mask"
+				]
+			],
+			[
+				13,
+				"cell",
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"dyeA"
+					],
+					"idx"
+				]
+			],
+			[
+				13,
+				"oldDens",
+				[
+					7,
+					"cell",
+					"x"
+				]
+			],
+			[
+				13,
+				"addDens",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								7,
+								"p",
+								"emitIntensity"
+							],
+							"*",
+							"influence"
+						],
+						"*",
+						[
+							7,
+							"p",
+							"dt"
+						]
+					],
+					"*",
+					[5, "8"]
+				]
+			],
+			[
+				13,
+				"newDens",
+				[
+					6,
+					[
+						7,
+						"std",
+						"min"
+					],
+					[[
+						1,
+						"oldDens",
+						"+",
+						"addDens"
+					], [5, "1"]]
+				]
+			],
+			[
+				13,
+				"rejuvenate",
+				[
+					1,
+					"addDens",
+					"/",
+					[
+						6,
+						[
+							7,
+							"std",
+							"max"
+						],
+						["newDens", [
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "0.001"]]
+						]]
+					]
+				]
+			],
+			[
+				2,
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"dyeA"
+					],
+					"idx"
+				],
+				"=",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec4f"
+					],
+					[
+						"newDens",
+						[
+							1,
+							[
+								7,
+								"cell",
+								"y"
+							],
+							"*",
+							[
+								1,
+								[5, "1"],
+								"-",
+								[
+									6,
+									[
+										7,
+										"std",
+										"min"
+									],
+									["rejuvenate", [5, "1"]]
+								]
+							]
+						],
+						[5, "0"],
+						[5, "0"]
+					]
+				]
+			],
+			[
+				13,
+				"vel",
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"velA"
+					],
+					"idx"
+				]
+			],
+			[
+				13,
+				"perpOff",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							"dx",
+							"*",
+							[
+								7,
+								"p",
+								"perpDirX"
+							]
+						],
+						"+",
+						[
+							1,
+							"dy",
+							"*",
+							[
+								7,
+								"p",
+								"perpDirY"
+							]
+						]
+					],
+					"/",
+					[
+						6,
+						[
+							7,
+							"std",
+							"max"
+						],
+						[[
+							7,
+							"p",
+							"emitRad"
+						], [
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "1"]]
+						]]
+					]
+				]
+			],
+			[
+				13,
+				"vmSq",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					[[
+						1,
+						[
+							1,
+							[
+								7,
+								"p",
+								"emitVelX"
+							],
+							"*",
+							[
+								7,
+								"p",
+								"emitVelX"
+							]
+						],
+						"+",
+						[
+							1,
+							[
+								7,
+								"p",
+								"emitVelY"
+							],
+							"*",
+							[
+								7,
+								"p",
+								"emitVelY"
+							]
+						]
+					], [
+						6,
+						[
+							7,
+							"d",
+							"f32"
+						],
+						[[5, "1"]]
+					]]
+				]
+			],
+			[
+				13,
+				"tvx",
+				[
+					1,
+					[
+						7,
+						"p",
+						"emitVelX"
+					],
+					"+",
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									"p",
+									"perpDirX"
+								],
+								"*",
+								"perpOff"
+							],
+							"*",
+							[
+								7,
+								"p",
+								"spreadFactor"
+							]
+						],
+						"*",
+						[
+							6,
+							[
+								7,
+								"std",
+								"sqrt"
+							],
+							["vmSq"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"tvy",
+				[
+					1,
+					[
+						7,
+						"p",
+						"emitVelY"
+					],
+					"+",
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									"p",
+									"perpDirY"
+								],
+								"*",
+								"perpOff"
+							],
+							"*",
+							[
+								7,
+								"p",
+								"spreadFactor"
+							]
+						],
+						"*",
+						[
+							6,
+							[
+								7,
+								"std",
+								"sqrt"
+							],
+							["vmSq"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"br",
+				[
+					6,
+					[
+						7,
+						"std",
+						"min"
+					],
+					[[
+						1,
+						[
+							1,
+							"influence",
+							"*",
+							[
+								7,
+								"p",
+								"dt"
+							]
+						],
+						"*",
+						[5, "3"]
+					], [5, "1"]]
+				]
+			],
+			[
+				13,
+				"gravForce",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									"p",
+									"gravity"
+								],
+								"*",
+								"oldDens"
+							],
+							"*",
+							[
+								7,
+								"p",
+								"dt"
+							]
+						],
+						"*",
+						[
+							1,
+							"N",
+							"*",
+							[5, "0.08"]
+						]
+					],
+					"*",
+					"mask"
+				]
+			],
+			[
+				13,
+				"cursorDX",
+				[
+					1,
+					"cellX",
+					"-",
+					[
+						7,
+						"p",
+						"cursorX"
+					]
+				]
+			],
+			[
+				13,
+				"cursorDY",
+				[
+					1,
+					"cellY",
+					"-",
+					[
+						7,
+						"p",
+						"cursorY"
+					]
+				]
+			],
+			[
+				13,
+				"cursorDistSq",
+				[
+					1,
+					[
+						1,
+						"cursorDX",
+						"*",
+						"cursorDX"
+					],
+					"+",
+					[
+						1,
+						"cursorDY",
+						"*",
+						"cursorDY"
+					]
+				]
+			],
+			[
+				13,
+				"cursorInf",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"std",
+								"exp"
+							],
+							[[
+								1,
+								[
+									1,
+									"cursorDistSq",
+									"/",
+									[
+										6,
+										[
+											7,
+											"std",
+											"max"
+										],
+										[[
+											7,
+											"p",
+											"mouseRadSq"
+										], [
+											6,
+											[
+												7,
+												"d",
+												"f32"
+											],
+											[[5, "1"]]
+										]]
+									]
+								],
+								"*",
+								[
+									4,
+									"-",
+									[5, "1"]
+								]
+							]]
+						],
+						"*",
+						[
+							7,
+							"p",
+							"mouseActive"
+						]
+					],
+					"*",
+					"mask"
+				]
+			],
+			[
+				2,
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"velA"
+					],
+					"idx"
+				],
+				"=",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec4f"
+					],
+					[
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"std",
+									"mix"
+								],
+								[
+									[
+										7,
+										"vel",
+										"x"
+									],
+									"tvx",
+									"br"
+								]
+							],
+							"+",
+							[
+								1,
+								[
+									7,
+									"p",
+									"cursorVelX"
+								],
+								"*",
+								"cursorInf"
+							]
+						],
+						[
+							1,
+							[
+								1,
+								[
+									6,
+									[
+										7,
+										"std",
+										"mix"
+									],
+									[
+										[
+											7,
+											"vel",
+											"y"
+										],
+										"tvy",
+										"br"
+									]
+								],
+								"+",
+								"gravForce"
+							],
+							"+",
+							[
+								1,
+								[
+									7,
+									"p",
+									"cursorVelY"
+								],
+								"*",
+								"cursorInf"
+							]
+						],
+						[
+							7,
+							"vel",
+							"z"
+						],
+						[5, "0"]
+					]
+				]
+			]
+		]],
+		"externalNames": [
+			"fluidLayout",
+			"d",
+			"N",
+			"std"
+		]
+	},
+	externals: () => ({
+		fluidLayout,
+		d: data_exports,
+		N,
+		std: std_exports
+	})
+}) && $.f)({})).$name("smokeFillSplat");
+var solverKernels = buildStableFluidsKernels(fluidLayout, {
+	n: N,
+	namePrefix: "smokeFill",
+	boundary: "clamped",
+	dye: "densityAge",
+	dyeDissipation: true,
+	ageAdvance: true,
+	solidMask: true
+});
+const { curl: curlKernel, vorticity: vorticityKernel, divergence: divergenceKernel, jacobi: jacobiKernel, gradSubtract: gradSubtractKernel, advectVel: advectVelKernel, copyVel: copyVelKernel, advectDye: advectDensKernel, copyDye: copyDensKernel } = solverKernels;
+const outputKernel = buildFluidOutputKernel(outputLayout, {
+	n: N,
+	namePrefix: "smokeFill",
+	dye: "densityAge"
+});
+const smokeFillShapeMask = src_default.fn([f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((dist) => {
+	"use gpu";
+	return clamp(__tsover_mul(__tsover_mul(dist, -1), __tsover_mul(N, 4)), 0, 1);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "dist"
+		}],
+		"body": [0, [[10, [
+			6,
+			[
+				7,
+				"std",
+				"clamp"
+			],
+			[
+				[
+					1,
+					[
+						1,
+						"dist",
+						"*",
+						[
+							4,
+							"-",
+							[5, "1"]
+						]
+					],
+					"*",
+					[
+						1,
+						"N",
+						"*",
+						[5, "4"]
+					]
+				],
+				[5, "0"],
+				[5, "1"]
+			]
+		]]]],
+		"externalNames": ["std", "N"]
+	},
+	externals: () => ({
+		std: std_exports,
+		N
+	})
+}) && $.f)({}));
+const componentDefinition = {
+	name: "SmokeFill",
+	boundingBoxDeclaration: shapeEffectBoundingBoxDeclaration,
+	category: "Shape Effects",
+	description: "Fill a shape with swirling fluid smoke that interacts with the shape boundary",
+	requiresRTT: false,
+	requiresChild: false,
+	usesPointer: true,
+	extraFields: {
+		...VOLUMETRIC_FIELD_EXTRA_FIELDS,
+		...ANALYTIC_SDF_EXTRA_FIELDS
+	},
+	props: {
+		colorA: {
+			default: "#8cf3ff",
+			transform: transformColor,
+			description: "Color of fresh smoke",
+			ui: {
+				type: "color",
+				label: "Start Color",
+				group: "Colors"
+			}
+		},
+		colorB: {
+			default: "#04a0d6",
+			transform: transformColor,
+			description: "Color smoke transitions to as it ages",
+			ui: {
+				type: "color",
+				label: "End Color",
+				group: "Colors"
+			}
+		},
+		origin: {
+			default: "center",
+			description: "Reference edge the center position is measured from (center default). Lets you pin the shape relative to a corner or the canvas centre.",
+			ui: {
+				type: "origin",
+				label: "Origin",
+				group: "Position"
+			}
+		},
+		center: {
+			default: {
+				x: .5,
+				y: .5
+			},
+			transform: transformPosition,
+			description: "Center position of the shape",
+			ui: {
+				type: "position",
+				label: "Center",
+				group: "Position",
+				units: ["%", "px"]
+			}
+		},
+		scale: {
+			default: 1,
+			description: "Scale of the shape (1 = default size)",
+			ui: {
+				type: "range",
+				min: .1,
+				max: 3,
+				step: .01,
+				label: "Scale",
+				group: "Position"
+			}
+		},
+		rotation: {
+			default: 0,
+			description: "Rotation of the shape in degrees",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Rotation",
+				group: "Position"
+			}
+		},
+		emitFrom: {
+			default: {
+				x: .5,
+				y: .5
+			},
+			transform: transformPosition,
+			description: "Emission source point within the shape",
+			ui: {
+				type: "position",
+				label: "Emit From",
+				group: "Emission"
+			}
+		},
+		direction: {
+			default: 0,
+			description: "Emission direction (0 = up, 90 = right, 180 = down, 270 = left)",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Direction",
+				group: "Emission"
+			}
+		},
+		speed: {
+			default: 10,
+			description: "Emission velocity strength",
+			ui: {
+				type: "range",
+				min: .1,
+				max: 30,
+				step: .1,
+				label: "Speed",
+				group: "Emission"
+			}
+		},
+		spread: {
+			default: 60,
+			description: "Emission cone angle in degrees",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 180,
+				step: 1,
+				label: "Spread",
+				group: "Emission"
+			}
+		},
+		emitRadius: {
+			default: .03,
+			description: "Size of the emission area",
+			ui: {
+				type: "range",
+				min: .01,
+				max: .3,
+				step: .01,
+				label: "Emit Size",
+				group: "Emission"
+			}
+		},
+		intensity: {
+			default: 1,
+			description: "Smoke emission density",
+			ui: {
+				type: "range",
+				min: .1,
+				max: 1,
+				step: .01,
+				label: "Intensity",
+				group: "Effect"
+			}
+		},
+		dissipation: {
+			default: .3,
+			description: "How fast smoke fades over time",
+			ui: {
+				type: "range",
+				min: .1,
+				max: 5,
+				step: .1,
+				label: "Dissipation",
+				group: "Effect"
+			}
+		},
+		detail: {
+			default: 25,
+			description: "Fine-scale swirling detail",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 50,
+				step: 1,
+				label: "Detail",
+				group: "Effect"
+			}
+		},
+		gravity: {
+			default: .5,
+			description: "Downward gravitational pull on smoke — 0 = weightless, negative values = smoke rises",
+			ui: {
+				type: "range",
+				min: -2,
+				max: 2,
+				step: .1,
+				label: "Gravity",
+				group: "Effect"
+			}
+		},
+		colorDecay: {
+			default: .4,
+			description: "How quickly smoke shifts from Color A to Color B",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 3,
+				step: .1,
+				label: "Color Decay",
+				group: "Colors"
+			}
+		},
+		mouseInfluence: {
+			default: .1,
+			description: "Strength of cursor influence",
+			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"
+			}
+		},
+		shape: {
+			default: DEFAULT_SHAPE_CONFIG,
+			description: "Serialized shape configuration (JSON)",
+			ui: {
+				type: "shape",
+				label: "Shape",
+				group: "Shape"
+			}
+		},
+		shapeSdfUrl: {
+			default: "",
+			compileTime: true,
+			description: "URL to a pre-generated SDF .bin file"
+		},
+		shapeType: {
+			default: "",
+			compileTime: true,
+			description: "Active SDF shape type"
+		}
+	},
+	compute: (params) => {
+		const { gpu, getCpuValue, registerComputeTexture, onCleanup } = params;
+		const root = gpu?.root;
+		if (!root) return null;
+		const shapeSdfUrl = getCpuValue("shapeSdfUrl") || "";
+		const shapeType = resolveShapeType(getCpuValue("shapeType") || "", getCpuValue("shape"));
+		const vf = createVolumetricFieldComputeNode(params, () => getCpuValue("shape"), "none");
+		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 maskBuf = createStateBuffer(root, vec4f, 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 smokeTexture = registerComputeTexture(outTex);
+		const paramsU = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(FillParams), "paramsU");
+		const size = [N, N];
+		const fluidBg = root.createBindGroup(fluidLayout, {
+			velA,
+			velB,
+			dyeA,
+			dyeB,
+			pressure,
+			divergence,
+			maskBuf,
+			params: paramsU.buffer
+		});
+		const outputBg = root.createBindGroup(outputLayout, {
+			dyeA,
+			outTex
+		});
+		const mk = (kernel, bg = fluidBg) => 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: bg
+		});
+		let maskPass;
+		if (vf) maskPass = mk(vfMaskKernel, root.createBindGroup(maskVfLayout, {
+			maskBuf,
+			params: paramsU.buffer,
+			fieldTex: vf.fieldTexture
+		}));
+		else if (shapeSdfUrl) {
+			const sdfTex = createSdfDataTexture(params, shapeSdfUrl);
+			maskPass = mk(svgMaskKernel, root.createBindGroup(maskSvgLayout, {
+				maskBuf,
+				params: paramsU.buffer,
+				sdfSource: sdfTex.texture.texture
+			}));
+		} else {
+			const maskBg = root.createBindGroup(maskLayout, {
+				maskBuf,
+				params: paramsU.buffer
+			});
+			maskPass = mk(makeMaskKernel(shapeType), maskBg);
+		}
+		const splat = mk(splatKernel);
+		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 num = (v, f) => typeof v === "number" ? v : f;
+		const resolveSub = () => {
+			const raw = getCpuValue("shape");
+			let c = {};
+			if (raw && typeof raw === "object") c = raw;
+			else if (typeof raw === "string") try {
+				c = JSON.parse(raw);
+			} catch {
+				c = {};
+			}
+			return {
+				saRadius: num(c.radius, num(c.width, num(c.bottomWidth, .35))),
+				saSides: num(c.sides, 6),
+				saRounding: num(c.rounding, 0),
+				saInnerRatio: num(c.innerRatio, num(c.thickness, num(c.spread, num(c.topWidth, num(c.topRatio, .4))))),
+				saRotation: num(c.rotation, 0),
+				saHeight: num(c.height, .25),
+				saOffset: num(c.offset, num(c.skew, .2)),
+				saAperture: num(c.aperture, 270)
+			};
+		};
+		let lastTime = Date.now();
+		const pointer = createPointerVelocityTracker({ minDrag: 5e-4 });
+		return {
+			outputs: {
+				smokeTexture,
+				...vf ? vf.outputs : {}
+			},
+			getComputeNodes: (frameParams) => {
+				const fp = frameParams;
+				const vfNodes = vf?.getComputeNodes(fp) ?? null;
+				const now = Date.now();
+				const dt = Math.min(fp.deltaTime ?? (now - lastTime) / 1e3, .033);
+				lastTime = now;
+				if (dt < .001) return vfNodes;
+				const g = (key, fallback) => {
+					const v = getCpuValue(key);
+					return typeof v === "number" ? v : fallback;
+				};
+				const speed = g("speed", 2);
+				const dirRad = g("direction", 0) * Math.PI / 180;
+				const spreadHalf = Math.min(89 * Math.PI / 180, g("spread", 60) * Math.PI / 360);
+				const centerView = getCpuValue("center");
+				const emitView = getCpuValue("emitFrom");
+				const h = fp.dimensions?.height ?? 0;
+				const aspect = h > 0 ? (fp.dimensions?.width ?? 0) / h : 1;
+				const velMag = speed * N * .15;
+				const sub = resolveSub();
+				const mouseInf = g("mouseInfluence", .5);
+				const mouseRad = g("mouseRadius", .12);
+				const ptr = pointer.update(fp.pointer, dt);
+				const active = ptr.moving && mouseInf > 0;
+				const mouseRadGrid = mouseRad * N;
+				const dom = vf?.getFieldDomain();
+				paramsU.write({
+					dt,
+					emitX: (emitView?.x ?? .5) * N,
+					emitY: (1 - (emitView?.y ?? .5)) * N,
+					emitVelX: Math.sin(dirRad) * velMag,
+					emitVelY: -Math.cos(dirRad) * velMag,
+					perpDirX: Math.cos(dirRad),
+					perpDirY: Math.sin(dirRad),
+					spreadFactor: Math.tan(spreadHalf),
+					emitRad: g("emitRadius", .03) * N,
+					emitIntensity: g("intensity", .8),
+					dyeFade: g("dissipation", .5),
+					velFade: VELOCITY_DISSIPATION,
+					curlStrength: g("detail", 30),
+					gravity: g("gravity", .5),
+					colorDecay: g("colorDecay", 1),
+					centerX: centerView?.x ?? .5,
+					centerY: 1 - (centerView?.y ?? .5),
+					scale: g("scale", 1),
+					rotation: g("rotation", 0) * Math.PI / 180,
+					aspect,
+					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,
+					...sub,
+					vfOriginX: dom?.originX ?? 0,
+					vfOriginY: dom?.originY ?? 0,
+					vfSpanX: dom?.spanX ?? 1,
+					vfSpanY: dom?.spanY ?? 1,
+					vfActiveRes: dom?.activeRes ?? 1
+				});
+				return [
+					...vfNodes ?? [],
+					maskPass,
+					splat,
+					...solver.solveSteps({ jacobiIters: JACOBI_ITERS }),
+					output
+				];
+			}
+		};
+	},
+	fragment: (params) => {
+		const { ctx, computeOutputs, propValues, uniforms, getCpuValue } = params;
+		const smokeField = computeOutputs?.smokeTexture;
+		if (!smokeField) return ZERO;
+		let sampler;
+		const fieldTex = computeOutputs?.volumetricFieldTexture;
+		if (fieldTex) sampler = buildVolumetricFieldSampler(fieldTex, {
+			originX: uniforms._vfOriginX,
+			originY: uniforms._vfOriginY,
+			spanX: uniforms._vfSpanX,
+			spanY: uniforms._vfSpanY,
+			activeResF: uniforms._vfActiveRes,
+			rBound: uniforms._vfRBound
+		}).volumetricFieldSampler;
+		else {
+			const shapeSdfUrl = propValues.shapeSdfUrl || "";
+			if (shapeSdfUrl) sampler = createSvgSdfSampler(params, shapeSdfUrl);
+			else sampler = createAnalyticSdfSampler(resolveShapeType(propValues.shapeType || "", getCpuValue("shape")), driveAnalyticSubProps(params, () => getCpuValue("shape")));
+		}
+		const sdfUV = call(sdfSpaceUV, "sdfSpaceUV", [
+			uniforms.center,
+			uniforms.scale,
+			uniforms.rotation,
+			ctx.uv,
+			ctx.aspect
+		]);
+		const shapeMask = call(smokeFillShapeMask, "smokeFillShapeMask", [sampler(sdfUV).member("x")]);
+		const s = smokeField.sample(ctx.uv, "linearClamp");
+		const smokeDensity = s.member("x");
+		const smokeAge = s.member("y");
+		const colorSpaceMode = propValues.colorSpace ?? 0;
+		const smokeColor = call(cm.mixColorsVariants[colorSpaceMode] ?? cm.mixColorsLinear, "mixColors", [
+			uniforms.colorA,
+			uniforms.colorB,
+			smokeAge
+		]);
+		return vec4(smokeColor.member("rgb"), smokeColor.member("a").mul(smokeDensity).mul(shapeMask));
+	}
+};
+var SmokeFill_default = componentDefinition;
+export { vorticityKernel as _, copyDensKernel as a, divergenceKernel as c, makeMaskKernel as d, outputKernel as f, vfMaskKernel as g, svgMaskKernel as h, componentDefinition as i, gradSubtractKernel as l, splatKernel as m, advectDensKernel as n, copyVelKernel as o, smokeFillShapeMask as p, advectVelKernel as r, curlKernel as s, SmokeFill_default as t, jacobiKernel as u };