shaders 3.1.463 → 3.2.465

package/dist/core/ReactionDiffusion-z37SYWSB.js

@@ -1,3262 +0,0 @@
-import { Dt as sin, Ft as vec3f, Gt as textureStorage2d, I as colorMixing_exports, Kt as arrayOf, Lt as vec4f, Mt as vec2f, Ot as smoothstep, Pt as vec2u, Wt as texture2d, _t as max, b as vec4, bt as normalize, cn as i32, ct as clamp, d as ZERO, dt as dot, et as typegpu_default, ft as exp, ln as u32, lt as cos, m as call, qt as struct, rt as select, sn as f32, v as floatE, vt as min, xt as pow, yt as mix } from "./edges-CV-BHMpI.js";
-import { F as textureDimensions, I as textureLoad, M as createGuardedCompute, N as createPingPongPair, P as createStateBuffer, R as textureStore } from "./device-DKcu50_C.js";
-import { t as DEG_TO_RAD } from "./constants-BKlzQFdJ.js";
-import { O as createLateBoundChildInput } from "./porters-j7yWJYy2.js";
-import { s as hash12 } from "./noise-eXd1Bfrw.js";
-import { a as transformColor, i as transformBoolean, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-u-UZrXjj.js";
-import { n as createPointerVelocityTracker } from "./pointer-CdyEZBpL.js";
-var cm = colorMixing_exports;
-var N = 512;
-var COUNT = N * N;
-var STATE_FORMAT = "rgba16float";
-var MAX_ITERATIONS = 16;
-var SEED_DENSITY = .06;
-var RELIEF_EPS = 1.5 / N;
-var RELIEF_STRENGTH = 6;
-var RELIEF_AMBIENT = .42;
-var RELIEF_LIGHT_XY = .85;
-var RELIEF_LIGHT_Z = .55;
-var RELIEF_SHININESS = 18;
-var RELIEF_SPEC = .35;
-var DEG2RAD = DEG_TO_RAD;
-var PRESETS = {
-	coral: {
-		feed: .0545,
-		kill: .062
-	},
-	mitosis: {
-		feed: .0367,
-		kill: .0649
-	},
-	spots: {
-		feed: .03,
-		kill: .062
-	},
-	maze: {
-		feed: .029,
-		kill: .057
-	},
-	worms: {
-		feed: .078,
-		kill: .061
-	},
-	fingerprints: {
-		feed: .037,
-		kill: .06
-	},
-	holes: {
-		feed: .039,
-		kill: .058
-	},
-	solitons: {
-		feed: .074,
-		kill: .064
-	},
-	bubbles: {
-		feed: .098,
-		kill: .0555
-	},
-	waves: {
-		feed: .014,
-		kill: .045
-	},
-	flowers: {
-		feed: .062,
-		kill: .06093
-	}
-};
-var CHILD_CONTRAST_MAX = 8;
-var CHILD_DFEED = .022;
-var CHILD_DKILL = .014;
-var CHILD_FEED_MIN = .008;
-var CHILD_FEED_MAX = .11;
-var CHILD_KILL_MIN = .03;
-var CHILD_KILL_MAX = .075;
-var RDParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
-	feed: f32,
-	kill: f32,
-	dv: f32,
-	brushRadSq: f32,
-	brushStrength: f32,
-	cursorX: f32,
-	cursorY: f32,
-	cursorActive: f32,
-	childInfluence: f32,
-	childContrast: f32,
-	childThreshold: f32,
-	childInvert: f32,
-	childMapX: f32,
-	childMapY: f32,
-	_pad0: f32,
-	_pad1: f32
-}), "RDParams");
-var reactionLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.bindGroupLayout({
-	readBuf: {
-		storage: arrayOf(vec2f, COUNT),
-		access: "readonly"
-	},
-	writeBuf: {
-		storage: arrayOf(vec2f, COUNT),
-		access: "mutable"
-	},
-	params: { uniform: RDParams }
-}), "reactionLayout");
-var seedLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.bindGroupLayout({ stateBuf: {
-	storage: arrayOf(vec2f, COUNT),
-	access: "mutable"
-} }), "seedLayout");
-var outputLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.bindGroupLayout({
-	srcBuf: {
-		storage: arrayOf(vec2f, COUNT),
-		access: "readonly"
-	},
-	outTex: { storageTexture: textureStorage2d(STATE_FORMAT, "write-only") }
-}), "outputLayout");
-var reactionChildLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.bindGroupLayout({
-	readBuf: {
-		storage: arrayOf(vec2f, COUNT),
-		access: "readonly"
-	},
-	writeBuf: {
-		storage: arrayOf(vec2f, COUNT),
-		access: "mutable"
-	},
-	params: { uniform: RDParams },
-	childTex: { texture: texture2d(f32) }
-}), "reactionChildLayout");
-var makeNbrState = (layout, name) => typegpu_default.fn([
-	i32,
-	i32,
-	i32,
-	i32
-], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((ii, ji, di, dj) => {
-	"use gpu";
-	const row = clamp(__tsover_add(ii, di), 0, __tsover_sub(N, 1));
-	const col = clamp(__tsover_add(ji, dj), 0, __tsover_sub(N, 1));
-	return layout.$.readBuf[u32(__tsover_add(__tsover_mul(row, N), col))];
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "ii"
-			},
-			{
-				"type": "i",
-				"name": "ji"
-			},
-			{
-				"type": "i",
-				"name": "di"
-			},
-			{
-				"type": "i",
-				"name": "dj"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"row",
-				[
-					6,
-					"std.clamp",
-					[
-						[
-							1,
-							"ii",
-							"+",
-							"di"
-						],
-						[5, "0"],
-						[
-							1,
-							"N",
-							"-",
-							[5, "1"]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"col",
-				[
-					6,
-					"std.clamp",
-					[
-						[
-							1,
-							"ji",
-							"+",
-							"dj"
-						],
-						[5, "0"],
-						[
-							1,
-							"N",
-							"-",
-							[5, "1"]
-						]
-					]
-				]
-			],
-			[10, [
-				8,
-				[
-					7,
-					[
-						7,
-						"layout",
-						"$"
-					],
-					"readBuf"
-				],
-				[
-					6,
-					"d.u32",
-					[[
-						1,
-						[
-							1,
-							"row",
-							"*",
-							"N"
-						],
-						"+",
-						"col"
-					]]
-				]
-			]]
-		]]
-	},
-	externals: {
-		"std.clamp": () => clamp,
-		"N": () => N,
-		"layout": () => layout,
-		"d.u32": () => u32
-	}
-}) && $.f)({})).$name(name);
-var nbrState = makeNbrState(reactionLayout, "reactionDiffusionNbr");
-var nbrStateChild = makeNbrState(reactionChildLayout, "reactionDiffusionNbrChild");
-var rdRatesPlain = typegpu_default.fn([
-	f32,
-	f32,
-	u32,
-	u32
-], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((feed, kill) => {
-	"use gpu";
-	return vec2f(feed, kill);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "feed"
-		}, {
-			"type": "i",
-			"name": "kill"
-		}],
-		"body": [0, [[10, [
-			6,
-			"d.vec2f",
-			["feed", "kill"]
-		]]]]
-	},
-	externals: { "d.vec2f": () => vec2f }
-}) && $.f)({})).$name("reactionDiffusionRates");
-var makeReactionKernel = (layout, nbr, rates, name) => typegpu_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-	"use gpu";
-	const p = layout.$.params;
-	const idx = __tsover_add(__tsover_mul(cy, u32(N)), cx);
-	const self = layout.$.readBuf[idx];
-	const ii = i32(cy);
-	const ji = i32(cx);
-	const L = nbr(ii, ji, 0, -1);
-	const R = nbr(ii, ji, 0, 1);
-	const T = nbr(ii, ji, -1, 0);
-	const B = nbr(ii, ji, 1, 0);
-	const TL = nbr(ii, ji, -1, -1);
-	const TR = nbr(ii, ji, -1, 1);
-	const BL = nbr(ii, ji, 1, -1);
-	const BR = nbr(ii, ji, 1, 1);
-	const lapU = __tsover_sub(__tsover_add(__tsover_mul(__tsover_add(__tsover_add(__tsover_add(L.x, R.x), T.x), B.x), .2), __tsover_mul(__tsover_add(__tsover_add(__tsover_add(TL.x, TR.x), BL.x), BR.x), .05)), self.x);
-	const lapV = __tsover_sub(__tsover_add(__tsover_mul(__tsover_add(__tsover_add(__tsover_add(L.y, R.y), T.y), B.y), .2), __tsover_mul(__tsover_add(__tsover_add(__tsover_add(TL.y, TR.y), BL.y), BR.y), .05)), self.y);
-	const fk = rates(p.feed, p.kill, cx, cy);
-	const feedCell = fk.x;
-	const killCell = fk.y;
-	const U = self.x;
-	const V = self.y;
-	const uvv = __tsover_mul(__tsover_mul(U, V), V);
-	let newU = __tsover_add(U, __tsover_add(__tsover_sub(lapU, uvv), __tsover_mul(feedCell, __tsover_sub(1, U))));
-	let newV = __tsover_add(V, __tsover_sub(__tsover_add(__tsover_mul(p.dv, lapV), uvv), __tsover_mul(__tsover_add(feedCell, killCell), V)));
-	if (p.cursorActive > 0) {
-		const cellX = __tsover_add(f32(cx), .5);
-		const cellY = __tsover_add(f32(cy), .5);
-		const dxp = __tsover_sub(cellX, p.cursorX);
-		const dyp = __tsover_sub(cellY, p.cursorY);
-		const distSq = __tsover_add(__tsover_mul(dxp, dxp), __tsover_mul(dyp, dyp));
-		const inf = __tsover_mul(exp(__tsover_mul(__tsover_div(distSq, max(p.brushRadSq, f32(1))), -1)), p.cursorActive);
-		newV = min(__tsover_add(newV, __tsover_mul(inf, p.brushStrength)), f32(1));
-	}
-	newU = clamp(newU, 0, 1);
-	newV = clamp(newV, 0, 1);
-	layout.$.writeBuf[idx] = vec2f(newU, newV);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "cx"
-		}, {
-			"type": "i",
-			"name": "cy"
-		}],
-		"body": [0, [
-			[
-				13,
-				"p",
-				[
-					7,
-					[
-						7,
-						"layout",
-						"$"
-					],
-					"params"
-				]
-			],
-			[
-				13,
-				"idx",
-				[
-					1,
-					[
-						1,
-						"cy",
-						"*",
-						[
-							6,
-							"d.u32",
-							["N"]
-						]
-					],
-					"+",
-					"cx"
-				]
-			],
-			[
-				13,
-				"self",
-				[
-					8,
-					[
-						7,
-						[
-							7,
-							"layout",
-							"$"
-						],
-						"readBuf"
-					],
-					"idx"
-				]
-			],
-			[
-				13,
-				"ii",
-				[
-					6,
-					"d.i32",
-					["cy"]
-				]
-			],
-			[
-				13,
-				"ji",
-				[
-					6,
-					"d.i32",
-					["cx"]
-				]
-			],
-			[
-				13,
-				"L",
-				[
-					6,
-					"nbr",
-					[
-						"ii",
-						"ji",
-						[5, "0"],
-						[
-							4,
-							"-",
-							[5, "1"]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"R",
-				[
-					6,
-					"nbr",
-					[
-						"ii",
-						"ji",
-						[5, "0"],
-						[5, "1"]
-					]
-				]
-			],
-			[
-				13,
-				"T",
-				[
-					6,
-					"nbr",
-					[
-						"ii",
-						"ji",
-						[
-							4,
-							"-",
-							[5, "1"]
-						],
-						[5, "0"]
-					]
-				]
-			],
-			[
-				13,
-				"B",
-				[
-					6,
-					"nbr",
-					[
-						"ii",
-						"ji",
-						[5, "1"],
-						[5, "0"]
-					]
-				]
-			],
-			[
-				13,
-				"TL",
-				[
-					6,
-					"nbr",
-					[
-						"ii",
-						"ji",
-						[
-							4,
-							"-",
-							[5, "1"]
-						],
-						[
-							4,
-							"-",
-							[5, "1"]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"TR",
-				[
-					6,
-					"nbr",
-					[
-						"ii",
-						"ji",
-						[
-							4,
-							"-",
-							[5, "1"]
-						],
-						[5, "1"]
-					]
-				]
-			],
-			[
-				13,
-				"BL",
-				[
-					6,
-					"nbr",
-					[
-						"ii",
-						"ji",
-						[5, "1"],
-						[
-							4,
-							"-",
-							[5, "1"]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"BR",
-				[
-					6,
-					"nbr",
-					[
-						"ii",
-						"ji",
-						[5, "1"],
-						[5, "1"]
-					]
-				]
-			],
-			[
-				13,
-				"lapU",
-				[
-					1,
-					[
-						1,
-						[
-							1,
-							[
-								1,
-								[
-									1,
-									[
-										1,
-										[
-											7,
-											"L",
-											"x"
-										],
-										"+",
-										[
-											7,
-											"R",
-											"x"
-										]
-									],
-									"+",
-									[
-										7,
-										"T",
-										"x"
-									]
-								],
-								"+",
-								[
-									7,
-									"B",
-									"x"
-								]
-							],
-							"*",
-							[5, "0.2"]
-						],
-						"+",
-						[
-							1,
-							[
-								1,
-								[
-									1,
-									[
-										1,
-										[
-											7,
-											"TL",
-											"x"
-										],
-										"+",
-										[
-											7,
-											"TR",
-											"x"
-										]
-									],
-									"+",
-									[
-										7,
-										"BL",
-										"x"
-									]
-								],
-								"+",
-								[
-									7,
-									"BR",
-									"x"
-								]
-							],
-							"*",
-							[5, "0.05"]
-						]
-					],
-					"-",
-					[
-						7,
-						"self",
-						"x"
-					]
-				]
-			],
-			[
-				13,
-				"lapV",
-				[
-					1,
-					[
-						1,
-						[
-							1,
-							[
-								1,
-								[
-									1,
-									[
-										1,
-										[
-											7,
-											"L",
-											"y"
-										],
-										"+",
-										[
-											7,
-											"R",
-											"y"
-										]
-									],
-									"+",
-									[
-										7,
-										"T",
-										"y"
-									]
-								],
-								"+",
-								[
-									7,
-									"B",
-									"y"
-								]
-							],
-							"*",
-							[5, "0.2"]
-						],
-						"+",
-						[
-							1,
-							[
-								1,
-								[
-									1,
-									[
-										1,
-										[
-											7,
-											"TL",
-											"y"
-										],
-										"+",
-										[
-											7,
-											"TR",
-											"y"
-										]
-									],
-									"+",
-									[
-										7,
-										"BL",
-										"y"
-									]
-								],
-								"+",
-								[
-									7,
-									"BR",
-									"y"
-								]
-							],
-							"*",
-							[5, "0.05"]
-						]
-					],
-					"-",
-					[
-						7,
-						"self",
-						"y"
-					]
-				]
-			],
-			[
-				13,
-				"fk",
-				[
-					6,
-					"rates",
-					[
-						[
-							7,
-							"p",
-							"feed"
-						],
-						[
-							7,
-							"p",
-							"kill"
-						],
-						"cx",
-						"cy"
-					]
-				]
-			],
-			[
-				13,
-				"feedCell",
-				[
-					7,
-					"fk",
-					"x"
-				]
-			],
-			[
-				13,
-				"killCell",
-				[
-					7,
-					"fk",
-					"y"
-				]
-			],
-			[
-				13,
-				"U",
-				[
-					7,
-					"self",
-					"x"
-				]
-			],
-			[
-				13,
-				"V",
-				[
-					7,
-					"self",
-					"y"
-				]
-			],
-			[
-				13,
-				"uvv",
-				[
-					1,
-					[
-						1,
-						"U",
-						"*",
-						"V"
-					],
-					"*",
-					"V"
-				]
-			],
-			[
-				12,
-				"newU",
-				[
-					1,
-					"U",
-					"+",
-					[
-						1,
-						[
-							1,
-							"lapU",
-							"-",
-							"uvv"
-						],
-						"+",
-						[
-							1,
-							"feedCell",
-							"*",
-							[
-								1,
-								[5, "1"],
-								"-",
-								"U"
-							]
-						]
-					]
-				]
-			],
-			[
-				12,
-				"newV",
-				[
-					1,
-					"V",
-					"+",
-					[
-						1,
-						[
-							1,
-							[
-								1,
-								[
-									7,
-									"p",
-									"dv"
-								],
-								"*",
-								"lapV"
-							],
-							"+",
-							"uvv"
-						],
-						"-",
-						[
-							1,
-							[
-								1,
-								"feedCell",
-								"+",
-								"killCell"
-							],
-							"*",
-							"V"
-						]
-					]
-				]
-			],
-			[
-				11,
-				[
-					1,
-					[
-						7,
-						"p",
-						"cursorActive"
-					],
-					">",
-					[5, "0"]
-				],
-				[0, [
-					[
-						13,
-						"cellX",
-						[
-							1,
-							[
-								6,
-								"d.f32",
-								["cx"]
-							],
-							"+",
-							[5, "0.5"]
-						]
-					],
-					[
-						13,
-						"cellY",
-						[
-							1,
-							[
-								6,
-								"d.f32",
-								["cy"]
-							],
-							"+",
-							[5, "0.5"]
-						]
-					],
-					[
-						13,
-						"dxp",
-						[
-							1,
-							"cellX",
-							"-",
-							[
-								7,
-								"p",
-								"cursorX"
-							]
-						]
-					],
-					[
-						13,
-						"dyp",
-						[
-							1,
-							"cellY",
-							"-",
-							[
-								7,
-								"p",
-								"cursorY"
-							]
-						]
-					],
-					[
-						13,
-						"distSq",
-						[
-							1,
-							[
-								1,
-								"dxp",
-								"*",
-								"dxp"
-							],
-							"+",
-							[
-								1,
-								"dyp",
-								"*",
-								"dyp"
-							]
-						]
-					],
-					[
-						13,
-						"inf",
-						[
-							1,
-							[
-								6,
-								"std.exp",
-								[[
-									1,
-									[
-										1,
-										"distSq",
-										"/",
-										[
-											6,
-											"std.max",
-											[[
-												7,
-												"p",
-												"brushRadSq"
-											], [
-												6,
-												"d.f32",
-												[[5, "1"]]
-											]]
-										]
-									],
-									"*",
-									[
-										4,
-										"-",
-										[5, "1"]
-									]
-								]]
-							],
-							"*",
-							[
-								7,
-								"p",
-								"cursorActive"
-							]
-						]
-					],
-					[
-						2,
-						"newV",
-						"=",
-						[
-							6,
-							"std.min",
-							[[
-								1,
-								"newV",
-								"+",
-								[
-									1,
-									"inf",
-									"*",
-									[
-										7,
-										"p",
-										"brushStrength"
-									]
-								]
-							], [
-								6,
-								"d.f32",
-								[[5, "1"]]
-							]]
-						]
-					]
-				]]
-			],
-			[
-				2,
-				"newU",
-				"=",
-				[
-					6,
-					"std.clamp",
-					[
-						"newU",
-						[5, "0"],
-						[5, "1"]
-					]
-				]
-			],
-			[
-				2,
-				"newV",
-				"=",
-				[
-					6,
-					"std.clamp",
-					[
-						"newV",
-						[5, "0"],
-						[5, "1"]
-					]
-				]
-			],
-			[
-				2,
-				[
-					8,
-					[
-						7,
-						[
-							7,
-							"layout",
-							"$"
-						],
-						"writeBuf"
-					],
-					"idx"
-				],
-				"=",
-				[
-					6,
-					"d.vec2f",
-					["newU", "newV"]
-				]
-			]
-		]]
-	},
-	externals: {
-		"layout": () => layout,
-		"d.u32": () => u32,
-		"N": () => N,
-		"d.i32": () => i32,
-		"nbr": () => nbr,
-		"rates": () => rates,
-		"d.f32": () => f32,
-		"std.exp": () => exp,
-		"std.max": () => max,
-		"std.min": () => min,
-		"std.clamp": () => clamp,
-		"d.vec2f": () => vec2f
-	}
-}) && $.f)({})).$name(name);
-const reactionKernel = makeReactionKernel(reactionLayout, nbrState, rdRatesPlain, "reactionDiffusionReact");
-const rdChildDrive = typegpu_default.fn([u32, u32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-	"use gpu";
-	const p = reactionChildLayout.$.params;
-	const dims = textureDimensions(reactionChildLayout.$.childTex);
-	const fw = f32(dims.x);
-	const fh = f32(dims.y);
-	const fx = __tsover_div(__tsover_add(f32(cx), .5), f32(N));
-	const fy = __tsover_div(__tsover_add(f32(cy), .5), f32(N));
-	const cu = clamp(__tsover_add(__tsover_mul(__tsover_sub(fx, .5), p.childMapX), .5), f32(0), f32(1));
-	const cv = clamp(__tsover_add(__tsover_mul(__tsover_sub(fy, .5), p.childMapY), .5), f32(0), f32(1));
-	const px = u32(min(__tsover_mul(cu, fw), __tsover_sub(fw, 1)));
-	const py = u32(min(__tsover_mul(cv, fh), __tsover_sub(fh, 1)));
-	const texel = textureLoad(reactionChildLayout.$.childTex, vec2u(px, py), 0);
-	const cov = clamp(texel.w, f32(0), f32(1));
-	const luma = dot(texel.xyz.div(max(texel.w, f32(.001))), vec3f(.2126, .7152, .0722));
-	const gain = __tsover_add(f32(1), __tsover_mul(p.childContrast, f32(CHILD_CONTRAST_MAX)));
-	const shaped = clamp(__tsover_add(__tsover_mul(__tsover_sub(luma, p.childThreshold), gain), .5), f32(0), f32(1));
-	let signed = __tsover_mul(__tsover_sub(shaped, .5), 2);
-	signed = select(signed, __tsover_mul(signed, -1), p.childInvert > .5);
-	return __tsover_mul(signed, cov);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "cx"
-		}, {
-			"type": "i",
-			"name": "cy"
-		}],
-		"body": [0, [
-			[
-				13,
-				"p",
-				[
-					7,
-					[
-						7,
-						"reactionChildLayout",
-						"$"
-					],
-					"params"
-				]
-			],
-			[
-				13,
-				"dims",
-				[
-					6,
-					"std.textureDimensions",
-					[[
-						7,
-						[
-							7,
-							"reactionChildLayout",
-							"$"
-						],
-						"childTex"
-					]]
-				]
-			],
-			[
-				13,
-				"fw",
-				[
-					6,
-					"d.f32",
-					[[
-						7,
-						"dims",
-						"x"
-					]]
-				]
-			],
-			[
-				13,
-				"fh",
-				[
-					6,
-					"d.f32",
-					[[
-						7,
-						"dims",
-						"y"
-					]]
-				]
-			],
-			[
-				13,
-				"fx",
-				[
-					1,
-					[
-						1,
-						[
-							6,
-							"d.f32",
-							["cx"]
-						],
-						"+",
-						[5, "0.5"]
-					],
-					"/",
-					[
-						6,
-						"d.f32",
-						["N"]
-					]
-				]
-			],
-			[
-				13,
-				"fy",
-				[
-					1,
-					[
-						1,
-						[
-							6,
-							"d.f32",
-							["cy"]
-						],
-						"+",
-						[5, "0.5"]
-					],
-					"/",
-					[
-						6,
-						"d.f32",
-						["N"]
-					]
-				]
-			],
-			[
-				13,
-				"cu",
-				[
-					6,
-					"std.clamp",
-					[
-						[
-							1,
-							[
-								1,
-								[
-									1,
-									"fx",
-									"-",
-									[5, "0.5"]
-								],
-								"*",
-								[
-									7,
-									"p",
-									"childMapX"
-								]
-							],
-							"+",
-							[5, "0.5"]
-						],
-						[
-							6,
-							"d.f32",
-							[[5, "0"]]
-						],
-						[
-							6,
-							"d.f32",
-							[[5, "1"]]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"cv",
-				[
-					6,
-					"std.clamp",
-					[
-						[
-							1,
-							[
-								1,
-								[
-									1,
-									"fy",
-									"-",
-									[5, "0.5"]
-								],
-								"*",
-								[
-									7,
-									"p",
-									"childMapY"
-								]
-							],
-							"+",
-							[5, "0.5"]
-						],
-						[
-							6,
-							"d.f32",
-							[[5, "0"]]
-						],
-						[
-							6,
-							"d.f32",
-							[[5, "1"]]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"px",
-				[
-					6,
-					"d.u32",
-					[[
-						6,
-						"std.min",
-						[[
-							1,
-							"cu",
-							"*",
-							"fw"
-						], [
-							1,
-							"fw",
-							"-",
-							[5, "1"]
-						]]
-					]]
-				]
-			],
-			[
-				13,
-				"py",
-				[
-					6,
-					"d.u32",
-					[[
-						6,
-						"std.min",
-						[[
-							1,
-							"cv",
-							"*",
-							"fh"
-						], [
-							1,
-							"fh",
-							"-",
-							[5, "1"]
-						]]
-					]]
-				]
-			],
-			[
-				13,
-				"texel",
-				[
-					6,
-					"std.textureLoad",
-					[
-						[
-							7,
-							[
-								7,
-								"reactionChildLayout",
-								"$"
-							],
-							"childTex"
-						],
-						[
-							6,
-							"d.vec2u",
-							["px", "py"]
-						],
-						[5, "0"]
-					]
-				]
-			],
-			[
-				13,
-				"cov",
-				[
-					6,
-					"std.clamp",
-					[
-						[
-							7,
-							"texel",
-							"w"
-						],
-						[
-							6,
-							"d.f32",
-							[[5, "0"]]
-						],
-						[
-							6,
-							"d.f32",
-							[[5, "1"]]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"rgb",
-				[
-					6,
-					[
-						7,
-						[
-							7,
-							"texel",
-							"xyz"
-						],
-						"div"
-					],
-					[[
-						6,
-						"std.max",
-						[[
-							7,
-							"texel",
-							"w"
-						], [
-							6,
-							"d.f32",
-							[[5, "0.001"]]
-						]]
-					]]
-				]
-			],
-			[
-				13,
-				"luma",
-				[
-					6,
-					"std.dot",
-					["rgb", [
-						6,
-						"d.vec3f",
-						[
-							[5, "0.2126"],
-							[5, "0.7152"],
-							[5, "0.0722"]
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"gain",
-				[
-					1,
-					[
-						6,
-						"d.f32",
-						[[5, "1"]]
-					],
-					"+",
-					[
-						1,
-						[
-							7,
-							"p",
-							"childContrast"
-						],
-						"*",
-						[
-							6,
-							"d.f32",
-							["CHILD_CONTRAST_MAX"]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"shaped",
-				[
-					6,
-					"std.clamp",
-					[
-						[
-							1,
-							[
-								1,
-								[
-									1,
-									"luma",
-									"-",
-									[
-										7,
-										"p",
-										"childThreshold"
-									]
-								],
-								"*",
-								"gain"
-							],
-							"+",
-							[5, "0.5"]
-						],
-						[
-							6,
-							"d.f32",
-							[[5, "0"]]
-						],
-						[
-							6,
-							"d.f32",
-							[[5, "1"]]
-						]
-					]
-				]
-			],
-			[
-				12,
-				"signed",
-				[
-					1,
-					[
-						1,
-						"shaped",
-						"-",
-						[5, "0.5"]
-					],
-					"*",
-					[5, "2"]
-				]
-			],
-			[
-				2,
-				"signed",
-				"=",
-				[
-					6,
-					"std.select",
-					[
-						"signed",
-						[
-							1,
-							"signed",
-							"*",
-							[
-								4,
-								"-",
-								[5, "1"]
-							]
-						],
-						[
-							1,
-							[
-								7,
-								"p",
-								"childInvert"
-							],
-							">",
-							[5, "0.5"]
-						]
-					]
-				]
-			],
-			[10, [
-				1,
-				"signed",
-				"*",
-				"cov"
-			]]
-		]]
-	},
-	externals: {
-		"reactionChildLayout": () => reactionChildLayout,
-		"std.textureDimensions": () => textureDimensions,
-		"d.f32": () => f32,
-		"N": () => N,
-		"std.clamp": () => clamp,
-		"d.u32": () => u32,
-		"std.min": () => min,
-		"std.textureLoad": () => textureLoad,
-		"d.vec2u": () => vec2u,
-		"std.max": () => max,
-		"std.dot": () => dot,
-		"d.vec3f": () => vec3f,
-		"CHILD_CONTRAST_MAX": () => CHILD_CONTRAST_MAX,
-		"std.select": () => select
-	}
-}) && $.f)({})).$name("reactionDiffusionChildDrive");
-const reactionKernelChild = makeReactionKernel(reactionChildLayout, nbrStateChild, typegpu_default.fn([
-	f32,
-	f32,
-	u32,
-	u32
-], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((feed, kill, cx, cy) => {
-	"use gpu";
-	const mod = __tsover_mul(rdChildDrive(cx, cy), reactionChildLayout.$.params.childInfluence);
-	return vec2f(clamp(__tsover_add(feed, __tsover_mul(mod, f32(CHILD_DFEED))), f32(CHILD_FEED_MIN), f32(CHILD_FEED_MAX)), clamp(__tsover_sub(kill, __tsover_mul(mod, f32(CHILD_DKILL))), f32(CHILD_KILL_MIN), f32(CHILD_KILL_MAX)));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "feed"
-			},
-			{
-				"type": "i",
-				"name": "kill"
-			},
-			{
-				"type": "i",
-				"name": "cx"
-			},
-			{
-				"type": "i",
-				"name": "cy"
-			}
-		],
-		"body": [0, [[
-			13,
-			"mod",
-			[
-				1,
-				[
-					6,
-					"rdChildDrive",
-					["cx", "cy"]
-				],
-				"*",
-				[
-					7,
-					[
-						7,
-						[
-							7,
-							"reactionChildLayout",
-							"$"
-						],
-						"params"
-					],
-					"childInfluence"
-				]
-			]
-		], [10, [
-			6,
-			"d.vec2f",
-			[[
-				6,
-				"std.clamp",
-				[
-					[
-						1,
-						"feed",
-						"+",
-						[
-							1,
-							"mod",
-							"*",
-							[
-								6,
-								"d.f32",
-								["CHILD_DFEED"]
-							]
-						]
-					],
-					[
-						6,
-						"d.f32",
-						["CHILD_FEED_MIN"]
-					],
-					[
-						6,
-						"d.f32",
-						["CHILD_FEED_MAX"]
-					]
-				]
-			], [
-				6,
-				"std.clamp",
-				[
-					[
-						1,
-						"kill",
-						"-",
-						[
-							1,
-							"mod",
-							"*",
-							[
-								6,
-								"d.f32",
-								["CHILD_DKILL"]
-							]
-						]
-					],
-					[
-						6,
-						"d.f32",
-						["CHILD_KILL_MIN"]
-					],
-					[
-						6,
-						"d.f32",
-						["CHILD_KILL_MAX"]
-					]
-				]
-			]]
-		]]]]
-	},
-	externals: {
-		"rdChildDrive": () => rdChildDrive,
-		"reactionChildLayout": () => reactionChildLayout,
-		"d.vec2f": () => vec2f,
-		"std.clamp": () => clamp,
-		"d.f32": () => f32,
-		"CHILD_DFEED": () => CHILD_DFEED,
-		"CHILD_FEED_MIN": () => CHILD_FEED_MIN,
-		"CHILD_FEED_MAX": () => CHILD_FEED_MAX,
-		"CHILD_DKILL": () => CHILD_DKILL,
-		"CHILD_KILL_MIN": () => CHILD_KILL_MIN,
-		"CHILD_KILL_MAX": () => CHILD_KILL_MAX
-	}
-}) && $.f)({})).$name("reactionDiffusionRatesChild"), "reactionDiffusionReactChild");
-const seedKernel = typegpu_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-	"use gpu";
-	const idx = __tsover_add(__tsover_mul(cy, u32(N)), cx);
-	const h = hash12(vec2f(f32(cx), f32(cy)));
-	const vSeed = select(f32(0), f32(1), h < SEED_DENSITY);
-	seedLayout.$.stateBuf[idx] = vec2f(1, vSeed);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "cx"
-		}, {
-			"type": "i",
-			"name": "cy"
-		}],
-		"body": [0, [
-			[
-				13,
-				"idx",
-				[
-					1,
-					[
-						1,
-						"cy",
-						"*",
-						[
-							6,
-							"d.u32",
-							["N"]
-						]
-					],
-					"+",
-					"cx"
-				]
-			],
-			[
-				13,
-				"h",
-				[
-					6,
-					"noise.hash12",
-					[[
-						6,
-						"d.vec2f",
-						[[
-							6,
-							"d.f32",
-							["cx"]
-						], [
-							6,
-							"d.f32",
-							["cy"]
-						]]
-					]]
-				]
-			],
-			[
-				13,
-				"vSeed",
-				[
-					6,
-					"std.select",
-					[
-						[
-							6,
-							"d.f32",
-							[[5, "0"]]
-						],
-						[
-							6,
-							"d.f32",
-							[[5, "1"]]
-						],
-						[
-							1,
-							"h",
-							"<",
-							"SEED_DENSITY"
-						]
-					]
-				]
-			],
-			[
-				2,
-				[
-					8,
-					[
-						7,
-						[
-							7,
-							"seedLayout",
-							"$"
-						],
-						"stateBuf"
-					],
-					"idx"
-				],
-				"=",
-				[
-					6,
-					"d.vec2f",
-					[[5, "1"], "vSeed"]
-				]
-			]
-		]]
-	},
-	externals: {
-		"d.u32": () => u32,
-		"N": () => N,
-		"noise.hash12": () => hash12,
-		"d.vec2f": () => vec2f,
-		"d.f32": () => f32,
-		"std.select": () => select,
-		"SEED_DENSITY": () => SEED_DENSITY,
-		"seedLayout": () => seedLayout
-	}
-}) && $.f)({})).$name("reactionDiffusionSeed");
-const outputKernel = typegpu_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-	"use gpu";
-	const idx = __tsover_add(__tsover_mul(cy, u32(N)), cx);
-	const s = outputLayout.$.srcBuf[idx];
-	textureStore(outputLayout.$.outTex, vec2u(cx, cy), vec4f(s.x, s.y, 0, 0));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "cx"
-		}, {
-			"type": "i",
-			"name": "cy"
-		}],
-		"body": [0, [
-			[
-				13,
-				"idx",
-				[
-					1,
-					[
-						1,
-						"cy",
-						"*",
-						[
-							6,
-							"d.u32",
-							["N"]
-						]
-					],
-					"+",
-					"cx"
-				]
-			],
-			[
-				13,
-				"s",
-				[
-					8,
-					[
-						7,
-						[
-							7,
-							"outputLayout",
-							"$"
-						],
-						"srcBuf"
-					],
-					"idx"
-				]
-			],
-			[
-				6,
-				"std.textureStore",
-				[
-					[
-						7,
-						[
-							7,
-							"outputLayout",
-							"$"
-						],
-						"outTex"
-					],
-					[
-						6,
-						"d.vec2u",
-						["cx", "cy"]
-					],
-					[
-						6,
-						"d.vec4f",
-						[
-							[
-								7,
-								"s",
-								"x"
-							],
-							[
-								7,
-								"s",
-								"y"
-							],
-							[5, "0"],
-							[5, "0"]
-						]
-					]
-				]
-			]
-		]]
-	},
-	externals: {
-		"d.u32": () => u32,
-		"N": () => N,
-		"outputLayout": () => outputLayout,
-		"std.textureStore": () => textureStore,
-		"d.vec2u": () => vec2u,
-		"d.vec4f": () => vec4f
-	}
-}) && $.f)({})).$name("reactionDiffusionOutput");
-const rdSampleUV = typegpu_default.fn([
-	vec2f,
-	f32,
-	f32
-], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, featureSize) => {
-	"use gpu";
-	const view = __tsover_div(1, featureSize);
-	const sx = min(aspect, 1);
-	const sy = min(__tsover_div(1, aspect), 1);
-	return vec2f(__tsover_add(__tsover_mul(__tsover_mul(__tsover_sub(uv.x, .5), sx), view), .5), __tsover_add(__tsover_mul(__tsover_mul(__tsover_sub(uv.y, .5), sy), view), .5));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "uv"
-			},
-			{
-				"type": "i",
-				"name": "aspect"
-			},
-			{
-				"type": "i",
-				"name": "featureSize"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"view",
-				[
-					1,
-					[5, "1"],
-					"/",
-					"featureSize"
-				]
-			],
-			[
-				13,
-				"sx",
-				[
-					6,
-					"std.min",
-					["aspect", [5, "1"]]
-				]
-			],
-			[
-				13,
-				"sy",
-				[
-					6,
-					"std.min",
-					[[
-						1,
-						[5, "1"],
-						"/",
-						"aspect"
-					], [5, "1"]]
-				]
-			],
-			[
-				13,
-				"fx",
-				[
-					1,
-					[
-						1,
-						[
-							1,
-							[
-								1,
-								[
-									7,
-									"uv",
-									"x"
-								],
-								"-",
-								[5, "0.5"]
-							],
-							"*",
-							"sx"
-						],
-						"*",
-						"view"
-					],
-					"+",
-					[5, "0.5"]
-				]
-			],
-			[
-				13,
-				"fy",
-				[
-					1,
-					[
-						1,
-						[
-							1,
-							[
-								1,
-								[
-									7,
-									"uv",
-									"y"
-								],
-								"-",
-								[5, "0.5"]
-							],
-							"*",
-							"sy"
-						],
-						"*",
-						"view"
-					],
-					"+",
-					[5, "0.5"]
-				]
-			],
-			[10, [
-				6,
-				"d.vec2f",
-				["fx", "fy"]
-			]]
-		]]
-	},
-	externals: {
-		"std.min": () => min,
-		"d.vec2f": () => vec2f
-	}
-}) && $.f)({})).$name("reactionDiffusionSampleUV");
-const rdRampT = typegpu_default.fn([
-	f32,
-	f32,
-	f32
-], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((v, contrast, threshold) => {
-	"use gpu";
-	const w = max(__tsover_sub(.6, __tsover_mul(contrast, .55)), .02);
-	return smoothstep(__tsover_sub(threshold, w), __tsover_add(threshold, w), v);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "v"
-			},
-			{
-				"type": "i",
-				"name": "contrast"
-			},
-			{
-				"type": "i",
-				"name": "threshold"
-			}
-		],
-		"body": [0, [[
-			13,
-			"w",
-			[
-				6,
-				"std.max",
-				[[
-					1,
-					[5, "0.6"],
-					"-",
-					[
-						1,
-						"contrast",
-						"*",
-						[5, "0.55"]
-					]
-				], [5, "0.02"]]
-			]
-		], [10, [
-			6,
-			"std.smoothstep",
-			[
-				[
-					1,
-					"threshold",
-					"-",
-					"w"
-				],
-				[
-					1,
-					"threshold",
-					"+",
-					"w"
-				],
-				"v"
-			]
-		]]]]
-	},
-	externals: {
-		"std.max": () => max,
-		"std.smoothstep": () => smoothstep
-	}
-}) && $.f)({}));
-const rdSeg = typegpu_default.fn([f32, f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((t, offset) => {
-	"use gpu";
-	return clamp(__tsover_sub(__tsover_mul(t, 2), offset), 0, 1);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "t"
-		}, {
-			"type": "i",
-			"name": "offset"
-		}],
-		"body": [0, [[10, [
-			6,
-			"std.clamp",
-			[
-				[
-					1,
-					[
-						1,
-						"t",
-						"*",
-						[5, "2"]
-					],
-					"-",
-					"offset"
-				],
-				[5, "0"],
-				[5, "1"]
-			]
-		]]]]
-	},
-	externals: { "std.clamp": () => clamp }
-}) && $.f)({}));
-const rdPickSeg = typegpu_default.fn([
-	vec4f,
-	vec4f,
-	f32
-], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((lo, hi, t) => {
-	"use gpu";
-	const useHi = t > .5;
-	return vec4f(select(lo.x, hi.x, useHi), select(lo.y, hi.y, useHi), select(lo.z, hi.z, useHi), select(lo.w, hi.w, useHi));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "lo"
-			},
-			{
-				"type": "i",
-				"name": "hi"
-			},
-			{
-				"type": "i",
-				"name": "t"
-			}
-		],
-		"body": [0, [[
-			13,
-			"useHi",
-			[
-				1,
-				"t",
-				">",
-				[5, "0.5"]
-			]
-		], [10, [
-			6,
-			"d.vec4f",
-			[
-				[
-					6,
-					"std.select",
-					[
-						[
-							7,
-							"lo",
-							"x"
-						],
-						[
-							7,
-							"hi",
-							"x"
-						],
-						"useHi"
-					]
-				],
-				[
-					6,
-					"std.select",
-					[
-						[
-							7,
-							"lo",
-							"y"
-						],
-						[
-							7,
-							"hi",
-							"y"
-						],
-						"useHi"
-					]
-				],
-				[
-					6,
-					"std.select",
-					[
-						[
-							7,
-							"lo",
-							"z"
-						],
-						[
-							7,
-							"hi",
-							"z"
-						],
-						"useHi"
-					]
-				],
-				[
-					6,
-					"std.select",
-					[
-						[
-							7,
-							"lo",
-							"w"
-						],
-						[
-							7,
-							"hi",
-							"w"
-						],
-						"useHi"
-					]
-				]
-			]
-		]]]]
-	},
-	externals: {
-		"d.vec4f": () => vec4f,
-		"std.select": () => select
-	}
-}) && $.f)({}));
-const rdShiftUV = typegpu_default.fn([
-	vec2f,
-	f32,
-	f32
-], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, ox, oy) => {
-	"use gpu";
-	return vec2f(__tsover_add(uv.x, ox), __tsover_add(uv.y, oy));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "uv"
-			},
-			{
-				"type": "i",
-				"name": "ox"
-			},
-			{
-				"type": "i",
-				"name": "oy"
-			}
-		],
-		"body": [0, [[10, [
-			6,
-			"d.vec2f",
-			[[
-				1,
-				[
-					7,
-					"uv",
-					"x"
-				],
-				"+",
-				"ox"
-			], [
-				1,
-				[
-					7,
-					"uv",
-					"y"
-				],
-				"+",
-				"oy"
-			]]
-		]]]]
-	},
-	externals: { "d.vec2f": () => vec2f }
-}) && $.f)({})).$name("reactionDiffusionShiftUV");
-const rdShade = typegpu_default.fn([
-	vec4f,
-	f32,
-	f32,
-	f32,
-	f32,
-	f32,
-	f32
-], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((base, vL, vR, vT, vB, relief, lightAngle) => {
-	"use gpu";
-	const gx = __tsover_mul(__tsover_sub(vR, vL), f32(RELIEF_STRENGTH));
-	const gy = __tsover_mul(__tsover_sub(vB, vT), f32(RELIEF_STRENGTH));
-	const n = normalize(vec3f(-gx, -gy, f32(1)));
-	const ang = __tsover_mul(lightAngle, DEG2RAD);
-	const lightDir = normalize(vec3f(__tsover_mul(cos(ang), RELIEF_LIGHT_XY), __tsover_mul(sin(ang), RELIEF_LIGHT_XY), RELIEF_LIGHT_Z));
-	const diff = clamp(dot(n, lightDir), f32(0), f32(1));
-	const shade = __tsover_add(RELIEF_AMBIENT, __tsover_mul(__tsover_sub(f32(1), RELIEF_AMBIENT), diff));
-	const halfVec = normalize(lightDir.add(vec3f(f32(0), f32(0), f32(1))));
-	const spec = __tsover_mul(pow(clamp(dot(n, halfVec), f32(0), f32(1)), f32(RELIEF_SHININESS)), RELIEF_SPEC);
-	const litRgb = base.xyz.mul(shade).add(vec3f(spec, spec, spec));
-	const outRgb = mix(base.xyz, litRgb, relief);
-	return vec4f(outRgb.x, outRgb.y, outRgb.z, base.w);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "base"
-			},
-			{
-				"type": "i",
-				"name": "vL"
-			},
-			{
-				"type": "i",
-				"name": "vR"
-			},
-			{
-				"type": "i",
-				"name": "vT"
-			},
-			{
-				"type": "i",
-				"name": "vB"
-			},
-			{
-				"type": "i",
-				"name": "relief"
-			},
-			{
-				"type": "i",
-				"name": "lightAngle"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"gx",
-				[
-					1,
-					[
-						1,
-						"vR",
-						"-",
-						"vL"
-					],
-					"*",
-					[
-						6,
-						"d.f32",
-						["RELIEF_STRENGTH"]
-					]
-				]
-			],
-			[
-				13,
-				"gy",
-				[
-					1,
-					[
-						1,
-						"vB",
-						"-",
-						"vT"
-					],
-					"*",
-					[
-						6,
-						"d.f32",
-						["RELIEF_STRENGTH"]
-					]
-				]
-			],
-			[
-				13,
-				"n",
-				[
-					6,
-					"std.normalize",
-					[[
-						6,
-						"d.vec3f",
-						[
-							[
-								4,
-								"-",
-								"gx"
-							],
-							[
-								4,
-								"-",
-								"gy"
-							],
-							[
-								6,
-								"d.f32",
-								[[5, "1"]]
-							]
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"ang",
-				[
-					1,
-					"lightAngle",
-					"*",
-					"DEG2RAD"
-				]
-			],
-			[
-				13,
-				"lightDir",
-				[
-					6,
-					"std.normalize",
-					[[
-						6,
-						"d.vec3f",
-						[
-							[
-								1,
-								[
-									6,
-									"std.cos",
-									["ang"]
-								],
-								"*",
-								"RELIEF_LIGHT_XY"
-							],
-							[
-								1,
-								[
-									6,
-									"std.sin",
-									["ang"]
-								],
-								"*",
-								"RELIEF_LIGHT_XY"
-							],
-							"RELIEF_LIGHT_Z"
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"diff",
-				[
-					6,
-					"std.clamp",
-					[
-						[
-							6,
-							"std.dot",
-							["n", "lightDir"]
-						],
-						[
-							6,
-							"d.f32",
-							[[5, "0"]]
-						],
-						[
-							6,
-							"d.f32",
-							[[5, "1"]]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"shade",
-				[
-					1,
-					"RELIEF_AMBIENT",
-					"+",
-					[
-						1,
-						[
-							1,
-							[
-								6,
-								"d.f32",
-								[[5, "1"]]
-							],
-							"-",
-							"RELIEF_AMBIENT"
-						],
-						"*",
-						"diff"
-					]
-				]
-			],
-			[
-				13,
-				"halfVec",
-				[
-					6,
-					"std.normalize",
-					[[
-						6,
-						[
-							7,
-							"lightDir",
-							"add"
-						],
-						[[
-							6,
-							"d.vec3f",
-							[
-								[
-									6,
-									"d.f32",
-									[[5, "0"]]
-								],
-								[
-									6,
-									"d.f32",
-									[[5, "0"]]
-								],
-								[
-									6,
-									"d.f32",
-									[[5, "1"]]
-								]
-							]
-						]]
-					]]
-				]
-			],
-			[
-				13,
-				"spec",
-				[
-					1,
-					[
-						6,
-						"std.pow",
-						[[
-							6,
-							"std.clamp",
-							[
-								[
-									6,
-									"std.dot",
-									["n", "halfVec"]
-								],
-								[
-									6,
-									"d.f32",
-									[[5, "0"]]
-								],
-								[
-									6,
-									"d.f32",
-									[[5, "1"]]
-								]
-							]
-						], [
-							6,
-							"d.f32",
-							["RELIEF_SHININESS"]
-						]]
-					],
-					"*",
-					"RELIEF_SPEC"
-				]
-			],
-			[
-				13,
-				"litRgb",
-				[
-					6,
-					[
-						7,
-						[
-							6,
-							[
-								7,
-								[
-									7,
-									"base",
-									"xyz"
-								],
-								"mul"
-							],
-							["shade"]
-						],
-						"add"
-					],
-					[[
-						6,
-						"d.vec3f",
-						[
-							"spec",
-							"spec",
-							"spec"
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"outRgb",
-				[
-					6,
-					"std.mix",
-					[
-						[
-							7,
-							"base",
-							"xyz"
-						],
-						"litRgb",
-						"relief"
-					]
-				]
-			],
-			[10, [
-				6,
-				"d.vec4f",
-				[
-					[
-						7,
-						"outRgb",
-						"x"
-					],
-					[
-						7,
-						"outRgb",
-						"y"
-					],
-					[
-						7,
-						"outRgb",
-						"z"
-					],
-					[
-						7,
-						"base",
-						"w"
-					]
-				]
-			]]
-		]]
-	},
-	externals: {
-		"d.f32": () => f32,
-		"RELIEF_STRENGTH": () => RELIEF_STRENGTH,
-		"std.normalize": () => normalize,
-		"d.vec3f": () => vec3f,
-		"DEG2RAD": () => DEG2RAD,
-		"std.cos": () => cos,
-		"RELIEF_LIGHT_XY": () => RELIEF_LIGHT_XY,
-		"std.sin": () => sin,
-		"RELIEF_LIGHT_Z": () => RELIEF_LIGHT_Z,
-		"std.clamp": () => clamp,
-		"std.dot": () => dot,
-		"RELIEF_AMBIENT": () => RELIEF_AMBIENT,
-		"std.pow": () => pow,
-		"RELIEF_SHININESS": () => RELIEF_SHININESS,
-		"RELIEF_SPEC": () => RELIEF_SPEC,
-		"std.mix": () => mix,
-		"d.vec4f": () => vec4f
-	}
-}) && $.f)({})).$name("reactionDiffusionShade");
-const componentDefinition = {
-	name: "ReactionDiffusion",
-	boundingBoxDeclaration: { aspectRatio: null },
-	category: "Interactive",
-	description: "A living Gray-Scott reaction-diffusion pattern that fills the layer and blooms wherever you drag the cursor",
-	requiresRTT: false,
-	requiresChild: false,
-	acceptsOptionalChild: true,
-	usesPointer: true,
-	props: {
-		preset: {
-			default: "coral",
-			description: "Named Gray-Scott regime — drives the feed & kill rates for a whole family of patterns. Choose Custom to dial feed & kill by hand",
-			ui: {
-				type: "select",
-				options: [
-					{
-						label: "Coral",
-						value: "coral"
-					},
-					{
-						label: "Mitosis",
-						value: "mitosis"
-					},
-					{
-						label: "Spots",
-						value: "spots"
-					},
-					{
-						label: "Maze",
-						value: "maze"
-					},
-					{
-						label: "Worms",
-						value: "worms"
-					},
-					{
-						label: "Fingerprints",
-						value: "fingerprints"
-					},
-					{
-						label: "Holes",
-						value: "holes"
-					},
-					{
-						label: "Solitons",
-						value: "solitons"
-					},
-					{
-						label: "Bubbles",
-						value: "bubbles"
-					},
-					{
-						label: "Waves",
-						value: "waves"
-					},
-					{
-						label: "Flowers",
-						value: "flowers"
-					},
-					{
-						label: "Custom",
-						value: "custom"
-					}
-				],
-				label: "Pattern",
-				group: "Pattern"
-			}
-		},
-		feed: {
-			default: .0545,
-			description: "Feed rate — how fast chemical U is replenished (used when Pattern = Custom)",
-			ui: {
-				type: "range",
-				min: .01,
-				max: .1,
-				step: .001,
-				label: "Feed",
-				group: "Pattern",
-				condition: { preset: "custom" }
-			}
-		},
-		kill: {
-			default: .062,
-			description: "Kill rate — how fast chemical V is removed (used when Pattern = Custom)",
-			ui: {
-				type: "range",
-				min: .03,
-				max: .07,
-				step: .001,
-				label: "Kill",
-				group: "Pattern",
-				condition: { preset: "custom" }
-			}
-		},
-		diffusionRatio: {
-			default: .5,
-			description: "Ratio of the two chemicals' diffusion rates — shifts the pattern character (lower = tighter, more filament-like)",
-			ui: {
-				type: "range",
-				min: .2,
-				max: .9,
-				step: .01,
-				label: "Diffusion Ratio",
-				group: "Pattern"
-			}
-		},
-		featureSize: {
-			default: 3,
-			description: "Size of the pattern features — lower shows finer, smaller cells; higher magnifies them into larger cells",
-			ui: {
-				type: "range",
-				min: 1,
-				max: 6,
-				step: .1,
-				label: "Feature Size",
-				group: "Pattern"
-			}
-		},
-		speed: {
-			default: 6,
-			description: "Simulation steps per frame — higher evolves the pattern faster",
-			ui: {
-				type: "range",
-				min: 1,
-				max: MAX_ITERATIONS,
-				step: 1,
-				label: "Speed",
-				group: "Pattern"
-			}
-		},
-		brushSize: {
-			default: .04,
-			description: "Radius of the cursor brush that seeds new reagent as you drag",
-			ui: {
-				type: "range",
-				min: .01,
-				max: .3,
-				step: .01,
-				label: "Brush Size",
-				group: "Interaction"
-			}
-		},
-		brushStrength: {
-			default: .6,
-			description: "How much reagent the cursor injects while dragging",
-			ui: {
-				type: "range",
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Brush Strength",
-				group: "Interaction"
-			}
-		},
-		colorA: {
-			default: "transparent",
-			transform: transformColor,
-			description: "Background color (empty regions between cells)",
-			ui: {
-				type: "color",
-				label: "Background",
-				group: "Colors"
-			}
-		},
-		colorC: {
-			default: "#38bdf8",
-			transform: transformColor,
-			description: "Accent color at the cell walls (mid pattern values)",
-			ui: {
-				type: "color",
-				label: "Wall Color",
-				group: "Colors"
-			}
-		},
-		colorB: {
-			default: "#e2f5ff",
-			transform: transformColor,
-			description: "Color of the dense cell interiors (high pattern values)",
-			ui: {
-				type: "color",
-				label: "Cell Color",
-				group: "Colors"
-			}
-		},
-		contrast: {
-			default: .5,
-			description: "Sharpness of the cell walls — higher gives crisper, more graphic edges",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Contrast",
-				group: "Colors"
-			}
-		},
-		threshold: {
-			default: .28,
-			description: "Pattern level the colors are centered on — shifts the balance of background vs. cells",
-			ui: {
-				type: ["range", "map"],
-				min: .05,
-				max: .6,
-				step: .01,
-				label: "Threshold",
-				group: "Colors"
-			}
-		},
-		colorSpace: {
-			default: "oklch",
-			transform: transformColorSpace,
-			compileTime: true,
-			description: "Color space for color interpolation",
-			ui: {
-				type: "select",
-				options: colorSpaceOptions,
-				label: "Color Space",
-				group: "Colors"
-			}
-		},
-		relief: {
-			default: .4,
-			description: "Treats the pattern as a raised surface and shades it with a light — higher gives a more sculpted, three-dimensional look (0 for a flat, graphic look)",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Relief",
-				group: "Lighting"
-			}
-		},
-		lightAngle: {
-			default: 135,
-			description: "Direction the surface light comes from, in degrees",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 360,
-				step: 1,
-				label: "Light Angle",
-				group: "Lighting"
-			}
-		},
-		childInfluence: {
-			default: .6,
-			description: "When a child layer is nested, how strongly its brightness biases the pattern — the preset sets the character, the child steers where it grows dense vs. sparse (0 ignores the child)",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Influence",
-				group: "Child"
-			}
-		},
-		childContrast: {
-			default: .5,
-			description: "Contrast applied to the child's brightness before it drives the pattern — higher pushes toward a crisp two-tone split (edges), lower keeps smooth tonal shading",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Contrast",
-				group: "Child"
-			}
-		},
-		childThreshold: {
-			default: .5,
-			description: "Brightness level of the child that reads as neutral — shifts which tones grow the pattern vs. clear it",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Threshold",
-				group: "Child"
-			}
-		},
-		childInvert: {
-			default: false,
-			transform: transformBoolean,
-			description: "Flip which tones of the child grow the pattern (bright vs. dark areas)",
-			ui: {
-				type: "checkbox",
-				label: "Invert",
-				group: "Child"
-			}
-		}
-	},
-	compute: (params) => {
-		const { gpu, getCpuValue, registerComputeTexture, onCleanup, childNode } = params;
-		const root = gpu?.root;
-		if (!root) return null;
-		const hasChild = !!childNode;
-		const bufferA = createStateBuffer(root, vec2f, COUNT);
-		const bufferB = createStateBuffer(root, vec2f, 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 rdTexture = registerComputeTexture(outTex);
-		const paramsU = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(RDParams), "paramsU");
-		const size = [N, N];
-		const state = createPingPongPair(bufferA, bufferB);
-		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 });
-		const outGroup = state.perSide((srcBuf) => output.with(root.createBindGroup(outputLayout, {
-			srcBuf,
-			outTex
-		})));
-		const seed = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-			"use gpu";
-			seedKernel(cx, cy);
-		}), {
-			v: 2,
-			name: void 0,
-			ast: {
-				"params": [{
-					"type": "i",
-					"name": "cx"
-				}, {
-					"type": "i",
-					"name": "cy"
-				}],
-				"body": [0, [[
-					6,
-					"seedKernel",
-					["cx", "cy"]
-				]]]
-			},
-			externals: { "seedKernel": () => seedKernel }
-		}) && $.f)({}), {
-			size,
-			bindGroup: root.createBindGroup(seedLayout, { stateBuf: bufferA })
-		});
-		const reaction = hasChild ? createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-			"use gpu";
-			reactionKernelChild(cx, cy);
-		}), {
-			v: 2,
-			name: void 0,
-			ast: {
-				"params": [{
-					"type": "i",
-					"name": "cx"
-				}, {
-					"type": "i",
-					"name": "cy"
-				}],
-				"body": [0, [[
-					6,
-					"reactionKernelChild",
-					["cx", "cy"]
-				]]]
-			},
-			externals: { "reactionKernelChild": () => reactionKernelChild }
-		}) && $.f)({}), { size }) : createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-			"use gpu";
-			reactionKernel(cx, cy);
-		}), {
-			v: 2,
-			name: void 0,
-			ast: {
-				"params": [{
-					"type": "i",
-					"name": "cx"
-				}, {
-					"type": "i",
-					"name": "cy"
-				}],
-				"body": [0, [[
-					6,
-					"reactionKernel",
-					["cx", "cy"]
-				]]]
-			},
-			externals: { "reactionKernel": () => reactionKernel }
-		}) && $.f)({}), { size });
-		const generatorGroup = hasChild ? null : state.groups((readBuf, writeBuf) => reaction.with(root.createBindGroup(reactionLayout, {
-			readBuf,
-			writeBuf,
-			params: paramsU.buffer
-		})));
-		const child = hasChild ? createLateBoundChildInput(params, (childTex) => state.groups((readBuf, writeBuf) => reaction.with(root.createBindGroup(reactionChildLayout, {
-			readBuf,
-			writeBuf,
-			params: paramsU.buffer,
-			childTex
-		})))) : null;
-		let needsSeed = true;
-		let lastPreset = "";
-		const pointer = createPointerVelocityTracker();
-		return {
-			outputs: { rdTexture },
-			...child ? { bindInputs: child.bindInputs } : {},
-			getComputeNodes: (frameParams) => {
-				const reactGroup = child ? child.bound() : generatorGroup;
-				if (!reactGroup) return null;
-				const fp = frameParams;
-				const g = (key, fallback) => {
-					const v = getCpuValue(key);
-					return typeof v === "number" ? v : fallback;
-				};
-				const hgt = fp.dimensions?.height ?? 0;
-				const aspect = hgt > 0 ? (fp.dimensions?.width ?? 0) / hgt : 1;
-				const preset = getCpuValue("preset") || "coral";
-				if (preset !== lastPreset) {
-					lastPreset = preset;
-					needsSeed = true;
-				}
-				const pk = PRESETS[preset];
-				const feed = pk ? pk.feed : g("feed", .055);
-				const kill = pk ? pk.kill : g("kill", .062);
-				const view = 1 / Math.max(g("featureSize", 3), 1e-4);
-				const sx = Math.min(aspect, 1);
-				const sy = Math.min(1 / aspect, 1);
-				const move = pointer.update(fp.pointer, .016);
-				const fieldX = (move.x - .5) * sx * view + .5;
-				const fieldY = (move.y - .5) * sy * view + .5;
-				const cursorSpeed = Math.sqrt(move.dx * move.dx + move.dy * move.dy);
-				const velScale = cursorSpeed > 5e-4 && g("brushStrength", .6) > 0 ? Math.min(cursorSpeed / .02, 1) : 0;
-				const brushRadGrid = g("brushSize", .04) * N * view;
-				const invRaw = getCpuValue("childInvert");
-				paramsU.write({
-					feed,
-					kill,
-					dv: g("diffusionRatio", .5),
-					brushRadSq: brushRadGrid * brushRadGrid,
-					brushStrength: g("brushStrength", .6),
-					cursorX: fieldX * N,
-					cursorY: fieldY * N,
-					cursorActive: velScale,
-					childInfluence: g("childInfluence", .6),
-					childContrast: g("childContrast", .5),
-					childThreshold: g("childThreshold", .5),
-					childInvert: invRaw === true || invRaw === 1 ? 1 : 0,
-					childMapX: 1 / (sx * view),
-					childMapY: 1 / (sy * view),
-					_pad0: 0,
-					_pad1: 0
-				});
-				const nodes = [];
-				if (needsSeed) {
-					needsSeed = false;
-					state.reset();
-					nodes.push(seed);
-				}
-				const iters = Math.min(MAX_ITERATIONS, Math.max(1, Math.round(g("speed", 6))));
-				for (let i = 0; i < iters; i++) {
-					nodes.push(reactGroup());
-					state.swap();
-				}
-				nodes.push(outGroup.read());
-				return nodes;
-			}
-		};
-	},
-	fragment: (params) => {
-		const { ctx, computeOutputs, propValues, uniforms } = params;
-		const rdField = computeOutputs?.rdTexture;
-		if (!rdField) return ZERO;
-		const sampleUV = call(rdSampleUV, "rdSampleUV", [
-			ctx.uv,
-			ctx.aspect,
-			uniforms.featureSize
-		]);
-		const t = call(rdRampT, "rdRampT", [
-			rdField.sample(sampleUV, "linearClamp").member("y"),
-			uniforms.contrast,
-			uniforms.threshold
-		]);
-		const colorSpaceMode = propValues.colorSpace ?? 0;
-		const variant = cm.mixColorsVariants[colorSpaceMode] ?? cm.mixColorsLinear;
-		const lit = call(rdShade, "rdShade", [
-			call(rdPickSeg, "rdPickSeg", [
-				call(variant, "mixColors", [
-					uniforms.colorA,
-					uniforms.colorC,
-					call(rdSeg, "rdSeg", [t, floatE(0)])
-				]),
-				call(variant, "mixColors", [
-					uniforms.colorC,
-					uniforms.colorB,
-					call(rdSeg, "rdSeg", [t, floatE(1)])
-				]),
-				t
-			]),
-			rdField.sample(call(rdShiftUV, "rdShiftL", [
-				sampleUV,
-				floatE(-RELIEF_EPS),
-				floatE(0)
-			]), "linearClamp").member("y"),
-			rdField.sample(call(rdShiftUV, "rdShiftR", [
-				sampleUV,
-				floatE(RELIEF_EPS),
-				floatE(0)
-			]), "linearClamp").member("y"),
-			rdField.sample(call(rdShiftUV, "rdShiftT", [
-				sampleUV,
-				floatE(0),
-				floatE(-RELIEF_EPS)
-			]), "linearClamp").member("y"),
-			rdField.sample(call(rdShiftUV, "rdShiftB", [
-				sampleUV,
-				floatE(0),
-				floatE(RELIEF_EPS)
-			]), "linearClamp").member("y"),
-			uniforms.relief,
-			uniforms.lightAngle
-		]);
-		return vec4(lit.member("rgb"), lit.member("a"));
-	}
-};
-var ReactionDiffusion_default = componentDefinition;
-export { rdPickSeg as a, rdSeg as c, reactionKernel as d, reactionKernelChild as f, rdChildDrive as i, rdShade as l, componentDefinition as n, rdRampT as o, seedKernel as p, outputKernel as r, rdSampleUV as s, ReactionDiffusion_default as t, rdShiftUV as u };