shaders 3.0.453 → 3.1.455

package/dist/core/Smoke-5x6IAk2_.js

@@ -0,0 +1,1265 @@
+import { At as max, Gt as data_exports, Ht as sqrt, Mt as mix, R as colorMixing_exports, Yt as textureStorage2d, at as std_exports, cn as vec4f, en as struct, f as ZERO, fn as u32, h as call, jt as min, qt as arrayOf, rt as src_default, un as f32, x as vec4 } from "./edges-CD7gCAto.js";
+import { J as mixColorStopsRuntime, V as colorStopsPropConfig, a as gaussianBrushSq, c as createStableFluidsPasses, o as buildFluidOutputKernel, s as buildStableFluidsKernels } from "./porters-DUtQounc.js";
+import { M as createGuardedCompute, P as createStateBuffer } from "./device-B0ZwBfOg.js";
+import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-B-zNWNdd.js";
+import { n as createPointerVelocityTracker } from "./pointer-DGDGF-yO.js";
+var N = 256;
+var COUNT = N * N;
+var JACOBI_ITERS = 10;
+var VELOCITY_DISSIPATION = .2;
+var STATE_FORMAT = "rgba16float";
+var cm = colorMixing_exports;
+var FluidParams = /* @__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,
+	cursorX: f32,
+	cursorY: f32,
+	cursorVelX: f32,
+	cursorVelY: f32,
+	mouseActive: f32,
+	mouseRadSq: f32,
+	colorDecay: f32
+}), "FluidParams");
+var fluidLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
+	velA: {
+		storage: arrayOf(vec4f, COUNT),
+		access: "mutable"
+	},
+	velB: {
+		storage: arrayOf(vec4f, COUNT),
+		access: "mutable"
+	},
+	dyeA: {
+		storage: arrayOf(vec4f, COUNT),
+		access: "mutable"
+	},
+	dyeB: {
+		storage: arrayOf(vec4f, COUNT),
+		access: "mutable"
+	},
+	pressure: {
+		storage: arrayOf(f32, COUNT),
+		access: "mutable"
+	},
+	divergence: {
+		storage: arrayOf(f32, COUNT),
+		access: "mutable"
+	},
+	params: { uniform: FluidParams }
+}), "fluidLayout");
+var outputLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
+	dyeA: {
+		storage: arrayOf(vec4f, COUNT),
+		access: "readonly"
+	},
+	outTex: { storageTexture: textureStorage2d(STATE_FORMAT, "write-only") }
+}), "outputLayout");
+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 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 influence = gaussianBrushSq(__tsover_add(__tsover_mul(dx, dx), __tsover_mul(dy, dy)), max(__tsover_mul(p.emitRad, p.emitRad), f32(1)));
+	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(p.gravity, oldDens), p.dt), __tsover_mul(N, .08));
+	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(gaussianBrushSq(cursorDistSq, max(p.mouseRadSq, f32(1))), p.mouseActive);
+	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,
+				"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",
+				[
+					6,
+					"gaussianBrushSq",
+					["distSq", "radSq"]
+				]
+			],
+			[
+				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,
+							[
+								7,
+								"p",
+								"gravity"
+							],
+							"*",
+							"oldDens"
+						],
+						"*",
+						[
+							7,
+							"p",
+							"dt"
+						]
+					],
+					"*",
+					[
+						1,
+						"N",
+						"*",
+						[5, "0.08"]
+					]
+				]
+			],
+			[
+				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,
+					[
+						6,
+						"gaussianBrushSq",
+						["cursorDistSq", [
+							6,
+							[
+								7,
+								"std",
+								"max"
+							],
+							[[
+								7,
+								"p",
+								"mouseRadSq"
+							], [
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[5, "1"]]
+							]]
+						]]
+					],
+					"*",
+					[
+						7,
+						"p",
+						"mouseActive"
+					]
+				]
+			],
+			[
+				2,
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"velA"
+					],
+					"idx"
+				],
+				"=",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec4f"
+					],
+					[
+						[
+							1,
+							[
+								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",
+			"gaussianBrushSq"
+		]
+	},
+	externals: () => ({
+		fluidLayout,
+		d: data_exports,
+		N,
+		std: std_exports,
+		gaussianBrushSq
+	})
+}) && $.f)({})).$name("smokeSplat");
+var solverKernels = buildStableFluidsKernels(fluidLayout, {
+	n: N,
+	namePrefix: "smoke",
+	boundary: "clamped",
+	dye: "densityAge",
+	dyeDissipation: true,
+	ageAdvance: 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: "smoke",
+	dye: "densityAge"
+});
+const componentDefinition = {
+	name: "Smoke",
+	boundingBoxDeclaration: { aspectRatio: null },
+	category: "Interactive",
+	description: "Realistic fluid smoke simulation with vorticity dynamics",
+	usesPointer: true,
+	props: {
+		colorA: {
+			default: "#fc83f9",
+			transform: transformColor,
+			description: "Color of fresh smoke",
+			ui: {
+				type: "color",
+				label: "Start Color",
+				group: "Colors"
+			}
+		},
+		colorB: {
+			default: "#c21c79",
+			transform: transformColor,
+			description: "Color smoke transitions to as it ages",
+			ui: {
+				type: "color",
+				label: "End Color",
+				group: "Colors"
+			}
+		},
+		stops: colorStopsPropConfig(),
+		emitFrom: {
+			default: {
+				x: .5,
+				y: 1
+			},
+			transform: transformPosition,
+			description: "The emission source point",
+			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: 20,
+			description: "Emission velocity strength",
+			ui: {
+				type: "range",
+				min: .1,
+				max: 50,
+				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: .08,
+			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: .2,
+			description: "How fast smoke fades over time",
+			ui: {
+				type: "range",
+				min: .1,
+				max: 3,
+				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",
+			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"
+			}
+		}
+	},
+	compute: (params) => {
+		const { gpu, getCpuValue, registerComputeTexture, onCleanup } = params;
+		const root = gpu?.root;
+		if (!root) return null;
+		const velA = createStateBuffer(root, vec4f, COUNT);
+		const velB = createStateBuffer(root, vec4f, COUNT);
+		const dyeA = createStateBuffer(root, vec4f, COUNT);
+		const dyeB = createStateBuffer(root, vec4f, COUNT);
+		const pressure = createStateBuffer(root, f32, COUNT);
+		const divergence = createStateBuffer(root, f32, COUNT);
+		const outTex = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
+			size: [N, N],
+			format: STATE_FORMAT
+		}).$usage("storage", "sampled"), "outTex");
+		onCleanup(() => outTex.destroy());
+		const smokeTexture = registerComputeTexture(outTex);
+		const paramsU = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(FluidParams), "paramsU");
+		const size = [N, N];
+		const fluidBg = root.createBindGroup(fluidLayout, {
+			velA,
+			velB,
+			dyeA,
+			dyeB,
+			pressure,
+			divergence,
+			params: paramsU.buffer
+		});
+		const outputBg = root.createBindGroup(outputLayout, {
+			dyeA,
+			outTex
+		});
+		const splat = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+			"use gpu";
+			splatKernel(cx, cy);
+		}), {
+			v: 1,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "cx"
+				}, {
+					"type": "i",
+					"name": "cy"
+				}],
+				"body": [0, [[
+					6,
+					"splatKernel",
+					["cx", "cy"]
+				]]],
+				"externalNames": ["splatKernel"]
+			},
+			externals: () => ({ splatKernel })
+		}) && $.f)({}), {
+			size,
+			bindGroup: fluidBg
+		});
+		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
+		});
+		let lastTime = Date.now();
+		const pointer = createPointerVelocityTracker({ minDrag: 5e-4 });
+		return {
+			outputs: { smokeTexture },
+			getComputeNodes: (frameParams) => {
+				const fp = frameParams;
+				const now = Date.now();
+				const dt = Math.min(fp.deltaTime ?? (now - lastTime) / 1e3, .033);
+				lastTime = now;
+				if (dt < .001) return null;
+				const num = (key, fallback) => {
+					const v = getCpuValue(key);
+					return typeof v === "number" ? v : fallback;
+				};
+				const speed = num("speed", 3);
+				const dirRad = num("direction", 0) * Math.PI / 180;
+				const spreadHalf = Math.min(89 * Math.PI / 180, num("spread", 45) * Math.PI / 360);
+				const emitPos = getCpuValue("emitFrom");
+				const epx = emitPos?.x ?? .5;
+				const epy = emitPos?.y ?? 0;
+				const velMag = speed * N * .15;
+				const mouseInf = num("mouseInfluence", .5);
+				const mouseRad = num("mouseRadius", .12);
+				const ptr = pointer.update(fp.pointer, dt);
+				const mouseRadGrid = mouseRad * N;
+				const active = ptr.moving && mouseInf > 0;
+				paramsU.write({
+					dt,
+					emitX: epx * N,
+					emitY: (1 - epy) * N,
+					emitVelX: Math.sin(dirRad) * velMag,
+					emitVelY: -Math.cos(dirRad) * velMag,
+					perpDirX: Math.cos(dirRad),
+					perpDirY: Math.sin(dirRad),
+					spreadFactor: Math.tan(spreadHalf),
+					emitRad: num("emitRadius", .06) * N,
+					emitIntensity: num("intensity", .7),
+					dyeFade: num("dissipation", 1),
+					velFade: VELOCITY_DISSIPATION,
+					curlStrength: num("detail", 30),
+					gravity: num("gravity", .5),
+					colorDecay: num("colorDecay", 1),
+					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
+				});
+				return [
+					splat,
+					...solver.solveSteps({ jacobiIters: JACOBI_ITERS }),
+					output
+				];
+			}
+		};
+	},
+	fragment: ({ ctx, computeOutputs, propValues, uniforms }) => {
+		const smokeField = computeOutputs?.smokeTexture;
+		if (!smokeField) return ZERO;
+		const s = smokeField.sample(ctx.uv, "linearClamp");
+		const smokeDensity = s.member("x");
+		const smokeAge = s.member("y");
+		const colorSpaceMode = propValues.colorSpace ?? 0;
+		const stopCount = propValues.stopCount ?? 0;
+		let smokeColor;
+		if (stopCount > 1) smokeColor = mixColorStopsRuntime(smokeAge, {
+			colorsArray: uniforms.colorsArray,
+			positionsArray: uniforms.positionsArray,
+			convertedColorsArray: uniforms.convertedColorsArray,
+			stopCount: uniforms.stopCount
+		}, colorSpaceMode);
+		else smokeColor = call(cm.mixColorsVariants[colorSpaceMode] ?? cm.mixColorsLinear, "mixColors", [
+			uniforms.colorA,
+			uniforms.colorB,
+			smokeAge
+		]);
+		return vec4(smokeColor.member("rgb"), smokeColor.member("a").mul(smokeDensity));
+	}
+};
+var Smoke_default = componentDefinition;
+export { copyDensKernel as a, divergenceKernel as c, outputKernel as d, splatKernel as f, componentDefinition as i, gradSubtractKernel as l, advectDensKernel as n, copyVelKernel as o, vorticityKernel as p, advectVelKernel as r, curlKernel as s, Smoke_default as t, jacobiKernel as u };