shaders 3.0.453 → 3.1.455

package/dist/core/InkFlow-Bd4RXQmm.js

@@ -0,0 +1,1159 @@
+import { At as max, B as convertP3ToMixSpaceCPU, Gt as data_exports, J as mixPreconvertedLinear, Mt as mix, Y as mixPreconvertedVariants, Yt as textureStorage2d, at as std_exports, cn as vec4f, en as struct, f as ZERO, fn as u32, h as call, on as vec3f, qt as arrayOf, rt as src_default, un as f32, x as vec4, xt as clamp, y as floatE } from "./edges-CD7gCAto.js";
+import { c as createStableFluidsPasses, i as gaussianBrushFnSq, 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 STATE_FORMAT = "rgba16float";
+var IMPULSE_K = .16;
+var MAX_STEPS = 16;
+var CYCLE_PER_SPLAT = .006;
+var CYCLE_TIME_RATE = .06;
+var VEL_FADE_MAX = 4;
+var VEL_FADE_MIN = .05;
+var GAIN = 1.35;
+var FlowParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+	dt: f32,
+	curlStrength: f32,
+	velFade: f32,
+	dyeFade: f32
+}), "FlowParams");
+var SplatParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+	posX: f32,
+	posY: f32,
+	velX: f32,
+	velY: f32,
+	colR: f32,
+	colG: f32,
+	colB: f32,
+	col2R: f32,
+	col2G: f32,
+	col2B: f32,
+	mixT: f32,
+	radius: f32,
+	strength: f32
+}), "SplatParams");
+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 splatLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
+	velA: {
+		storage: arrayOf(vec4f, COUNT),
+		access: "mutable"
+	},
+	dyeA: {
+		storage: arrayOf(vec4f, COUNT),
+		access: "mutable"
+	},
+	sparams: { uniform: SplatParams }
+}), "splatLayout");
+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");
+var makeSplatKernel = (colorSpaceMode) => {
+	const mixFn = mixPreconvertedVariants[colorSpaceMode] ?? mixPreconvertedLinear;
+	const brushWeight = gaussianBrushFnSq({ edgeShift: false });
+	return src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+		"use gpu";
+		const p = splatLayout.$.sparams;
+		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.posX);
+		const dy = __tsover_sub(cellY, p.posY);
+		const inf = brushWeight(__tsover_add(__tsover_mul(dx, dx), __tsover_mul(dy, dy)), max(__tsover_mul(p.radius, p.radius), f32(1)));
+		const w = clamp(__tsover_mul(inf, p.strength), f32(0), f32(1));
+		const brush = mixFn(vec3f(p.colR, p.colG, p.colB), vec3f(p.col2R, p.col2G, p.col2B), 1, 1, p.mixT);
+		const cell = splatLayout.$.dyeA[idx];
+		splatLayout.$.dyeA[idx] = vec4f(mix(cell.x, brush.x, w), mix(cell.y, brush.y, w), mix(cell.z, brush.z, w), 0);
+		const vel = splatLayout.$.velA[idx];
+		splatLayout.$.velA[idx] = vec4f(__tsover_add(vel.x, __tsover_mul(p.velX, inf)), __tsover_add(vel.y, __tsover_mul(p.velY, inf)), vel.z, 0);
+	}), {
+		v: 1,
+		name: void 0,
+		ast: {
+			"params": [{
+				"type": "i",
+				"name": "cx"
+			}, {
+				"type": "i",
+				"name": "cy"
+			}],
+			"body": [0, [
+				[
+					13,
+					"p",
+					[
+						7,
+						[
+							7,
+							"splatLayout",
+							"$"
+						],
+						"sparams"
+					]
+				],
+				[
+					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",
+							"posX"
+						]
+					]
+				],
+				[
+					13,
+					"dy",
+					[
+						1,
+						"cellY",
+						"-",
+						[
+							7,
+							"p",
+							"posY"
+						]
+					]
+				],
+				[
+					13,
+					"distSq",
+					[
+						1,
+						[
+							1,
+							"dx",
+							"*",
+							"dx"
+						],
+						"+",
+						[
+							1,
+							"dy",
+							"*",
+							"dy"
+						]
+					]
+				],
+				[
+					13,
+					"radSq",
+					[
+						6,
+						[
+							7,
+							"std",
+							"max"
+						],
+						[[
+							1,
+							[
+								7,
+								"p",
+								"radius"
+							],
+							"*",
+							[
+								7,
+								"p",
+								"radius"
+							]
+						], [
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "1"]]
+						]]
+					]
+				],
+				[
+					13,
+					"inf",
+					[
+						6,
+						"brushWeight",
+						["distSq", "radSq"]
+					]
+				],
+				[
+					13,
+					"w",
+					[
+						6,
+						[
+							7,
+							"std",
+							"clamp"
+						],
+						[
+							[
+								1,
+								"inf",
+								"*",
+								[
+									7,
+									"p",
+									"strength"
+								]
+							],
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[5, "0"]]
+							],
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[5, "1"]]
+							]
+						]
+					]
+				],
+				[
+					13,
+					"brush",
+					[
+						6,
+						"mixFn",
+						[
+							[
+								6,
+								[
+									7,
+									"d",
+									"vec3f"
+								],
+								[
+									[
+										7,
+										"p",
+										"colR"
+									],
+									[
+										7,
+										"p",
+										"colG"
+									],
+									[
+										7,
+										"p",
+										"colB"
+									]
+								]
+							],
+							[
+								6,
+								[
+									7,
+									"d",
+									"vec3f"
+								],
+								[
+									[
+										7,
+										"p",
+										"col2R"
+									],
+									[
+										7,
+										"p",
+										"col2G"
+									],
+									[
+										7,
+										"p",
+										"col2B"
+									]
+								]
+							],
+							[5, "1"],
+							[5, "1"],
+							[
+								7,
+								"p",
+								"mixT"
+							]
+						]
+					]
+				],
+				[
+					13,
+					"cell",
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"splatLayout",
+								"$"
+							],
+							"dyeA"
+						],
+						"idx"
+					]
+				],
+				[
+					2,
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"splatLayout",
+								"$"
+							],
+							"dyeA"
+						],
+						"idx"
+					],
+					"=",
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec4f"
+						],
+						[
+							[
+								6,
+								[
+									7,
+									"std",
+									"mix"
+								],
+								[
+									[
+										7,
+										"cell",
+										"x"
+									],
+									[
+										7,
+										"brush",
+										"x"
+									],
+									"w"
+								]
+							],
+							[
+								6,
+								[
+									7,
+									"std",
+									"mix"
+								],
+								[
+									[
+										7,
+										"cell",
+										"y"
+									],
+									[
+										7,
+										"brush",
+										"y"
+									],
+									"w"
+								]
+							],
+							[
+								6,
+								[
+									7,
+									"std",
+									"mix"
+								],
+								[
+									[
+										7,
+										"cell",
+										"z"
+									],
+									[
+										7,
+										"brush",
+										"z"
+									],
+									"w"
+								]
+							],
+							[5, "0"]
+						]
+					]
+				],
+				[
+					13,
+					"vel",
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"splatLayout",
+								"$"
+							],
+							"velA"
+						],
+						"idx"
+					]
+				],
+				[
+					2,
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"splatLayout",
+								"$"
+							],
+							"velA"
+						],
+						"idx"
+					],
+					"=",
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec4f"
+						],
+						[
+							[
+								1,
+								[
+									7,
+									"vel",
+									"x"
+								],
+								"+",
+								[
+									1,
+									[
+										7,
+										"p",
+										"velX"
+									],
+									"*",
+									"inf"
+								]
+							],
+							[
+								1,
+								[
+									7,
+									"vel",
+									"y"
+								],
+								"+",
+								[
+									1,
+									[
+										7,
+										"p",
+										"velY"
+									],
+									"*",
+									"inf"
+								]
+							],
+							[
+								7,
+								"vel",
+								"z"
+							],
+							[5, "0"]
+						]
+					]
+				]
+			]],
+			"externalNames": [
+				"splatLayout",
+				"d",
+				"N",
+				"std",
+				"brushWeight",
+				"mixFn"
+			]
+		},
+		externals: () => ({
+			splatLayout,
+			d: data_exports,
+			N,
+			std: std_exports,
+			brushWeight,
+			mixFn
+		})
+	}) && $.f)({})).$name(`inkFlowSplat${colorSpaceMode}`);
+};
+var splatKernelVariants = {
+	0: makeSplatKernel(0),
+	1: makeSplatKernel(1),
+	2: makeSplatKernel(2),
+	3: makeSplatKernel(3),
+	4: makeSplatKernel(4),
+	5: makeSplatKernel(5)
+};
+const splatKernel = splatKernelVariants[2];
+var solverKernels = buildStableFluidsKernels(fluidLayout, {
+	n: N,
+	namePrefix: "inkFlow",
+	boundary: "clamped",
+	dye: "rgb",
+	dyeDissipation: true
+});
+const { curl: curlKernel, vorticity: vorticityKernel, divergence: divergenceKernel, jacobi: jacobiKernel, gradSubtract: gradSubtractKernel, advectVel: advectVelKernel, copyVel: copyVelKernel, advectDye: advectDyeKernel, copyDye: copyDyeKernel } = solverKernels;
+const outputKernel = buildFluidOutputKernel(outputLayout, {
+	n: N,
+	namePrefix: "inkFlow",
+	dye: "rgb"
+});
+const inkFlowComposite = src_default.fn([vec3f, f32], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((dye, gain) => {
+	"use gpu";
+	const lum = max(dye.x, max(dye.y, dye.z));
+	return vec4f(dye, clamp(__tsover_mul(lum, gain), f32(0), f32(1)));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "dye"
+		}, {
+			"type": "i",
+			"name": "gain"
+		}],
+		"body": [0, [
+			[
+				13,
+				"lum",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					[[
+						7,
+						"dye",
+						"x"
+					], [
+						6,
+						[
+							7,
+							"std",
+							"max"
+						],
+						[[
+							7,
+							"dye",
+							"y"
+						], [
+							7,
+							"dye",
+							"z"
+						]]
+					]]
+				]
+			],
+			[
+				13,
+				"coverage",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							"lum",
+							"*",
+							"gain"
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "0"]]
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "1"]]
+						]
+					]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"d",
+					"vec4f"
+				],
+				["dye", "coverage"]
+			]]
+		]],
+		"externalNames": ["std", "d"]
+	},
+	externals: () => ({
+		std: std_exports,
+		d: data_exports
+	})
+}) && $.f)({})).$name("inkFlowComposite");
+function srgbToLinear(c) {
+	return c <= .04045 ? c / 12.92 : Math.pow((c + .055) / 1.055, 2.4);
+}
+function hueToLinearRgb(hue) {
+	const h = (hue % 1 + 1) % 1;
+	const i = Math.floor(h * 6);
+	const f = h * 6 - i;
+	const q = 1 - f;
+	let r = 0;
+	let g = 0;
+	let b = 0;
+	if (i === 0) {
+		r = 1;
+		g = f;
+		b = 0;
+	} else if (i === 1) {
+		r = q;
+		g = 1;
+		b = 0;
+	} else if (i === 2) {
+		r = 0;
+		g = 1;
+		b = f;
+	} else if (i === 3) {
+		r = 0;
+		g = q;
+		b = 1;
+	} else if (i === 4) {
+		r = f;
+		g = 0;
+		b = 1;
+	} else {
+		r = 1;
+		g = 0;
+		b = q;
+	}
+	return [
+		srgbToLinear(r),
+		srgbToLinear(g),
+		srgbToLinear(b)
+	];
+}
+const componentDefinition = {
+	name: "InkFlow",
+	boundingBoxDeclaration: { aspectRatio: null },
+	category: "Interactive",
+	description: "Drag to paint swirling ribbons of ink through a real fluid field — eddies keep evolving after you let go",
+	requiresRTT: false,
+	requiresChild: false,
+	usesPointer: true,
+	props: {
+		colorMode: {
+			default: "rainbow",
+			description: "How the brush colour is chosen: an ever-cycling rainbow, a single fixed colour, or a custom three-colour cycle",
+			ui: {
+				type: "select",
+				options: [
+					{
+						label: "Rainbow",
+						value: "rainbow"
+					},
+					{
+						label: "Single Color",
+						value: "single"
+					},
+					{
+						label: "Custom Colors",
+						value: "custom"
+					}
+				],
+				label: "Color Mode",
+				group: "Color"
+			}
+		},
+		colorSpeed: {
+			default: 1,
+			description: "How quickly the brush cycles through the rainbow or the custom colours as you paint",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 4,
+				step: .05,
+				label: "Color Speed",
+				group: "Color",
+				condition: { colorMode: ["rainbow", "custom"] }
+			}
+		},
+		color: {
+			default: "#ff2d7e",
+			transform: transformColor,
+			description: "Brush colour used when Color Mode is Single",
+			ui: {
+				type: "color",
+				label: "Brush Color",
+				group: "Color",
+				condition: { colorMode: "single" }
+			}
+		},
+		color1: {
+			default: "#4338ff",
+			transform: transformColor,
+			description: "First colour of the custom brush cycle",
+			ui: {
+				type: "color",
+				label: "Color 1",
+				group: "Color",
+				condition: { colorMode: "custom" }
+			}
+		},
+		color2: {
+			default: "#ff2d7e",
+			transform: transformColor,
+			description: "Second colour of the custom brush cycle",
+			ui: {
+				type: "color",
+				label: "Color 2",
+				group: "Color",
+				condition: { colorMode: "custom" }
+			}
+		},
+		color3: {
+			default: "#19e3ff",
+			transform: transformColor,
+			description: "Third colour of the custom brush cycle",
+			ui: {
+				type: "color",
+				label: "Color 3",
+				group: "Color",
+				condition: { colorMode: "custom" }
+			}
+		},
+		colorSpace: {
+			default: "oklab",
+			transform: transformColorSpace,
+			compileTime: true,
+			description: "Colour space the custom colours blend through as the brush cycles between them",
+			ui: {
+				type: "select",
+				options: colorSpaceOptions,
+				label: "Color Space",
+				group: "Color",
+				condition: { colorMode: "custom" }
+			}
+		},
+		radius: {
+			default: .3,
+			description: "Size of the ink splat painted under the cursor",
+			ui: {
+				type: "range",
+				min: .1,
+				max: 5,
+				step: .05,
+				label: "Radius",
+				group: "Brush"
+			}
+		},
+		force: {
+			default: 1,
+			description: "How hard the cursor's motion pushes the fluid — higher throws faster, more violent jets and curls",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 3,
+				step: .05,
+				label: "Force",
+				group: "Brush"
+			}
+		},
+		curl: {
+			default: 0,
+			description: "Vorticity confinement — swirl energy that spins the ink into persistent eddies and curls",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 60,
+				step: 1,
+				label: "Swirl",
+				group: "Dynamics"
+			}
+		},
+		decay: {
+			default: .5,
+			description: "How fast the ink fades away — low values leave long, lingering trails",
+			ui: {
+				type: "range",
+				min: .05,
+				max: 4,
+				step: .05,
+				label: "Decay",
+				group: "Dynamics"
+			}
+		},
+		momentum: {
+			default: .6,
+			description: "How long the fluid keeps flowing after a stroke — high momentum lets the motion carry on and on",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Momentum",
+				group: "Dynamics"
+			}
+		}
+	},
+	compute: (params) => {
+		const { gpu, getCpuValue, propValues, 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 dyeTexture = registerComputeTexture(outTex);
+		const paramsU = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(FlowParams), "paramsU");
+		const splatU = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(SplatParams), "splatU");
+		const size = [N, N];
+		const fluidBg = root.createBindGroup(fluidLayout, {
+			velA,
+			velB,
+			dyeA,
+			dyeB,
+			pressure,
+			divergence,
+			params: paramsU.buffer
+		});
+		const splatBg = root.createBindGroup(splatLayout, {
+			velA,
+			dyeA,
+			sparams: splatU.buffer
+		});
+		const outputBg = root.createBindGroup(outputLayout, {
+			dyeA,
+			outTex
+		});
+		const spaceMode = propValues.colorSpace ?? 2;
+		const activeSplatKernel = splatKernelVariants[spaceMode] ?? splatKernelVariants[2];
+		const splat = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+			"use gpu";
+			activeSplatKernel(cx, cy);
+		}), {
+			v: 1,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "cx"
+				}, {
+					"type": "i",
+					"name": "cy"
+				}],
+				"body": [0, [[
+					6,
+					"activeSplatKernel",
+					["cx", "cy"]
+				]]],
+				"externalNames": ["activeSplatKernel"]
+			},
+			externals: () => ({ activeSplatKernel })
+		}) && $.f)({}), {
+			size,
+			bindGroup: splatBg
+		});
+		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();
+		let hueCursor = 0;
+		const pointer = createPointerVelocityTracker();
+		const idle = createIdleGate();
+		const num = (key, fallback) => {
+			const v = getCpuValue(key);
+			return typeof v === "number" ? v : fallback;
+		};
+		return {
+			outputs: { dyeTexture },
+			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 force = num("force", 1);
+				const radiusGrid = Math.max(num("radius", .3) * .1 * N, 1);
+				const colorSpeed = num("colorSpeed", 1);
+				const mode = getCpuValue("colorMode") || "rainbow";
+				hueCursor += dt * CYCLE_TIME_RATE * colorSpeed;
+				const toRgb = (v, fallback) => {
+					const c = v;
+					return c && typeof c.r === "number" ? [
+						c.r,
+						c.g ?? 0,
+						c.b ?? 0
+					] : fallback;
+				};
+				const conv = (c) => convertP3ToMixSpaceCPU(c[0], c[1], c[2], spaceMode);
+				const customStops = mode === "custom" ? [
+					conv(toRgb(getCpuValue("color1"), [
+						.26,
+						.22,
+						1
+					])),
+					conv(toRgb(getCpuValue("color2"), [
+						1,
+						.18,
+						.49
+					])),
+					conv(toRgb(getCpuValue("color3"), [
+						.1,
+						.89,
+						1
+					]))
+				] : null;
+				const brushSplat = () => {
+					hueCursor += CYCLE_PER_SPLAT * colorSpeed;
+					if (customStops) {
+						const h = (hueCursor % 1 + 1) % 1;
+						const seg = Math.min(2, Math.floor(h * 3));
+						return {
+							a: customStops[seg],
+							b: customStops[(seg + 1) % 3],
+							t: h * 3 - seg
+						};
+					}
+					if (mode === "single") {
+						const c$1 = conv(toRgb(getCpuValue("color"), [
+							1,
+							.18,
+							.49
+						]));
+						return {
+							a: c$1,
+							b: c$1,
+							t: 0
+						};
+					}
+					const c = conv(hueToLinearRgb(hueCursor));
+					return {
+						a: c,
+						b: c,
+						t: 0
+					};
+				};
+				const ptr = pointer.update(fp.pointer, dt);
+				if (ptr.moving) idle.markActive(now);
+				if (idle.shouldSkip(now, decayFadeSeconds(64, num("decay", .5)))) return null;
+				const momentum = Math.min(Math.max(num("momentum", .6), 0), 1);
+				paramsU.write({
+					dt,
+					curlStrength: num("curl", 0),
+					velFade: VEL_FADE_MAX * Math.pow(VEL_FADE_MIN / VEL_FADE_MAX, momentum),
+					dyeFade: num("decay", .5)
+				});
+				const nodes = [];
+				if (ptr.moving) {
+					const velX = ptr.velX * N * force * IMPULSE_K;
+					const velY = ptr.velY * N * force * IMPULSE_K;
+					pathStampRibbon(nodes, {
+						fromX: ptr.prevX,
+						fromY: ptr.prevY,
+						dx: ptr.dx,
+						dy: ptr.dy,
+						dragDist: ptr.dragDist,
+						stepSize: Math.max(.004, radiusGrid / N * .6),
+						maxSteps: MAX_STEPS,
+						scale: N,
+						prepare: brushSplat,
+						write: (posX, posY, _t, bc) => splatU.write({
+							posX,
+							posY,
+							velX,
+							velY,
+							colR: bc.a[0],
+							colG: bc.a[1],
+							colB: bc.a[2],
+							col2R: bc.b[0],
+							col2G: bc.b[1],
+							col2B: bc.b[2],
+							mixT: bc.t,
+							radius: radiusGrid,
+							strength: 1
+						}),
+						pass: splat
+					});
+				}
+				nodes.push(...solver.solveSteps({ jacobiIters: JACOBI_ITERS }), output);
+				return nodes;
+			}
+		};
+	},
+	fragment: ({ ctx, computeOutputs }) => {
+		const dyeField = computeOutputs?.dyeTexture;
+		if (!dyeField) return ZERO;
+		const out = call(inkFlowComposite, "inkFlowComposite", [dyeField.sample(ctx.uv, "linearClamp").member("rgb"), floatE(GAIN)]);
+		return vec4(out.member("rgb"), out.member("a"));
+	}
+};
+var InkFlow_default = componentDefinition;
+export { copyDyeKernel as a, divergenceKernel as c, jacobiKernel as d, outputKernel as f, componentDefinition as i, gradSubtractKernel as l, vorticityKernel as m, advectDyeKernel as n, copyVelKernel as o, splatKernel as p, advectVelKernel as r, curlKernel as s, InkFlow_default as t, inkFlowComposite as u };