shaders 3.1.462 → 3.2.464

package/dist/core/PixelSort-Cb_YKX9c.js

@@ -1,1983 +0,0 @@
-import { Ft as vec3f, Gt as textureStorage2d, Kt as arrayOf, Lt as vec4f, Mt as vec2f, Ot as smoothstep, P as unpremultiplyAlpha, Pt as vec2u, Tt as round, Wt as texture2d, cn as i32, ct as clamp, d as ZERO, dt as dot, et as typegpu_default, kt as sqrt, ln as u32, m as call, mt as floor, qt as struct, rt as select, sn as f32, vt as min, yt as mix } from "./edges-CV-BHMpI.js";
-import { I as textureLoad, M as createGuardedCompute, P as createStateBuffer, R as textureStore } from "./device-DKcu50_C.js";
-import { c as hash13 } from "./noise-eXd1Bfrw.js";
-var WORK = 512;
-var CELL_COUNT = WORK * WORK;
-var WORK_F = WORK;
-var MAX_COL = WORK - 1;
-var STATE_FORMAT = "rgba16float";
-const brushWeight = typegpu_default.fn([
-	f32,
-	f32,
-	f32,
-	f32,
-	f32,
-	f32,
-	f32
-], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cxf, cyf, mouseX, mouseY, radius, falloff, aspect) => {
-	"use gpu";
-	const dx = __tsover_sub(__tsover_div(cxf, WORK_F), mouseX);
-	const dy = __tsover_sub(__tsover_div(cyf, WORK_F), mouseY);
-	const ddx = select(dx, __tsover_mul(dx, aspect), aspect >= 1);
-	const ddy = select(__tsover_div(dy, aspect), dy, aspect >= 1);
-	const dist = sqrt(__tsover_add(__tsover_mul(ddx, ddx), __tsover_mul(ddy, ddy)));
-	const inner = __tsover_mul(radius, __tsover_sub(1, falloff));
-	return __tsover_sub(1, smoothstep(inner, radius, dist));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "cxf"
-			},
-			{
-				"type": "i",
-				"name": "cyf"
-			},
-			{
-				"type": "i",
-				"name": "mouseX"
-			},
-			{
-				"type": "i",
-				"name": "mouseY"
-			},
-			{
-				"type": "i",
-				"name": "radius"
-			},
-			{
-				"type": "i",
-				"name": "falloff"
-			},
-			{
-				"type": "i",
-				"name": "aspect"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"dx",
-				[
-					1,
-					[
-						1,
-						"cxf",
-						"/",
-						"WORK_F"
-					],
-					"-",
-					"mouseX"
-				]
-			],
-			[
-				13,
-				"dy",
-				[
-					1,
-					[
-						1,
-						"cyf",
-						"/",
-						"WORK_F"
-					],
-					"-",
-					"mouseY"
-				]
-			],
-			[
-				13,
-				"ddx",
-				[
-					6,
-					"std.select",
-					[
-						"dx",
-						[
-							1,
-							"dx",
-							"*",
-							"aspect"
-						],
-						[
-							1,
-							"aspect",
-							">=",
-							[5, "1"]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"ddy",
-				[
-					6,
-					"std.select",
-					[
-						[
-							1,
-							"dy",
-							"/",
-							"aspect"
-						],
-						"dy",
-						[
-							1,
-							"aspect",
-							">=",
-							[5, "1"]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"dist",
-				[
-					6,
-					"std.sqrt",
-					[[
-						1,
-						[
-							1,
-							"ddx",
-							"*",
-							"ddx"
-						],
-						"+",
-						[
-							1,
-							"ddy",
-							"*",
-							"ddy"
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"inner",
-				[
-					1,
-					"radius",
-					"*",
-					[
-						1,
-						[5, "1"],
-						"-",
-						"falloff"
-					]
-				]
-			],
-			[10, [
-				1,
-				[5, "1"],
-				"-",
-				[
-					6,
-					"std.smoothstep",
-					[
-						"inner",
-						"radius",
-						"dist"
-					]
-				]
-			]]
-		]]
-	},
-	externals: {
-		"WORK_F": () => WORK_F,
-		"std.select": () => select,
-		"std.sqrt": () => sqrt,
-		"std.smoothstep": () => smoothstep
-	}
-}) && $.f)({}));
-const cellRand = typegpu_default.fn([
-	f32,
-	f32,
-	f32
-], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((xf, yf, seed) => {
-	"use gpu";
-	return hash13(vec3f(xf, yf, seed));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "xf"
-			},
-			{
-				"type": "i",
-				"name": "yf"
-			},
-			{
-				"type": "i",
-				"name": "seed"
-			}
-		],
-		"body": [0, [[10, [
-			6,
-			"noise.hash13",
-			[[
-				6,
-				"d.vec3f",
-				[
-					"xf",
-					"yf",
-					"seed"
-				]
-			]]
-		]]]]
-	},
-	externals: {
-		"noise.hash13": () => hash13,
-		"d.vec3f": () => vec3f
-	}
-}) && $.f)({}));
-var lumaLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.bindGroupLayout({
-	input: { texture: texture2d(f32) },
-	lumaBuf: {
-		storage: arrayOf(f32, CELL_COUNT),
-		access: "mutable"
-	},
-	params: { uniform: /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
-		inputWidth: f32,
-		inputHeight: f32
-	}), "uniform") }
-}), "lumaLayout");
-var swapLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.bindGroupLayout({
-	readBuf: {
-		storage: arrayOf(f32, CELL_COUNT),
-		access: "readonly"
-	},
-	writeBuf: {
-		storage: arrayOf(f32, CELL_COUNT),
-		access: "mutable"
-	},
-	lumaBuf: {
-		storage: arrayOf(f32, CELL_COUNT),
-		access: "readonly"
-	},
-	params: { uniform: /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
-		mouseX: f32,
-		mouseY: f32,
-		radius: f32,
-		falloff: f32,
-		decay: f32,
-		aspect: f32,
-		seed: f32
-	}), "uniform") }
-}), "swapLayout");
-var outputLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.bindGroupLayout({
-	srcBuf: {
-		storage: arrayOf(f32, CELL_COUNT),
-		access: "readonly"
-	},
-	stateTex: { storageTexture: textureStorage2d(STATE_FORMAT, "write-only") }
-}), "outputLayout");
-const lumaKernel = typegpu_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-	"use gpu";
-	const p = lumaLayout.$.params;
-	const idx = __tsover_add(__tsover_mul(cy, u32(WORK)), cx);
-	const u = __tsover_div(__tsover_add(f32(cx), .5), WORK_F);
-	const v = __tsover_div(__tsover_add(f32(cy), .5), WORK_F);
-	const ix = clamp(i32(round(__tsover_mul(u, p.inputWidth))), 0, i32(__tsover_sub(p.inputWidth, 1)));
-	const iy = clamp(i32(round(__tsover_mul(v, p.inputHeight))), 0, i32(__tsover_sub(p.inputHeight, 1)));
-	const rgb = unpremultiplyAlpha(textureLoad(lumaLayout.$.input, vec2u(u32(ix), u32(iy)), 0)).xyz;
-	lumaLayout.$.lumaBuf[idx] = dot(rgb, vec3f(.299, .587, .114));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "cx"
-		}, {
-			"type": "i",
-			"name": "cy"
-		}],
-		"body": [0, [
-			[
-				13,
-				"p",
-				[
-					7,
-					[
-						7,
-						"lumaLayout",
-						"$"
-					],
-					"params"
-				]
-			],
-			[
-				13,
-				"idx",
-				[
-					1,
-					[
-						1,
-						"cy",
-						"*",
-						[
-							6,
-							"d.u32",
-							["WORK"]
-						]
-					],
-					"+",
-					"cx"
-				]
-			],
-			[
-				13,
-				"u",
-				[
-					1,
-					[
-						1,
-						[
-							6,
-							"d.f32",
-							["cx"]
-						],
-						"+",
-						[5, "0.5"]
-					],
-					"/",
-					"WORK_F"
-				]
-			],
-			[
-				13,
-				"v",
-				[
-					1,
-					[
-						1,
-						[
-							6,
-							"d.f32",
-							["cy"]
-						],
-						"+",
-						[5, "0.5"]
-					],
-					"/",
-					"WORK_F"
-				]
-			],
-			[
-				13,
-				"ix",
-				[
-					6,
-					"std.clamp",
-					[
-						[
-							6,
-							"d.i32",
-							[[
-								6,
-								"std.round",
-								[[
-									1,
-									"u",
-									"*",
-									[
-										7,
-										"p",
-										"inputWidth"
-									]
-								]]
-							]]
-						],
-						[5, "0"],
-						[
-							6,
-							"d.i32",
-							[[
-								1,
-								[
-									7,
-									"p",
-									"inputWidth"
-								],
-								"-",
-								[5, "1"]
-							]]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"iy",
-				[
-					6,
-					"std.clamp",
-					[
-						[
-							6,
-							"d.i32",
-							[[
-								6,
-								"std.round",
-								[[
-									1,
-									"v",
-									"*",
-									[
-										7,
-										"p",
-										"inputHeight"
-									]
-								]]
-							]]
-						],
-						[5, "0"],
-						[
-							6,
-							"d.i32",
-							[[
-								1,
-								[
-									7,
-									"p",
-									"inputHeight"
-								],
-								"-",
-								[5, "1"]
-							]]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"texel",
-				[
-					6,
-					"std.textureLoad",
-					[
-						[
-							7,
-							[
-								7,
-								"lumaLayout",
-								"$"
-							],
-							"input"
-						],
-						[
-							6,
-							"d.vec2u",
-							[[
-								6,
-								"d.u32",
-								["ix"]
-							], [
-								6,
-								"d.u32",
-								["iy"]
-							]]
-						],
-						[5, "0"]
-					]
-				]
-			],
-			[
-				13,
-				"rgb",
-				[
-					7,
-					[
-						6,
-						"blend.unpremultiplyAlpha",
-						["texel"]
-					],
-					"xyz"
-				]
-			],
-			[
-				2,
-				[
-					8,
-					[
-						7,
-						[
-							7,
-							"lumaLayout",
-							"$"
-						],
-						"lumaBuf"
-					],
-					"idx"
-				],
-				"=",
-				[
-					6,
-					"std.dot",
-					["rgb", [
-						6,
-						"d.vec3f",
-						[
-							[5, "0.299"],
-							[5, "0.587"],
-							[5, "0.114"]
-						]
-					]]
-				]
-			]
-		]]
-	},
-	externals: {
-		"lumaLayout": () => lumaLayout,
-		"d.u32": () => u32,
-		"WORK": () => WORK,
-		"d.f32": () => f32,
-		"WORK_F": () => WORK_F,
-		"std.clamp": () => clamp,
-		"d.i32": () => i32,
-		"std.round": () => round,
-		"std.textureLoad": () => textureLoad,
-		"d.vec2u": () => vec2u,
-		"blend.unpremultiplyAlpha": () => unpremultiplyAlpha,
-		"std.dot": () => dot,
-		"d.vec3f": () => vec3f
-	}
-}) && $.f)({})).$name("pixelSortLuma");
-function makeSwapKernel(vertical, dir, parity) {
-	return typegpu_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-		"use gpu";
-		const p = swapLayout.$.params;
-		const idx = __tsover_add(__tsover_mul(cy, u32(WORK)), cx);
-		const xf = f32(cx);
-		const yf = f32(cy);
-		const lineC = vertical ? cy : cx;
-		const fixedC = vertical ? cx : cy;
-		const lineCf = f32(lineC);
-		const lineCi = i32(lineC);
-		const myOff = swapLayout.$.readBuf[idx];
-		const myCol = clamp(__tsover_add(lineCf, myOff), 0, MAX_COL);
-		const isLeft = __tsover_mod(__tsover_add(lineC, u32(parity)), u32(2)) === u32(0);
-		const partnerLineI = select(__tsover_sub(lineCi, 1), __tsover_add(lineCi, 1), isLeft);
-		const valid = partnerLineI >= 0 && partnerLineI < WORK;
-		const pClamped = clamp(partnerLineI, 0, __tsover_sub(WORK, 1));
-		const pClampedU = u32(pClamped);
-		const partnerX = vertical ? fixedC : pClampedU;
-		const partnerY = vertical ? pClampedU : fixedC;
-		const partnerIdx = __tsover_add(__tsover_mul(partnerY, u32(WORK)), partnerX);
-		const partnerOff = swapLayout.$.readBuf[partnerIdx];
-		const partnerCol = clamp(__tsover_add(f32(pClamped), partnerOff), 0, MAX_COL);
-		const myC0 = clamp(floor(myCol), 0, MAX_COL);
-		const myC1 = min(__tsover_add(myC0, 1), MAX_COL);
-		const myIdx0 = vertical ? __tsover_add(__tsover_mul(u32(myC0), u32(WORK)), fixedC) : __tsover_add(__tsover_mul(fixedC, u32(WORK)), u32(myC0));
-		const myIdx1 = vertical ? __tsover_add(__tsover_mul(u32(myC1), u32(WORK)), fixedC) : __tsover_add(__tsover_mul(fixedC, u32(WORK)), u32(myC1));
-		const myKey = mix(swapLayout.$.lumaBuf[myIdx0], swapLayout.$.lumaBuf[myIdx1], __tsover_sub(myCol, myC0));
-		const pC0 = clamp(floor(partnerCol), 0, MAX_COL);
-		const pC1 = min(__tsover_add(pC0, 1), MAX_COL);
-		const pIdx0 = vertical ? __tsover_add(__tsover_mul(u32(pC0), u32(WORK)), fixedC) : __tsover_add(__tsover_mul(fixedC, u32(WORK)), u32(pC0));
-		const pIdx1 = vertical ? __tsover_add(__tsover_mul(u32(pC1), u32(WORK)), fixedC) : __tsover_add(__tsover_mul(fixedC, u32(WORK)), u32(pC1));
-		const partnerKey = mix(swapLayout.$.lumaBuf[pIdx0], swapLayout.$.lumaBuf[pIdx1], __tsover_sub(partnerCol, pC0));
-		const wMy = brushWeight(xf, yf, p.mouseX, p.mouseY, p.radius, p.falloff, p.aspect);
-		const wP = brushWeight(f32(partnerX), f32(partnerY), p.mouseX, p.mouseY, p.radius, p.falloff, p.aspect);
-		const rnd = cellRand(xf, yf, p.seed);
-		const gate = valid && min(wMy, wP) > rnd;
-		const keyDiff = __tsover_mul(__tsover_sub(myKey, partnerKey), dir);
-		const takePartner = select(keyDiff < 0, keyDiff > 0, isLeft);
-		const decayed = mix(select(myCol, partnerCol, gate && takePartner), lineCf, p.decay);
-		swapLayout.$.writeBuf[idx] = __tsover_sub(decayed, lineCf);
-	}), {
-		v: 2,
-		name: void 0,
-		ast: {
-			"params": [{
-				"type": "i",
-				"name": "cx"
-			}, {
-				"type": "i",
-				"name": "cy"
-			}],
-			"body": [0, [
-				[
-					13,
-					"p",
-					[
-						7,
-						[
-							7,
-							"swapLayout",
-							"$"
-						],
-						"params"
-					]
-				],
-				[
-					13,
-					"idx",
-					[
-						1,
-						[
-							1,
-							"cy",
-							"*",
-							[
-								6,
-								"d.u32",
-								["WORK"]
-							]
-						],
-						"+",
-						"cx"
-					]
-				],
-				[
-					13,
-					"xf",
-					[
-						6,
-						"d.f32",
-						["cx"]
-					]
-				],
-				[
-					13,
-					"yf",
-					[
-						6,
-						"d.f32",
-						["cy"]
-					]
-				],
-				[
-					13,
-					"lineC",
-					[
-						105,
-						"vertical",
-						"cy",
-						"cx"
-					]
-				],
-				[
-					13,
-					"fixedC",
-					[
-						105,
-						"vertical",
-						"cx",
-						"cy"
-					]
-				],
-				[
-					13,
-					"lineCf",
-					[
-						6,
-						"d.f32",
-						["lineC"]
-					]
-				],
-				[
-					13,
-					"lineCi",
-					[
-						6,
-						"d.i32",
-						["lineC"]
-					]
-				],
-				[
-					13,
-					"myOff",
-					[
-						8,
-						[
-							7,
-							[
-								7,
-								"swapLayout",
-								"$"
-							],
-							"readBuf"
-						],
-						"idx"
-					]
-				],
-				[
-					13,
-					"myCol",
-					[
-						6,
-						"std.clamp",
-						[
-							[
-								1,
-								"lineCf",
-								"+",
-								"myOff"
-							],
-							[5, "0"],
-							"MAX_COL"
-						]
-					]
-				],
-				[
-					13,
-					"isLeft",
-					[
-						1,
-						[
-							1,
-							[
-								1,
-								"lineC",
-								"+",
-								[
-									6,
-									"d.u32",
-									["parity"]
-								]
-							],
-							"%",
-							[
-								6,
-								"d.u32",
-								[[5, "2"]]
-							]
-						],
-						"===",
-						[
-							6,
-							"d.u32",
-							[[5, "0"]]
-						]
-					]
-				],
-				[
-					13,
-					"partnerLineI",
-					[
-						6,
-						"std.select",
-						[
-							[
-								1,
-								"lineCi",
-								"-",
-								[5, "1"]
-							],
-							[
-								1,
-								"lineCi",
-								"+",
-								[5, "1"]
-							],
-							"isLeft"
-						]
-					]
-				],
-				[
-					13,
-					"valid",
-					[
-						3,
-						[
-							1,
-							"partnerLineI",
-							">=",
-							[5, "0"]
-						],
-						"&&",
-						[
-							1,
-							"partnerLineI",
-							"<",
-							"WORK"
-						]
-					]
-				],
-				[
-					13,
-					"pClamped",
-					[
-						6,
-						"std.clamp",
-						[
-							"partnerLineI",
-							[5, "0"],
-							[
-								1,
-								"WORK",
-								"-",
-								[5, "1"]
-							]
-						]
-					]
-				],
-				[
-					13,
-					"pClampedU",
-					[
-						6,
-						"d.u32",
-						["pClamped"]
-					]
-				],
-				[
-					13,
-					"partnerX",
-					[
-						105,
-						"vertical",
-						"fixedC",
-						"pClampedU"
-					]
-				],
-				[
-					13,
-					"partnerY",
-					[
-						105,
-						"vertical",
-						"pClampedU",
-						"fixedC"
-					]
-				],
-				[
-					13,
-					"partnerIdx",
-					[
-						1,
-						[
-							1,
-							"partnerY",
-							"*",
-							[
-								6,
-								"d.u32",
-								["WORK"]
-							]
-						],
-						"+",
-						"partnerX"
-					]
-				],
-				[
-					13,
-					"partnerOff",
-					[
-						8,
-						[
-							7,
-							[
-								7,
-								"swapLayout",
-								"$"
-							],
-							"readBuf"
-						],
-						"partnerIdx"
-					]
-				],
-				[
-					13,
-					"partnerCol",
-					[
-						6,
-						"std.clamp",
-						[
-							[
-								1,
-								[
-									6,
-									"d.f32",
-									["pClamped"]
-								],
-								"+",
-								"partnerOff"
-							],
-							[5, "0"],
-							"MAX_COL"
-						]
-					]
-				],
-				[
-					13,
-					"myC0",
-					[
-						6,
-						"std.clamp",
-						[
-							[
-								6,
-								"std.floor",
-								["myCol"]
-							],
-							[5, "0"],
-							"MAX_COL"
-						]
-					]
-				],
-				[
-					13,
-					"myC1",
-					[
-						6,
-						"std.min",
-						[[
-							1,
-							"myC0",
-							"+",
-							[5, "1"]
-						], "MAX_COL"]
-					]
-				],
-				[
-					13,
-					"myIdx0",
-					[
-						105,
-						"vertical",
-						[
-							1,
-							[
-								1,
-								[
-									6,
-									"d.u32",
-									["myC0"]
-								],
-								"*",
-								[
-									6,
-									"d.u32",
-									["WORK"]
-								]
-							],
-							"+",
-							"fixedC"
-						],
-						[
-							1,
-							[
-								1,
-								"fixedC",
-								"*",
-								[
-									6,
-									"d.u32",
-									["WORK"]
-								]
-							],
-							"+",
-							[
-								6,
-								"d.u32",
-								["myC0"]
-							]
-						]
-					]
-				],
-				[
-					13,
-					"myIdx1",
-					[
-						105,
-						"vertical",
-						[
-							1,
-							[
-								1,
-								[
-									6,
-									"d.u32",
-									["myC1"]
-								],
-								"*",
-								[
-									6,
-									"d.u32",
-									["WORK"]
-								]
-							],
-							"+",
-							"fixedC"
-						],
-						[
-							1,
-							[
-								1,
-								"fixedC",
-								"*",
-								[
-									6,
-									"d.u32",
-									["WORK"]
-								]
-							],
-							"+",
-							[
-								6,
-								"d.u32",
-								["myC1"]
-							]
-						]
-					]
-				],
-				[
-					13,
-					"myKey",
-					[
-						6,
-						"std.mix",
-						[
-							[
-								8,
-								[
-									7,
-									[
-										7,
-										"swapLayout",
-										"$"
-									],
-									"lumaBuf"
-								],
-								"myIdx0"
-							],
-							[
-								8,
-								[
-									7,
-									[
-										7,
-										"swapLayout",
-										"$"
-									],
-									"lumaBuf"
-								],
-								"myIdx1"
-							],
-							[
-								1,
-								"myCol",
-								"-",
-								"myC0"
-							]
-						]
-					]
-				],
-				[
-					13,
-					"pC0",
-					[
-						6,
-						"std.clamp",
-						[
-							[
-								6,
-								"std.floor",
-								["partnerCol"]
-							],
-							[5, "0"],
-							"MAX_COL"
-						]
-					]
-				],
-				[
-					13,
-					"pC1",
-					[
-						6,
-						"std.min",
-						[[
-							1,
-							"pC0",
-							"+",
-							[5, "1"]
-						], "MAX_COL"]
-					]
-				],
-				[
-					13,
-					"pIdx0",
-					[
-						105,
-						"vertical",
-						[
-							1,
-							[
-								1,
-								[
-									6,
-									"d.u32",
-									["pC0"]
-								],
-								"*",
-								[
-									6,
-									"d.u32",
-									["WORK"]
-								]
-							],
-							"+",
-							"fixedC"
-						],
-						[
-							1,
-							[
-								1,
-								"fixedC",
-								"*",
-								[
-									6,
-									"d.u32",
-									["WORK"]
-								]
-							],
-							"+",
-							[
-								6,
-								"d.u32",
-								["pC0"]
-							]
-						]
-					]
-				],
-				[
-					13,
-					"pIdx1",
-					[
-						105,
-						"vertical",
-						[
-							1,
-							[
-								1,
-								[
-									6,
-									"d.u32",
-									["pC1"]
-								],
-								"*",
-								[
-									6,
-									"d.u32",
-									["WORK"]
-								]
-							],
-							"+",
-							"fixedC"
-						],
-						[
-							1,
-							[
-								1,
-								"fixedC",
-								"*",
-								[
-									6,
-									"d.u32",
-									["WORK"]
-								]
-							],
-							"+",
-							[
-								6,
-								"d.u32",
-								["pC1"]
-							]
-						]
-					]
-				],
-				[
-					13,
-					"partnerKey",
-					[
-						6,
-						"std.mix",
-						[
-							[
-								8,
-								[
-									7,
-									[
-										7,
-										"swapLayout",
-										"$"
-									],
-									"lumaBuf"
-								],
-								"pIdx0"
-							],
-							[
-								8,
-								[
-									7,
-									[
-										7,
-										"swapLayout",
-										"$"
-									],
-									"lumaBuf"
-								],
-								"pIdx1"
-							],
-							[
-								1,
-								"partnerCol",
-								"-",
-								"pC0"
-							]
-						]
-					]
-				],
-				[
-					13,
-					"wMy",
-					[
-						6,
-						"brushWeight",
-						[
-							"xf",
-							"yf",
-							[
-								7,
-								"p",
-								"mouseX"
-							],
-							[
-								7,
-								"p",
-								"mouseY"
-							],
-							[
-								7,
-								"p",
-								"radius"
-							],
-							[
-								7,
-								"p",
-								"falloff"
-							],
-							[
-								7,
-								"p",
-								"aspect"
-							]
-						]
-					]
-				],
-				[
-					13,
-					"wP",
-					[
-						6,
-						"brushWeight",
-						[
-							[
-								6,
-								"d.f32",
-								["partnerX"]
-							],
-							[
-								6,
-								"d.f32",
-								["partnerY"]
-							],
-							[
-								7,
-								"p",
-								"mouseX"
-							],
-							[
-								7,
-								"p",
-								"mouseY"
-							],
-							[
-								7,
-								"p",
-								"radius"
-							],
-							[
-								7,
-								"p",
-								"falloff"
-							],
-							[
-								7,
-								"p",
-								"aspect"
-							]
-						]
-					]
-				],
-				[
-					13,
-					"rnd",
-					[
-						6,
-						"cellRand",
-						[
-							"xf",
-							"yf",
-							[
-								7,
-								"p",
-								"seed"
-							]
-						]
-					]
-				],
-				[
-					13,
-					"gate",
-					[
-						3,
-						"valid",
-						"&&",
-						[
-							1,
-							[
-								6,
-								"std.min",
-								["wMy", "wP"]
-							],
-							">",
-							"rnd"
-						]
-					]
-				],
-				[
-					13,
-					"keyDiff",
-					[
-						1,
-						[
-							1,
-							"myKey",
-							"-",
-							"partnerKey"
-						],
-						"*",
-						"dir"
-					]
-				],
-				[
-					13,
-					"takePartner",
-					[
-						6,
-						"std.select",
-						[
-							[
-								1,
-								"keyDiff",
-								"<",
-								[5, "0"]
-							],
-							[
-								1,
-								"keyDiff",
-								">",
-								[5, "0"]
-							],
-							"isLeft"
-						]
-					]
-				],
-				[
-					13,
-					"newCol",
-					[
-						6,
-						"std.select",
-						[
-							"myCol",
-							"partnerCol",
-							[
-								3,
-								"gate",
-								"&&",
-								"takePartner"
-							]
-						]
-					]
-				],
-				[
-					13,
-					"decayed",
-					[
-						6,
-						"std.mix",
-						[
-							"newCol",
-							"lineCf",
-							[
-								7,
-								"p",
-								"decay"
-							]
-						]
-					]
-				],
-				[
-					2,
-					[
-						8,
-						[
-							7,
-							[
-								7,
-								"swapLayout",
-								"$"
-							],
-							"writeBuf"
-						],
-						"idx"
-					],
-					"=",
-					[
-						1,
-						"decayed",
-						"-",
-						"lineCf"
-					]
-				]
-			]]
-		},
-		externals: {
-			"swapLayout": () => swapLayout,
-			"d.u32": () => u32,
-			"WORK": () => WORK,
-			"d.f32": () => f32,
-			"vertical": () => vertical,
-			"d.i32": () => i32,
-			"std.clamp": () => clamp,
-			"MAX_COL": () => MAX_COL,
-			"parity": () => parity,
-			"std.select": () => select,
-			"std.floor": () => floor,
-			"std.min": () => min,
-			"std.mix": () => mix,
-			"brushWeight": () => brushWeight,
-			"cellRand": () => cellRand,
-			"dir": () => dir
-		}
-	}) && $.f)({})).$name("pixelSortSwap");
-}
-function makeOutputKernel(vertical) {
-	return 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(WORK)), cx);
-		const lineC = vertical ? cy : cx;
-		const col = clamp(__tsover_add(f32(lineC), outputLayout.$.srcBuf[idx]), 0, MAX_COL);
-		const u = __tsover_div(__tsover_add(col, .5), WORK_F);
-		textureStore(outputLayout.$.stateTex, vec2u(cx, cy), vec4f(u, 0, 0, 1));
-	}), {
-		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",
-								["WORK"]
-							]
-						],
-						"+",
-						"cx"
-					]
-				],
-				[
-					13,
-					"lineC",
-					[
-						105,
-						"vertical",
-						"cy",
-						"cx"
-					]
-				],
-				[
-					13,
-					"col",
-					[
-						6,
-						"std.clamp",
-						[
-							[
-								1,
-								[
-									6,
-									"d.f32",
-									["lineC"]
-								],
-								"+",
-								[
-									8,
-									[
-										7,
-										[
-											7,
-											"outputLayout",
-											"$"
-										],
-										"srcBuf"
-									],
-									"idx"
-								]
-							],
-							[5, "0"],
-							"MAX_COL"
-						]
-					]
-				],
-				[
-					13,
-					"u",
-					[
-						1,
-						[
-							1,
-							"col",
-							"+",
-							[5, "0.5"]
-						],
-						"/",
-						"WORK_F"
-					]
-				],
-				[
-					6,
-					"std.textureStore",
-					[
-						[
-							7,
-							[
-								7,
-								"outputLayout",
-								"$"
-							],
-							"stateTex"
-						],
-						[
-							6,
-							"d.vec2u",
-							["cx", "cy"]
-						],
-						[
-							6,
-							"d.vec4f",
-							[
-								"u",
-								[5, "0"],
-								[5, "0"],
-								[5, "1"]
-							]
-						]
-					]
-				]
-			]]
-		},
-		externals: {
-			"d.u32": () => u32,
-			"WORK": () => WORK,
-			"vertical": () => vertical,
-			"std.clamp": () => clamp,
-			"d.f32": () => f32,
-			"outputLayout": () => outputLayout,
-			"MAX_COL": () => MAX_COL,
-			"WORK_F": () => WORK_F,
-			"std.textureStore": () => textureStore,
-			"d.vec2u": () => vec2u,
-			"d.vec4f": () => vec4f
-		}
-	}) && $.f)({})).$name("pixelSortOutput");
-}
-const pixelSortUVVertical = typegpu_default.fn([vec2f, f32], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, srcCoord) => {
-	"use gpu";
-	return vec2f(uv.x, srcCoord);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "uv"
-		}, {
-			"type": "i",
-			"name": "srcCoord"
-		}],
-		"body": [0, [[10, [
-			6,
-			"d.vec2f",
-			[[
-				7,
-				"uv",
-				"x"
-			], "srcCoord"]
-		]]]]
-	},
-	externals: { "d.vec2f": () => vec2f }
-}) && $.f)({}));
-const pixelSortUVHorizontal = typegpu_default.fn([vec2f, f32], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, srcCoord) => {
-	"use gpu";
-	return vec2f(srcCoord, uv.y);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "uv"
-		}, {
-			"type": "i",
-			"name": "srcCoord"
-		}],
-		"body": [0, [[10, [
-			6,
-			"d.vec2f",
-			["srcCoord", [
-				7,
-				"uv",
-				"y"
-			]]
-		]]]]
-	},
-	externals: { "d.vec2f": () => vec2f }
-}) && $.f)({}));
-const componentDefinition = {
-	name: "PixelSort",
-	category: "Interactive",
-	description: "Pixels sort by brightness around the cursor and keep their sorted position, optionally decaying back over time",
-	requiresRTT: true,
-	requiresChild: true,
-	boundingBoxDeclaration: { aspectRatio: null },
-	usesPointer: true,
-	props: {
-		radius: {
-			default: .4,
-			description: "Size of the cursor brush that sorts pixels",
-			ui: {
-				type: ["range", "map"],
-				min: .03,
-				max: .6,
-				step: .01,
-				label: "Radius",
-				group: "Effect"
-			}
-		},
-		falloff: {
-			default: 1,
-			description: "Softness of the brush edge (0 = hard circle, 1 = very soft)",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Falloff",
-				group: "Effect"
-			}
-		},
-		strength: {
-			default: .1,
-			description: "How fast pixels sort — runs more sorting passes per frame",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Strength",
-				group: "Effect"
-			}
-		},
-		decay: {
-			default: .1,
-			description: "How quickly sorted pixels melt back to their original position (0 = permanent)",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Decay",
-				group: "Effect"
-			}
-		},
-		axis: {
-			default: "vertical",
-			compileTime: true,
-			description: "Axis pixels are sorted along",
-			ui: {
-				type: "select",
-				options: [{
-					label: "Horizontal",
-					value: "horizontal"
-				}, {
-					label: "Vertical",
-					value: "vertical"
-				}],
-				label: "Axis",
-				group: "Effect"
-			}
-		},
-		direction: {
-			default: "descending",
-			compileTime: true,
-			description: "Sort order by brightness",
-			ui: {
-				type: "select",
-				options: [{
-					label: "Dark → Light",
-					value: "ascending"
-				}, {
-					label: "Light → Dark",
-					value: "descending"
-				}],
-				label: "Direction",
-				group: "Effect"
-			}
-		}
-	},
-	compute: (params) => {
-		const { childNode, gpu, convertToTexture, registerComputeTexture, getCpuValue, propValues, onCleanup, onResize, dimensions } = params;
-		if (!childNode) return null;
-		const root = gpu?.root;
-		if (!root) return null;
-		const vertical = propValues.axis === "vertical";
-		const dir = propValues.direction === "descending" ? -1 : 1;
-		const childTexture = convertToTexture(childNode);
-		const bufferA = createStateBuffer(root, f32, CELL_COUNT);
-		const bufferB = createStateBuffer(root, f32, CELL_COUNT);
-		const lumaBuf = createStateBuffer(root, f32, CELL_COUNT);
-		const stateTex = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
-			size: [WORK, WORK],
-			format: STATE_FORMAT
-		}).$usage("storage", "sampled"), "stateTex");
-		onCleanup(() => stateTex.destroy());
-		const state = registerComputeTexture(stateTex);
-		const lumaParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(struct({
-			inputWidth: f32,
-			inputHeight: f32
-		})), "lumaParams");
-		const swapParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(struct({
-			mouseX: f32,
-			mouseY: f32,
-			radius: f32,
-			falloff: f32,
-			decay: f32,
-			aspect: f32,
-			seed: f32
-		})), "swapParams");
-		let curW = Math.max(1, Math.round(dimensions.width));
-		let curH = Math.max(1, Math.round(dimensions.height));
-		onResize(({ width, height }) => {
-			curW = Math.max(1, Math.round(width));
-			curH = Math.max(1, Math.round(height));
-		});
-		const swapKernel0 = makeSwapKernel(vertical, dir, 0);
-		const swapKernel1 = makeSwapKernel(vertical, dir, 1);
-		const outputKernel = makeOutputKernel(vertical);
-		const size = [WORK, WORK];
-		let lumaPipeline = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-			"use gpu";
-			lumaKernel(cx, cy);
-		}), {
-			v: 2,
-			name: void 0,
-			ast: {
-				"params": [{
-					"type": "i",
-					"name": "cx"
-				}, {
-					"type": "i",
-					"name": "cy"
-				}],
-				"body": [0, [[
-					6,
-					"lumaKernel",
-					["cx", "cy"]
-				]]]
-			},
-			externals: { "lumaKernel": () => lumaKernel }
-		}) && $.f)({}), { size });
-		let lumaReady = false;
-		const swapBgAB = root.createBindGroup(swapLayout, {
-			readBuf: bufferA,
-			writeBuf: bufferB,
-			lumaBuf,
-			params: swapParams.buffer
-		});
-		const swapBgBA = root.createBindGroup(swapLayout, {
-			readBuf: bufferB,
-			writeBuf: bufferA,
-			lumaBuf,
-			params: swapParams.buffer
-		});
-		const swap0 = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-			"use gpu";
-			swapKernel0(cx, cy);
-		}), {
-			v: 2,
-			name: void 0,
-			ast: {
-				"params": [{
-					"type": "i",
-					"name": "cx"
-				}, {
-					"type": "i",
-					"name": "cy"
-				}],
-				"body": [0, [[
-					6,
-					"swapKernel0",
-					["cx", "cy"]
-				]]]
-			},
-			externals: { "swapKernel0": () => swapKernel0 }
-		}) && $.f)({}), { size });
-		const swap1 = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-			"use gpu";
-			swapKernel1(cx, cy);
-		}), {
-			v: 2,
-			name: void 0,
-			ast: {
-				"params": [{
-					"type": "i",
-					"name": "cx"
-				}, {
-					"type": "i",
-					"name": "cy"
-				}],
-				"body": [0, [[
-					6,
-					"swapKernel1",
-					["cx", "cy"]
-				]]]
-			},
-			externals: { "swapKernel1": () => swapKernel1 }
-		}) && $.f)({}), { size });
-		const outputBgA = root.createBindGroup(outputLayout, {
-			srcBuf: bufferA,
-			stateTex
-		});
-		const outputBgB = root.createBindGroup(outputLayout, {
-			srcBuf: bufferB,
-			stateTex
-		});
-		const outputPass = 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 });
-		let cur = "A";
-		let tick = 0;
-		let frame = 0;
-		return {
-			outputs: {
-				state,
-				childTexture
-			},
-			bindInputs: (resolve) => {
-				const src = resolve(childTexture.key);
-				if (src) {
-					const lumaBg = root.createBindGroup(lumaLayout, {
-						input: src.texture,
-						lumaBuf,
-						params: lumaParams.buffer
-					});
-					lumaPipeline = lumaPipeline.with(lumaBg);
-					lumaReady = true;
-				}
-			},
-			getComputeNodes: (frameParams) => {
-				if (!lumaReady) return null;
-				const fp = frameParams;
-				const dt = Math.min(fp.deltaTime ?? 0, .05);
-				const safeW = Math.max(1, fp.dimensions?.width ?? curW);
-				const safeH = Math.max(1, fp.dimensions?.height ?? curH);
-				const strength = getCpuValue("strength") ?? .1;
-				const decayProp = getCpuValue("decay") ?? .1;
-				const passes = 1 + Math.round(strength * 4);
-				swapParams.write({
-					mouseX: fp.pointer?.x ?? .5,
-					mouseY: fp.pointer?.y ?? .5,
-					radius: getCpuValue("radius") ?? .4,
-					falloff: getCpuValue("falloff") ?? 1,
-					decay: decayProp * dt * 2 / passes,
-					aspect: safeW / safeH,
-					seed: frame % 1024
-				});
-				lumaParams.write({
-					inputWidth: curW,
-					inputHeight: curH
-				});
-				const nodes = [lumaPipeline];
-				for (let pIdx = 0; pIdx < passes; pIdx++) {
-					const pipe = tick % 2 ? swap1 : swap0;
-					nodes.push(pipe.with(cur === "A" ? swapBgAB : swapBgBA));
-					cur = cur === "A" ? "B" : "A";
-					tick++;
-				}
-				nodes.push(outputPass.with(cur === "A" ? outputBgA : outputBgB));
-				frame++;
-				return nodes;
-			}
-		};
-	},
-	fragment: ({ childNode, ctx, computeOutputs, propValues, convertToTexture }) => {
-		if (!childNode) return ZERO;
-		const state = computeOutputs?.state;
-		const childTex = computeOutputs?.childTexture;
-		if (!state || !childTex) return call(unpremultiplyAlpha, "unpremultiplyAlpha", [convertToTexture(childNode).sample(ctx.uv)]);
-		const vertical = propValues.axis === "vertical";
-		const srcCoord = state.sample(ctx.uv, "nearestClamp").member("r");
-		const childUV = vertical ? call(pixelSortUVVertical, "pixelSortUVVertical", [ctx.uv, srcCoord]) : call(pixelSortUVHorizontal, "pixelSortUVHorizontal", [ctx.uv, srcCoord]);
-		return call(unpremultiplyAlpha, "unpremultiplyAlpha", [childTex.sample(childUV)]);
-	}
-};
-var PixelSort_default = componentDefinition;
-export { lumaKernel as a, pixelSortUVHorizontal as c, componentDefinition as i, pixelSortUVVertical as l, brushWeight as n, makeOutputKernel as o, cellRand as r, makeSwapKernel as s, PixelSort_default as t };