shaders 3.1.463 → 3.2.465

package/dist/core/SmokeFill-BSu4o6eH.js

@@ -1,2868 +0,0 @@
-import { Dt as sin, Gt as textureStorage2d, I as colorMixing_exports, Kt as arrayOf, Lt as vec4f, Mt as vec2f, Pt as vec2u, Wt as texture2d, _t as max, b as vec4, cn as i32, ct as clamp, d as ZERO, et as typegpu_default, ft as exp, gt as length, kt as sqrt, ln as u32, lt as cos, m as call, qt as struct, rt as select, sn as f32, vt as min, yt as mix } from "./edges-CV-BHMpI.js";
-import { C as sdf_exports, I as textureLoad, M as createGuardedCompute, P as createStateBuffer } from "./device-DKcu50_C.js";
-import { c as createStableFluidsPasses, o as buildFluidOutputKernel, s as buildStableFluidsKernels } from "./porters-j7yWJYy2.js";
-import { i as shapeEffectBoundingBoxDeclaration, n as sdf3d_exports, r as resolveShapeType } from "./sdf3d-B8EwGL7R.js";
-import { n as glass_exports } from "./glass-Di_yYrw1.js";
-import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-u-UZrXjj.js";
-import { n as createPointerVelocityTracker } from "./pointer-CdyEZBpL.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))(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"
-	},
-	maskBuf: {
-		storage: arrayOf(vec4f, COUNT),
-		access: "readonly"
-	},
-	params: { uniform: FillParams }
-}), "fluidLayout");
-var maskLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.bindGroupLayout({
-	maskBuf: {
-		storage: arrayOf(vec4f, COUNT),
-		access: "mutable"
-	},
-	params: { uniform: FillParams }
-}), "maskLayout");
-var maskSvgLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_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))(typegpu_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))(typegpu_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 typegpu_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: 2,
-		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,
-								"d.u32",
-								["N"]
-							]
-						],
-						"+",
-						"cx"
-					]
-				],
-				[
-					13,
-					"u",
-					[
-						1,
-						[
-							1,
-							[
-								6,
-								"d.f32",
-								["cx"]
-							],
-							"+",
-							[5, "0.5"]
-						],
-						"/",
-						[
-							6,
-							"d.f32",
-							["N"]
-						]
-					]
-				],
-				[
-					13,
-					"v",
-					[
-						1,
-						[
-							1,
-							[
-								6,
-								"d.f32",
-								["cy"]
-							],
-							"+",
-							[5, "0.5"]
-						],
-						"/",
-						[
-							6,
-							"d.f32",
-							["N"]
-						]
-					]
-				],
-				[
-					13,
-					"dxAc",
-					[
-						1,
-						[
-							1,
-							"u",
-							"-",
-							[
-								7,
-								"p",
-								"centerX"
-							]
-						],
-						"*",
-						[
-							7,
-							"p",
-							"aspect"
-						]
-					]
-				],
-				[
-					13,
-					"dy",
-					[
-						1,
-						"v",
-						"-",
-						[
-							7,
-							"p",
-							"centerY"
-						]
-					]
-				],
-				[
-					13,
-					"cosR",
-					[
-						6,
-						"std.cos",
-						[[
-							7,
-							"p",
-							"rotation"
-						]]
-					]
-				],
-				[
-					13,
-					"sinR",
-					[
-						6,
-						"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,
-						"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,
-						"std.select",
-						[
-							[
-								6,
-								"d.f32",
-								[[5, "0"]]
-							],
-							[
-								6,
-								"d.f32",
-								[[5, "1"]]
-							],
-							[
-								1,
-								[
-									7,
-									"res",
-									"x"
-								],
-								"<",
-								[5, "0"]
-							]
-						]
-					]
-				],
-				[
-					2,
-					[
-						8,
-						[
-							7,
-							[
-								7,
-								"maskLayout",
-								"$"
-							],
-							"maskBuf"
-						],
-						"idx"
-					],
-					"=",
-					[
-						6,
-						"d.vec4f",
-						[
-							"inside",
-							[
-								7,
-								"res",
-								"x"
-							],
-							[5, "0"],
-							[5, "0"]
-						]
-					]
-				]
-			]]
-		},
-		externals: {
-			"maskLayout": () => maskLayout,
-			"d.u32": () => u32,
-			"N": () => N,
-			"d.f32": () => f32,
-			"std.cos": () => cos,
-			"std.sin": () => sin,
-			"d.vec2f": () => vec2f,
-			"sdfFn": () => sdfFn,
-			"std.select": () => select,
-			"d.vec4f": () => vec4f
-		}
-	}) && $.f)({})).$name("smokeFillMask");
-}
-const svgMaskKernel = typegpu_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: 2,
-	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,
-							"d.u32",
-							["N"]
-						]
-					],
-					"+",
-					"cx"
-				]
-			],
-			[
-				13,
-				"u",
-				[
-					1,
-					[
-						1,
-						[
-							6,
-							"d.f32",
-							["cx"]
-						],
-						"+",
-						[5, "0.5"]
-					],
-					"/",
-					[
-						6,
-						"d.f32",
-						["N"]
-					]
-				]
-			],
-			[
-				13,
-				"v",
-				[
-					1,
-					[
-						1,
-						[
-							6,
-							"d.f32",
-							["cy"]
-						],
-						"+",
-						[5, "0.5"]
-					],
-					"/",
-					[
-						6,
-						"d.f32",
-						["N"]
-					]
-				]
-			],
-			[
-				13,
-				"dxAc",
-				[
-					1,
-					[
-						1,
-						"u",
-						"-",
-						[
-							7,
-							"p",
-							"centerX"
-						]
-					],
-					"*",
-					[
-						7,
-						"p",
-						"aspect"
-					]
-				]
-			],
-			[
-				13,
-				"dy",
-				[
-					1,
-					"v",
-					"-",
-					[
-						7,
-						"p",
-						"centerY"
-					]
-				]
-			],
-			[
-				13,
-				"cosR",
-				[
-					6,
-					"std.cos",
-					[[
-						7,
-						"p",
-						"rotation"
-					]]
-				]
-			],
-			[
-				13,
-				"sinR",
-				[
-					6,
-					"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,
-					"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,
-					"std.clamp",
-					[
-						[
-							6,
-							"d.i32",
-							[[
-								1,
-								[
-									7,
-									"sdfUV",
-									"x"
-								],
-								"*",
-								"SVG_SDF_SIZE"
-							]]
-						],
-						[5, "0"],
-						"sizeM1"
-					]
-				]
-			],
-			[
-				13,
-				"ty",
-				[
-					6,
-					"std.clamp",
-					[
-						[
-							6,
-							"d.i32",
-							[[
-								1,
-								[
-									7,
-									"sdfUV",
-									"y"
-								],
-								"*",
-								"SVG_SDF_SIZE"
-							]]
-						],
-						[5, "0"],
-						"sizeM1"
-					]
-				]
-			],
-			[
-				13,
-				"dist",
-				[
-					7,
-					[
-						6,
-						"std.textureLoad",
-						[
-							[
-								7,
-								[
-									7,
-									"maskSvgLayout",
-									"$"
-								],
-								"sdfSource"
-							],
-							[
-								6,
-								"d.vec2u",
-								[[
-									6,
-									"d.u32",
-									["tx"]
-								], [
-									6,
-									"d.u32",
-									["ty"]
-								]]
-							],
-							[5, "0"]
-						]
-					],
-					"x"
-				]
-			],
-			[
-				13,
-				"inside",
-				[
-					6,
-					"std.select",
-					[
-						[
-							6,
-							"d.f32",
-							[[5, "0"]]
-						],
-						[
-							6,
-							"d.f32",
-							[[5, "1"]]
-						],
-						[
-							1,
-							"dist",
-							"<",
-							[5, "0"]
-						]
-					]
-				]
-			],
-			[
-				2,
-				[
-					8,
-					[
-						7,
-						[
-							7,
-							"maskSvgLayout",
-							"$"
-						],
-						"maskBuf"
-					],
-					"idx"
-				],
-				"=",
-				[
-					6,
-					"d.vec4f",
-					[
-						"inside",
-						"dist",
-						[5, "0"],
-						[5, "0"]
-					]
-				]
-			]
-		]]
-	},
-	externals: {
-		"maskSvgLayout": () => maskSvgLayout,
-		"d.u32": () => u32,
-		"N": () => N,
-		"d.f32": () => f32,
-		"std.cos": () => cos,
-		"std.sin": () => sin,
-		"d.vec2f": () => vec2f,
-		"SVG_SDF_SIZE": () => SVG_SDF_SIZE,
-		"std.clamp": () => clamp,
-		"d.i32": () => i32,
-		"std.textureLoad": () => textureLoad,
-		"d.vec2u": () => vec2u,
-		"std.select": () => select,
-		"d.vec4f": () => vec4f
-	}
-}) && $.f)({})).$name("smokeFillSvgMask");
-const vfMaskKernel = typegpu_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: 2,
-	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,
-							"d.u32",
-							["N"]
-						]
-					],
-					"+",
-					"cx"
-				]
-			],
-			[
-				13,
-				"u",
-				[
-					1,
-					[
-						1,
-						[
-							6,
-							"d.f32",
-							["cx"]
-						],
-						"+",
-						[5, "0.5"]
-					],
-					"/",
-					[
-						6,
-						"d.f32",
-						["N"]
-					]
-				]
-			],
-			[
-				13,
-				"v",
-				[
-					1,
-					[
-						1,
-						[
-							6,
-							"d.f32",
-							["cy"]
-						],
-						"+",
-						[5, "0.5"]
-					],
-					"/",
-					[
-						6,
-						"d.f32",
-						["N"]
-					]
-				]
-			],
-			[
-				13,
-				"dxAc",
-				[
-					1,
-					[
-						1,
-						"u",
-						"-",
-						[
-							7,
-							"p",
-							"centerX"
-						]
-					],
-					"*",
-					[
-						7,
-						"p",
-						"aspect"
-					]
-				]
-			],
-			[
-				13,
-				"dy",
-				[
-					1,
-					"v",
-					"-",
-					[
-						7,
-						"p",
-						"centerY"
-					]
-				]
-			],
-			[
-				13,
-				"cosR",
-				[
-					6,
-					"std.cos",
-					[[
-						7,
-						"p",
-						"rotation"
-					]]
-				]
-			],
-			[
-				13,
-				"sinR",
-				[
-					6,
-					"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,
-					"d.vec2f",
-					[[
-						1,
-						[
-							1,
-							"rdx",
-							"/",
-							[
-								7,
-								"p",
-								"scale"
-							]
-						],
-						"+",
-						[5, "0.5"]
-					], [
-						1,
-						[
-							1,
-							"rdy",
-							"/",
-							[
-								7,
-								"p",
-								"scale"
-							]
-						],
-						"+",
-						[5, "0.5"]
-					]]
-				]
-			],
-			[
-				13,
-				"uxc",
-				[
-					6,
-					"std.clamp",
-					[
-						[
-							7,
-							"sdfUV",
-							"x"
-						],
-						[
-							7,
-							"p",
-							"vfOriginX"
-						],
-						[
-							1,
-							[
-								7,
-								"p",
-								"vfOriginX"
-							],
-							"+",
-							[
-								7,
-								"p",
-								"vfSpanX"
-							]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"uyc",
-				[
-					6,
-					"std.clamp",
-					[
-						[
-							7,
-							"sdfUV",
-							"y"
-						],
-						[
-							7,
-							"p",
-							"vfOriginY"
-						],
-						[
-							1,
-							[
-								7,
-								"p",
-								"vfOriginY"
-							],
-							"+",
-							[
-								7,
-								"p",
-								"vfSpanY"
-							]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"outsideDist",
-				[
-					6,
-					"std.length",
-					[[
-						6,
-						"d.vec2f",
-						[[
-							1,
-							[
-								7,
-								"sdfUV",
-								"x"
-							],
-							"-",
-							"uxc"
-						], [
-							1,
-							[
-								7,
-								"sdfUV",
-								"y"
-							],
-							"-",
-							"uyc"
-						]]
-					]]
-				]
-			],
-			[
-				13,
-				"maxT",
-				[
-					1,
-					[
-						7,
-						"p",
-						"vfActiveRes"
-					],
-					"-",
-					[5, "1"]
-				]
-			],
-			[
-				13,
-				"tx",
-				[
-					6,
-					"std.clamp",
-					[
-						[
-							1,
-							[
-								1,
-								[
-									1,
-									[
-										1,
-										"uxc",
-										"-",
-										[
-											7,
-											"p",
-											"vfOriginX"
-										]
-									],
-									"/",
-									[
-										7,
-										"p",
-										"vfSpanX"
-									]
-								],
-								"*",
-								[
-									7,
-									"p",
-									"vfActiveRes"
-								]
-							],
-							"-",
-							[5, "0.5"]
-						],
-						[
-							6,
-							"d.f32",
-							[[5, "0"]]
-						],
-						"maxT"
-					]
-				]
-			],
-			[
-				13,
-				"ty",
-				[
-					6,
-					"std.clamp",
-					[
-						[
-							1,
-							[
-								1,
-								[
-									1,
-									[
-										1,
-										"uyc",
-										"-",
-										[
-											7,
-											"p",
-											"vfOriginY"
-										]
-									],
-									"/",
-									[
-										7,
-										"p",
-										"vfSpanY"
-									]
-								],
-								"*",
-								[
-									7,
-									"p",
-									"vfActiveRes"
-								]
-							],
-							"-",
-							[5, "0.5"]
-						],
-						[
-							6,
-							"d.f32",
-							[[5, "0"]]
-						],
-						"maxT"
-					]
-				]
-			],
-			[
-				13,
-				"dist",
-				[
-					1,
-					[
-						7,
-						[
-							6,
-							"std.textureLoad",
-							[
-								[
-									7,
-									[
-										7,
-										"maskVfLayout",
-										"$"
-									],
-									"fieldTex"
-								],
-								[
-									6,
-									"d.vec2u",
-									[[
-										6,
-										"d.u32",
-										["tx"]
-									], [
-										6,
-										"d.u32",
-										["ty"]
-									]]
-								],
-								[5, "0"]
-							]
-						],
-						"x"
-					],
-					"+",
-					"outsideDist"
-				]
-			],
-			[
-				13,
-				"inside",
-				[
-					6,
-					"std.select",
-					[
-						[
-							6,
-							"d.f32",
-							[[5, "0"]]
-						],
-						[
-							6,
-							"d.f32",
-							[[5, "1"]]
-						],
-						[
-							1,
-							"dist",
-							"<",
-							[5, "0"]
-						]
-					]
-				]
-			],
-			[
-				2,
-				[
-					8,
-					[
-						7,
-						[
-							7,
-							"maskVfLayout",
-							"$"
-						],
-						"maskBuf"
-					],
-					"idx"
-				],
-				"=",
-				[
-					6,
-					"d.vec4f",
-					[
-						"inside",
-						"dist",
-						[5, "0"],
-						[5, "0"]
-					]
-				]
-			]
-		]]
-	},
-	externals: {
-		"maskVfLayout": () => maskVfLayout,
-		"d.u32": () => u32,
-		"N": () => N,
-		"d.f32": () => f32,
-		"std.cos": () => cos,
-		"std.sin": () => sin,
-		"d.vec2f": () => vec2f,
-		"std.clamp": () => clamp,
-		"std.length": () => length,
-		"std.textureLoad": () => textureLoad,
-		"d.vec2u": () => vec2u,
-		"std.select": () => select,
-		"d.vec4f": () => vec4f
-	}
-}) && $.f)({})).$name("smokeFillVfMask");
-const splatKernel = 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 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: 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,
-				"mask",
-				[
-					7,
-					[
-						8,
-						[
-							7,
-							[
-								7,
-								"fluidLayout",
-								"$"
-							],
-							"maskBuf"
-						],
-						"idx"
-					],
-					"x"
-				]
-			],
-			[
-				13,
-				"cellX",
-				[
-					1,
-					[
-						6,
-						"d.f32",
-						["cx"]
-					],
-					"+",
-					[5, "0.5"]
-				]
-			],
-			[
-				13,
-				"cellY",
-				[
-					1,
-					[
-						6,
-						"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,
-					"std.max",
-					[[
-						1,
-						[
-							7,
-							"p",
-							"emitRad"
-						],
-						"*",
-						[
-							7,
-							"p",
-							"emitRad"
-						]
-					], [
-						6,
-						"d.f32",
-						[[5, "1"]]
-					]]
-				]
-			],
-			[
-				13,
-				"influence",
-				[
-					1,
-					[
-						6,
-						"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,
-					"std.min",
-					[[
-						1,
-						"oldDens",
-						"+",
-						"addDens"
-					], [5, "1"]]
-				]
-			],
-			[
-				13,
-				"rejuvenate",
-				[
-					1,
-					"addDens",
-					"/",
-					[
-						6,
-						"std.max",
-						["newDens", [
-							6,
-							"d.f32",
-							[[5, "0.001"]]
-						]]
-					]
-				]
-			],
-			[
-				2,
-				[
-					8,
-					[
-						7,
-						[
-							7,
-							"fluidLayout",
-							"$"
-						],
-						"dyeA"
-					],
-					"idx"
-				],
-				"=",
-				[
-					6,
-					"d.vec4f",
-					[
-						"newDens",
-						[
-							1,
-							[
-								7,
-								"cell",
-								"y"
-							],
-							"*",
-							[
-								1,
-								[5, "1"],
-								"-",
-								[
-									6,
-									"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,
-						"std.max",
-						[[
-							7,
-							"p",
-							"emitRad"
-						], [
-							6,
-							"d.f32",
-							[[5, "1"]]
-						]]
-					]
-				]
-			],
-			[
-				13,
-				"vmSq",
-				[
-					6,
-					"std.max",
-					[[
-						1,
-						[
-							1,
-							[
-								7,
-								"p",
-								"emitVelX"
-							],
-							"*",
-							[
-								7,
-								"p",
-								"emitVelX"
-							]
-						],
-						"+",
-						[
-							1,
-							[
-								7,
-								"p",
-								"emitVelY"
-							],
-							"*",
-							[
-								7,
-								"p",
-								"emitVelY"
-							]
-						]
-					], [
-						6,
-						"d.f32",
-						[[5, "1"]]
-					]]
-				]
-			],
-			[
-				13,
-				"tvx",
-				[
-					1,
-					[
-						7,
-						"p",
-						"emitVelX"
-					],
-					"+",
-					[
-						1,
-						[
-							1,
-							[
-								1,
-								[
-									7,
-									"p",
-									"perpDirX"
-								],
-								"*",
-								"perpOff"
-							],
-							"*",
-							[
-								7,
-								"p",
-								"spreadFactor"
-							]
-						],
-						"*",
-						[
-							6,
-							"std.sqrt",
-							["vmSq"]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"tvy",
-				[
-					1,
-					[
-						7,
-						"p",
-						"emitVelY"
-					],
-					"+",
-					[
-						1,
-						[
-							1,
-							[
-								1,
-								[
-									7,
-									"p",
-									"perpDirY"
-								],
-								"*",
-								"perpOff"
-							],
-							"*",
-							[
-								7,
-								"p",
-								"spreadFactor"
-							]
-						],
-						"*",
-						[
-							6,
-							"std.sqrt",
-							["vmSq"]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"br",
-				[
-					6,
-					"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,
-							"std.exp",
-							[[
-								1,
-								[
-									1,
-									"cursorDistSq",
-									"/",
-									[
-										6,
-										"std.max",
-										[[
-											7,
-											"p",
-											"mouseRadSq"
-										], [
-											6,
-											"d.f32",
-											[[5, "1"]]
-										]]
-									]
-								],
-								"*",
-								[
-									4,
-									"-",
-									[5, "1"]
-								]
-							]]
-						],
-						"*",
-						[
-							7,
-							"p",
-							"mouseActive"
-						]
-					],
-					"*",
-					"mask"
-				]
-			],
-			[
-				2,
-				[
-					8,
-					[
-						7,
-						[
-							7,
-							"fluidLayout",
-							"$"
-						],
-						"velA"
-					],
-					"idx"
-				],
-				"=",
-				[
-					6,
-					"d.vec4f",
-					[
-						[
-							1,
-							[
-								6,
-								"std.mix",
-								[
-									[
-										7,
-										"vel",
-										"x"
-									],
-									"tvx",
-									"br"
-								]
-							],
-							"+",
-							[
-								1,
-								[
-									7,
-									"p",
-									"cursorVelX"
-								],
-								"*",
-								"cursorInf"
-							]
-						],
-						[
-							1,
-							[
-								1,
-								[
-									6,
-									"std.mix",
-									[
-										[
-											7,
-											"vel",
-											"y"
-										],
-										"tvy",
-										"br"
-									]
-								],
-								"+",
-								"gravForce"
-							],
-							"+",
-							[
-								1,
-								[
-									7,
-									"p",
-									"cursorVelY"
-								],
-								"*",
-								"cursorInf"
-							]
-						],
-						[
-							7,
-							"vel",
-							"z"
-						],
-						[5, "0"]
-					]
-				]
-			]
-		]]
-	},
-	externals: {
-		"fluidLayout": () => fluidLayout,
-		"d.u32": () => u32,
-		"N": () => N,
-		"d.f32": () => f32,
-		"std.max": () => max,
-		"std.exp": () => exp,
-		"std.min": () => min,
-		"d.vec4f": () => vec4f,
-		"std.sqrt": () => sqrt,
-		"std.mix": () => mix
-	}
-}) && $.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 = typegpu_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: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "dist"
-		}],
-		"body": [0, [[10, [
-			6,
-			"std.clamp",
-			[
-				[
-					1,
-					[
-						1,
-						"dist",
-						"*",
-						[
-							4,
-							"-",
-							[5, "1"]
-						]
-					],
-					"*",
-					[
-						1,
-						"N",
-						"*",
-						[5, "4"]
-					]
-				],
-				[5, "0"],
-				[5, "1"]
-			]
-		]]]]
-	},
-	externals: {
-		"std.clamp": () => clamp,
-		"N": () => 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: 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: 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: 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 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 };