shaders 3.0.453 → 3.1.455

package/dist/core/SmokeFlow-B4fdM2M-.js

@@ -0,0 +1,903 @@
+import { At as max, Gt as data_exports, 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, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-B-zNWNdd.js";
+import { i as pathStampRibbon, n as createPointerVelocityTracker, r as decayFadeSeconds, t as createIdleGate } from "./pointer-DGDGF-yO.js";
+var N = 256;
+var COUNT = N * N;
+var JACOBI_ITERS = 10;
+var VELOCITY_DISSIPATION = .2;
+var MAX_STEPS = 16;
+var STATE_FORMAT = "rgba16float";
+var cm = colorMixing_exports;
+var FlowParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+	dt: f32,
+	cursorX: f32,
+	cursorY: f32,
+	cursorVelX: f32,
+	cursorVelY: f32,
+	cursorActive: f32,
+	emitRad: f32,
+	emitIntensity: f32,
+	dyeFade: f32,
+	velFade: f32,
+	curlStrength: f32,
+	gravity: f32,
+	colorDecay: f32
+}), "FlowParams");
+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: FlowParams }
+}), "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.cursorX);
+	const dy = __tsover_sub(cellY, p.cursorY);
+	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(gaussianBrushSq(distSq, radSq), p.cursorActive);
+	const cell = fluidLayout.$.dyeA[idx];
+	const oldDens = cell.x;
+	const addDens = __tsover_mul(__tsover_mul(__tsover_mul(p.emitIntensity, influence), p.dt), 10);
+	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 br = min(__tsover_mul(__tsover_mul(influence, p.dt), 4), 1);
+	const gravForce = __tsover_mul(__tsover_mul(__tsover_mul(p.gravity, oldDens), p.dt), __tsover_mul(N, .08));
+	fluidLayout.$.velA[idx] = vec4f(mix(vel.x, p.cursorVelX, br), __tsover_add(mix(vel.y, p.cursorVelY, br), gravForce), 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",
+						"cursorX"
+					]
+				]
+			],
+			[
+				13,
+				"dy",
+				[
+					1,
+					"cellY",
+					"-",
+					[
+						7,
+						"p",
+						"cursorY"
+					]
+				]
+			],
+			[
+				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,
+						"gaussianBrushSq",
+						["distSq", "radSq"]
+					],
+					"*",
+					[
+						7,
+						"p",
+						"cursorActive"
+					]
+				]
+			],
+			[
+				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, "10"]
+				]
+			],
+			[
+				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,
+				"br",
+				[
+					6,
+					[
+						7,
+						"std",
+						"min"
+					],
+					[[
+						1,
+						[
+							1,
+							"influence",
+							"*",
+							[
+								7,
+								"p",
+								"dt"
+							]
+						],
+						"*",
+						[5, "4"]
+					], [5, "1"]]
+				]
+			],
+			[
+				13,
+				"gravForce",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								7,
+								"p",
+								"gravity"
+							],
+							"*",
+							"oldDens"
+						],
+						"*",
+						[
+							7,
+							"p",
+							"dt"
+						]
+					],
+					"*",
+					[
+						1,
+						"N",
+						"*",
+						[5, "0.08"]
+					]
+				]
+			],
+			[
+				2,
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"fluidLayout",
+							"$"
+						],
+						"velA"
+					],
+					"idx"
+				],
+				"=",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec4f"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"std",
+								"mix"
+							],
+							[
+								[
+									7,
+									"vel",
+									"x"
+								],
+								[
+									7,
+									"p",
+									"cursorVelX"
+								],
+								"br"
+							]
+						],
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"std",
+									"mix"
+								],
+								[
+									[
+										7,
+										"vel",
+										"y"
+									],
+									[
+										7,
+										"p",
+										"cursorVelY"
+									],
+									"br"
+								]
+							],
+							"+",
+							"gravForce"
+						],
+						[
+							7,
+							"vel",
+							"z"
+						],
+						[5, "0"]
+					]
+				]
+			]
+		]],
+		"externalNames": [
+			"fluidLayout",
+			"d",
+			"N",
+			"std",
+			"gaussianBrushSq"
+		]
+	},
+	externals: () => ({
+		fluidLayout,
+		d: data_exports,
+		N,
+		std: std_exports,
+		gaussianBrushSq
+	})
+}) && $.f)({})).$name("smokeFlowSplat");
+var solverKernels = buildStableFluidsKernels(fluidLayout, {
+	n: N,
+	namePrefix: "smokeFlow",
+	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: "smokeFlow",
+	dye: "densityAge"
+});
+const componentDefinition = {
+	name: "SmokeFlow",
+	boundingBoxDeclaration: { aspectRatio: null },
+	category: "Interactive",
+	description: "Cursor-driven smoke that lingers, swirls, and dissipates with fluid dynamics",
+	usesPointer: true,
+	props: {
+		colorA: {
+			default: "#e29c8b",
+			transform: transformColor,
+			description: "Color of fresh smoke",
+			ui: {
+				type: "color",
+				label: "Fresh Color",
+				group: "Colors"
+			}
+		},
+		colorB: {
+			default: "#d517f9",
+			transform: transformColor,
+			description: "Color smoke transitions to as it ages",
+			ui: {
+				type: "color",
+				label: "Aged Color",
+				group: "Colors"
+			}
+		},
+		stops: colorStopsPropConfig(),
+		intensity: {
+			default: 1,
+			description: "How much smoke is emitted as you move the cursor",
+			ui: {
+				type: "range",
+				min: .1,
+				max: 2,
+				step: .05,
+				label: "Intensity",
+				group: "Emission"
+			}
+		},
+		emitRadius: {
+			default: .07,
+			description: "Size of smoke puff emitted at cursor",
+			ui: {
+				type: "range",
+				min: .01,
+				max: .3,
+				step: .01,
+				label: "Puff Size",
+				group: "Emission"
+			}
+		},
+		momentum: {
+			default: 20,
+			description: "How much cursor velocity is transferred into the smoke (higher = more directed flow)",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 50,
+				step: 1,
+				label: "Momentum",
+				group: "Emission"
+			}
+		},
+		dissipation: {
+			default: .5,
+			description: "How fast smoke fades over time",
+			ui: {
+				type: "range",
+				min: .05,
+				max: 3,
+				step: .05,
+				label: "Dissipation",
+				group: "Effect"
+			}
+		},
+		detail: {
+			default: 10,
+			description: "Fine-scale swirling detail driven by vorticity confinement",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 60,
+				step: 1,
+				label: "Swirl Detail",
+				group: "Effect"
+			}
+		},
+		gravity: {
+			default: 2,
+			description: "Vertical drift — negative floats up, positive sinks down",
+			ui: {
+				type: "range",
+				min: -5,
+				max: 5,
+				step: .05,
+				label: "Gravity",
+				group: "Effect"
+			}
+		},
+		colorDecay: {
+			default: .5,
+			description: "How quickly smoke shifts from fresh to aged color",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 3,
+				step: .1,
+				label: "Color Decay",
+				group: "Colors"
+			}
+		},
+		colorSpace: {
+			default: "OKLAB",
+			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(FlowParams), "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({ teleportGuard: Number.POSITIVE_INFINITY });
+		const idle = createIdleGate();
+		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 ptr = pointer.update(fp.pointer, dt);
+				const momentumScale = num("momentum", 1.2);
+				const speedGate = Math.min(ptr.smoothSpeed * ptr.smoothSpeed * 60, 1);
+				const isActive = speedGate > .005;
+				const dyeFade = num("dissipation", .4);
+				if (isActive) idle.markActive(now);
+				if (idle.shouldSkip(now, decayFadeSeconds(255, dyeFade))) return null;
+				const emitRadiusUv = num("emitRadius", .07);
+				const flowParams = {
+					dt,
+					cursorX: ptr.x * N,
+					cursorY: ptr.y * N,
+					cursorActive: isActive ? speedGate : 0,
+					cursorVelX: ptr.smoothVelX * N * momentumScale * .12,
+					cursorVelY: ptr.smoothVelY * N * momentumScale * .12,
+					emitRad: emitRadiusUv * N,
+					emitIntensity: num("intensity", 1.2),
+					dyeFade,
+					velFade: VELOCITY_DISSIPATION,
+					curlStrength: num("detail", 28),
+					gravity: num("gravity", -.3),
+					colorDecay: num("colorDecay", .5)
+				};
+				paramsU.write(flowParams);
+				const nodes = [];
+				if (isActive) pathStampRibbon(nodes, {
+					fromX: ptr.prevX,
+					fromY: ptr.prevY,
+					dx: ptr.dx,
+					dy: ptr.dy,
+					dragDist: ptr.dragDist,
+					stepSize: Math.max(.004, emitRadiusUv * .5),
+					maxSteps: MAX_STEPS,
+					scale: N,
+					write: (cursorX, cursorY) => paramsU.write({
+						...flowParams,
+						cursorX,
+						cursorY
+					}),
+					pass: splat
+				});
+				nodes.push(...solver.solveSteps({ jacobiIters: JACOBI_ITERS }), output);
+				return nodes;
+			}
+		};
+	},
+	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 SmokeFlow_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, SmokeFlow_default as t, jacobiKernel as u };