shaders 2.5.135 → 3.0.437

package/dist/core/PixelSort-DMWTXIcO.js

@@ -0,0 +1,2331 @@
+import { At as call, B as createGuardedCompute, Ot as ZERO, R as std, Ut as blend_exports, V as createStateBuffer, Wt as unpremultiplyAlpha, n as tgpu, on as d } from "./coords-BlwgBpJf.js";
+var WORK = 512;
+var CELL_COUNT = WORK * WORK;
+var WORK_F = WORK;
+var MAX_COL = WORK - 1;
+var STATE_FORMAT = "rgba16float";
+const brushWeight = tgpu.fn([
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32
+], d.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 = std.select(dx, __tsover_mul(dx, aspect), aspect >= 1);
+	const ddy = std.select(__tsover_div(dy, aspect), dy, aspect >= 1);
+	const dist = std.sqrt(__tsover_add(__tsover_mul(ddx, ddx), __tsover_mul(ddy, ddy)));
+	const inner = __tsover_mul(radius, __tsover_sub(1, falloff));
+	return __tsover_sub(1, std.smoothstep(inner, radius, dist));
+}), {
+	v: 1,
+	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,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"dx",
+						[
+							1,
+							"dx",
+							"*",
+							"aspect"
+						],
+						[
+							1,
+							"aspect",
+							">=",
+							[5, "1"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"ddy",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						[
+							1,
+							"dy",
+							"/",
+							"aspect"
+						],
+						"dy",
+						[
+							1,
+							"aspect",
+							">=",
+							[5, "1"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"dist",
+				[
+					6,
+					[
+						7,
+						"std",
+						"sqrt"
+					],
+					[[
+						1,
+						[
+							1,
+							"ddx",
+							"*",
+							"ddx"
+						],
+						"+",
+						[
+							1,
+							"ddy",
+							"*",
+							"ddy"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"inner",
+				[
+					1,
+					"radius",
+					"*",
+					[
+						1,
+						[5, "1"],
+						"-",
+						"falloff"
+					]
+				]
+			],
+			[10, [
+				1,
+				[5, "1"],
+				"-",
+				[
+					6,
+					[
+						7,
+						"std",
+						"smoothstep"
+					],
+					[
+						"inner",
+						"radius",
+						"dist"
+					]
+				]
+			]]
+		]],
+		"externalNames": ["WORK_F", "std"]
+	},
+	externals: () => ({
+		WORK_F,
+		std
+	})
+}) && $.f)({}));
+const cellRand = tgpu.fn([
+	d.f32,
+	d.f32,
+	d.f32
+], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((xf, yf, seed) => {
+	"use gpu";
+	return std.fract(__tsover_mul(std.sin(__tsover_add(__tsover_add(__tsover_mul(xf, 12.9898), __tsover_mul(yf, 78.233)), __tsover_mul(seed, .137))), 43758.5453));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "xf"
+			},
+			{
+				"type": "i",
+				"name": "yf"
+			},
+			{
+				"type": "i",
+				"name": "seed"
+			}
+		],
+		"body": [0, [[10, [
+			6,
+			[
+				7,
+				"std",
+				"fract"
+			],
+			[[
+				1,
+				[
+					6,
+					[
+						7,
+						"std",
+						"sin"
+					],
+					[[
+						1,
+						[
+							1,
+							[
+								1,
+								"xf",
+								"*",
+								[5, "12.9898"]
+							],
+							"+",
+							[
+								1,
+								"yf",
+								"*",
+								[5, "78.233"]
+							]
+						],
+						"+",
+						[
+							1,
+							"seed",
+							"*",
+							[5, "0.137"]
+						]
+					]]
+				],
+				"*",
+				[5, "43758.5453"]
+			]]
+		]]]],
+		"externalNames": ["std"]
+	},
+	externals: () => ({ std })
+}) && $.f)({}));
+var lumaLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+	input: { texture: d.texture2d(d.f32) },
+	lumaBuf: {
+		storage: d.arrayOf(d.f32, CELL_COUNT),
+		access: "mutable"
+	},
+	params: { uniform: /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(d.struct({
+		inputWidth: d.f32,
+		inputHeight: d.f32
+	}), "uniform") }
+}), "lumaLayout");
+var swapLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+	readBuf: {
+		storage: d.arrayOf(d.f32, CELL_COUNT),
+		access: "readonly"
+	},
+	writeBuf: {
+		storage: d.arrayOf(d.f32, CELL_COUNT),
+		access: "mutable"
+	},
+	lumaBuf: {
+		storage: d.arrayOf(d.f32, CELL_COUNT),
+		access: "readonly"
+	},
+	params: { uniform: /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(d.struct({
+		mouseX: d.f32,
+		mouseY: d.f32,
+		radius: d.f32,
+		falloff: d.f32,
+		decay: d.f32,
+		aspect: d.f32,
+		seed: d.f32
+	}), "uniform") }
+}), "swapLayout");
+var outputLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+	srcBuf: {
+		storage: d.arrayOf(d.f32, CELL_COUNT),
+		access: "readonly"
+	},
+	stateTex: { storageTexture: d.textureStorage2d(STATE_FORMAT, "write-only") }
+}), "outputLayout");
+const lumaKernel = tgpu.fn([d.u32, d.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, d.u32(WORK)), cx);
+	const u = __tsover_div(__tsover_add(d.f32(cx), .5), WORK_F);
+	const v = __tsover_div(__tsover_add(d.f32(cy), .5), WORK_F);
+	const ix = std.clamp(d.i32(std.round(__tsover_mul(u, p.inputWidth))), 0, d.i32(__tsover_sub(p.inputWidth, 1)));
+	const iy = std.clamp(d.i32(std.round(__tsover_mul(v, p.inputHeight))), 0, d.i32(__tsover_sub(p.inputHeight, 1)));
+	const rgb = unpremultiplyAlpha(std.textureLoad(lumaLayout.$.input, d.vec2u(d.u32(ix), d.u32(iy)), 0)).xyz;
+	lumaLayout.$.lumaBuf[idx] = std.dot(rgb, d.vec3f(.299, .587, .114));
+}), {
+	v: 1,
+	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,
+							[
+								7,
+								"d",
+								"u32"
+							],
+							["WORK"]
+						]
+					],
+					"+",
+					"cx"
+				]
+			],
+			[
+				13,
+				"u",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							["cx"]
+						],
+						"+",
+						[5, "0.5"]
+					],
+					"/",
+					"WORK_F"
+				]
+			],
+			[
+				13,
+				"v",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							["cy"]
+						],
+						"+",
+						[5, "0.5"]
+					],
+					"/",
+					"WORK_F"
+				]
+			],
+			[
+				13,
+				"ix",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"d",
+								"i32"
+							],
+							[[
+								6,
+								[
+									7,
+									"std",
+									"round"
+								],
+								[[
+									1,
+									"u",
+									"*",
+									[
+										7,
+										"p",
+										"inputWidth"
+									]
+								]]
+							]]
+						],
+						[5, "0"],
+						[
+							6,
+							[
+								7,
+								"d",
+								"i32"
+							],
+							[[
+								1,
+								[
+									7,
+									"p",
+									"inputWidth"
+								],
+								"-",
+								[5, "1"]
+							]]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"iy",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"d",
+								"i32"
+							],
+							[[
+								6,
+								[
+									7,
+									"std",
+									"round"
+								],
+								[[
+									1,
+									"v",
+									"*",
+									[
+										7,
+										"p",
+										"inputHeight"
+									]
+								]]
+							]]
+						],
+						[5, "0"],
+						[
+							6,
+							[
+								7,
+								"d",
+								"i32"
+							],
+							[[
+								1,
+								[
+									7,
+									"p",
+									"inputHeight"
+								],
+								"-",
+								[5, "1"]
+							]]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"texel",
+				[
+					6,
+					[
+						7,
+						"std",
+						"textureLoad"
+					],
+					[
+						[
+							7,
+							[
+								7,
+								"lumaLayout",
+								"$"
+							],
+							"input"
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec2u"
+							],
+							[[
+								6,
+								[
+									7,
+									"d",
+									"u32"
+								],
+								["ix"]
+							], [
+								6,
+								[
+									7,
+									"d",
+									"u32"
+								],
+								["iy"]
+							]]
+						],
+						[5, "0"]
+					]
+				]
+			],
+			[
+				13,
+				"rgb",
+				[
+					7,
+					[
+						6,
+						[
+							7,
+							"blend",
+							"unpremultiplyAlpha"
+						],
+						["texel"]
+					],
+					"xyz"
+				]
+			],
+			[
+				2,
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"lumaLayout",
+							"$"
+						],
+						"lumaBuf"
+					],
+					"idx"
+				],
+				"=",
+				[
+					6,
+					[
+						7,
+						"std",
+						"dot"
+					],
+					["rgb", [
+						6,
+						[
+							7,
+							"d",
+							"vec3f"
+						],
+						[
+							[5, "0.299"],
+							[5, "0.587"],
+							[5, "0.114"]
+						]
+					]]
+				]
+			]
+		]],
+		"externalNames": [
+			"lumaLayout",
+			"d",
+			"WORK",
+			"WORK_F",
+			"std",
+			"blend"
+		]
+	},
+	externals: () => ({
+		lumaLayout,
+		d,
+		WORK,
+		WORK_F,
+		std,
+		blend: blend_exports
+	})
+}) && $.f)({})).$name("pixelSortLuma");
+function makeSwapKernel(vertical, dir, parity) {
+	return tgpu.fn([d.u32, d.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, d.u32(WORK)), cx);
+		const xf = d.f32(cx);
+		const yf = d.f32(cy);
+		const lineC = vertical ? cy : cx;
+		const fixedC = vertical ? cx : cy;
+		const lineCf = d.f32(lineC);
+		const lineCi = d.i32(lineC);
+		const myOff = swapLayout.$.readBuf[idx];
+		const myCol = std.clamp(__tsover_add(lineCf, myOff), 0, MAX_COL);
+		const isLeft = __tsover_mod(__tsover_add(lineC, d.u32(parity)), d.u32(2)) === d.u32(0);
+		const partnerLineI = std.select(__tsover_sub(lineCi, 1), __tsover_add(lineCi, 1), isLeft);
+		const valid = partnerLineI >= 0 && partnerLineI < WORK;
+		const pClamped = std.clamp(partnerLineI, 0, __tsover_sub(WORK, 1));
+		const pClampedU = d.u32(pClamped);
+		const partnerX = vertical ? fixedC : pClampedU;
+		const partnerY = vertical ? pClampedU : fixedC;
+		const partnerIdx = __tsover_add(__tsover_mul(partnerY, d.u32(WORK)), partnerX);
+		const partnerOff = swapLayout.$.readBuf[partnerIdx];
+		const partnerCol = std.clamp(__tsover_add(d.f32(pClamped), partnerOff), 0, MAX_COL);
+		const myC0 = std.clamp(std.floor(myCol), 0, MAX_COL);
+		const myC1 = std.min(__tsover_add(myC0, 1), MAX_COL);
+		const myIdx0 = vertical ? __tsover_add(__tsover_mul(d.u32(myC0), d.u32(WORK)), fixedC) : __tsover_add(__tsover_mul(fixedC, d.u32(WORK)), d.u32(myC0));
+		const myIdx1 = vertical ? __tsover_add(__tsover_mul(d.u32(myC1), d.u32(WORK)), fixedC) : __tsover_add(__tsover_mul(fixedC, d.u32(WORK)), d.u32(myC1));
+		const myKey = std.mix(swapLayout.$.lumaBuf[myIdx0], swapLayout.$.lumaBuf[myIdx1], __tsover_sub(myCol, myC0));
+		const pC0 = std.clamp(std.floor(partnerCol), 0, MAX_COL);
+		const pC1 = std.min(__tsover_add(pC0, 1), MAX_COL);
+		const pIdx0 = vertical ? __tsover_add(__tsover_mul(d.u32(pC0), d.u32(WORK)), fixedC) : __tsover_add(__tsover_mul(fixedC, d.u32(WORK)), d.u32(pC0));
+		const pIdx1 = vertical ? __tsover_add(__tsover_mul(d.u32(pC1), d.u32(WORK)), fixedC) : __tsover_add(__tsover_mul(fixedC, d.u32(WORK)), d.u32(pC1));
+		const partnerKey = std.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(d.f32(partnerX), d.f32(partnerY), p.mouseX, p.mouseY, p.radius, p.falloff, p.aspect);
+		const rnd = cellRand(xf, yf, p.seed);
+		const gate = valid && std.min(wMy, wP) > rnd;
+		const keyDiff = __tsover_mul(__tsover_sub(myKey, partnerKey), dir);
+		const takePartner = std.select(keyDiff < 0, keyDiff > 0, isLeft);
+		const newCol = std.select(myCol, partnerCol, gate && takePartner);
+		const decayed = std.mix(newCol, lineCf, p.decay);
+		swapLayout.$.writeBuf[idx] = __tsover_sub(decayed, lineCf);
+	}), {
+		v: 1,
+		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,
+								[
+									7,
+									"d",
+									"u32"
+								],
+								["WORK"]
+							]
+						],
+						"+",
+						"cx"
+					]
+				],
+				[
+					13,
+					"xf",
+					[
+						6,
+						[
+							7,
+							"d",
+							"f32"
+						],
+						["cx"]
+					]
+				],
+				[
+					13,
+					"yf",
+					[
+						6,
+						[
+							7,
+							"d",
+							"f32"
+						],
+						["cy"]
+					]
+				],
+				[
+					13,
+					"lineC",
+					[
+						105,
+						"vertical",
+						"cy",
+						"cx"
+					]
+				],
+				[
+					13,
+					"fixedC",
+					[
+						105,
+						"vertical",
+						"cx",
+						"cy"
+					]
+				],
+				[
+					13,
+					"lineCf",
+					[
+						6,
+						[
+							7,
+							"d",
+							"f32"
+						],
+						["lineC"]
+					]
+				],
+				[
+					13,
+					"lineCi",
+					[
+						6,
+						[
+							7,
+							"d",
+							"i32"
+						],
+						["lineC"]
+					]
+				],
+				[
+					13,
+					"myOff",
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"swapLayout",
+								"$"
+							],
+							"readBuf"
+						],
+						"idx"
+					]
+				],
+				[
+					13,
+					"myCol",
+					[
+						6,
+						[
+							7,
+							"std",
+							"clamp"
+						],
+						[
+							[
+								1,
+								"lineCf",
+								"+",
+								"myOff"
+							],
+							[5, "0"],
+							"MAX_COL"
+						]
+					]
+				],
+				[
+					13,
+					"isLeft",
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								"lineC",
+								"+",
+								[
+									6,
+									[
+										7,
+										"d",
+										"u32"
+									],
+									["parity"]
+								]
+							],
+							"%",
+							[
+								6,
+								[
+									7,
+									"d",
+									"u32"
+								],
+								[[5, "2"]]
+							]
+						],
+						"===",
+						[
+							6,
+							[
+								7,
+								"d",
+								"u32"
+							],
+							[[5, "0"]]
+						]
+					]
+				],
+				[
+					13,
+					"partnerLineI",
+					[
+						6,
+						[
+							7,
+							"std",
+							"select"
+						],
+						[
+							[
+								1,
+								"lineCi",
+								"-",
+								[5, "1"]
+							],
+							[
+								1,
+								"lineCi",
+								"+",
+								[5, "1"]
+							],
+							"isLeft"
+						]
+					]
+				],
+				[
+					13,
+					"valid",
+					[
+						3,
+						[
+							1,
+							"partnerLineI",
+							">=",
+							[5, "0"]
+						],
+						"&&",
+						[
+							1,
+							"partnerLineI",
+							"<",
+							"WORK"
+						]
+					]
+				],
+				[
+					13,
+					"pClamped",
+					[
+						6,
+						[
+							7,
+							"std",
+							"clamp"
+						],
+						[
+							"partnerLineI",
+							[5, "0"],
+							[
+								1,
+								"WORK",
+								"-",
+								[5, "1"]
+							]
+						]
+					]
+				],
+				[
+					13,
+					"pClampedU",
+					[
+						6,
+						[
+							7,
+							"d",
+							"u32"
+						],
+						["pClamped"]
+					]
+				],
+				[
+					13,
+					"partnerX",
+					[
+						105,
+						"vertical",
+						"fixedC",
+						"pClampedU"
+					]
+				],
+				[
+					13,
+					"partnerY",
+					[
+						105,
+						"vertical",
+						"pClampedU",
+						"fixedC"
+					]
+				],
+				[
+					13,
+					"partnerIdx",
+					[
+						1,
+						[
+							1,
+							"partnerY",
+							"*",
+							[
+								6,
+								[
+									7,
+									"d",
+									"u32"
+								],
+								["WORK"]
+							]
+						],
+						"+",
+						"partnerX"
+					]
+				],
+				[
+					13,
+					"partnerOff",
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"swapLayout",
+								"$"
+							],
+							"readBuf"
+						],
+						"partnerIdx"
+					]
+				],
+				[
+					13,
+					"partnerCol",
+					[
+						6,
+						[
+							7,
+							"std",
+							"clamp"
+						],
+						[
+							[
+								1,
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									["pClamped"]
+								],
+								"+",
+								"partnerOff"
+							],
+							[5, "0"],
+							"MAX_COL"
+						]
+					]
+				],
+				[
+					13,
+					"myC0",
+					[
+						6,
+						[
+							7,
+							"std",
+							"clamp"
+						],
+						[
+							[
+								6,
+								[
+									7,
+									"std",
+									"floor"
+								],
+								["myCol"]
+							],
+							[5, "0"],
+							"MAX_COL"
+						]
+					]
+				],
+				[
+					13,
+					"myC1",
+					[
+						6,
+						[
+							7,
+							"std",
+							"min"
+						],
+						[[
+							1,
+							"myC0",
+							"+",
+							[5, "1"]
+						], "MAX_COL"]
+					]
+				],
+				[
+					13,
+					"myIdx0",
+					[
+						105,
+						"vertical",
+						[
+							1,
+							[
+								1,
+								[
+									6,
+									[
+										7,
+										"d",
+										"u32"
+									],
+									["myC0"]
+								],
+								"*",
+								[
+									6,
+									[
+										7,
+										"d",
+										"u32"
+									],
+									["WORK"]
+								]
+							],
+							"+",
+							"fixedC"
+						],
+						[
+							1,
+							[
+								1,
+								"fixedC",
+								"*",
+								[
+									6,
+									[
+										7,
+										"d",
+										"u32"
+									],
+									["WORK"]
+								]
+							],
+							"+",
+							[
+								6,
+								[
+									7,
+									"d",
+									"u32"
+								],
+								["myC0"]
+							]
+						]
+					]
+				],
+				[
+					13,
+					"myIdx1",
+					[
+						105,
+						"vertical",
+						[
+							1,
+							[
+								1,
+								[
+									6,
+									[
+										7,
+										"d",
+										"u32"
+									],
+									["myC1"]
+								],
+								"*",
+								[
+									6,
+									[
+										7,
+										"d",
+										"u32"
+									],
+									["WORK"]
+								]
+							],
+							"+",
+							"fixedC"
+						],
+						[
+							1,
+							[
+								1,
+								"fixedC",
+								"*",
+								[
+									6,
+									[
+										7,
+										"d",
+										"u32"
+									],
+									["WORK"]
+								]
+							],
+							"+",
+							[
+								6,
+								[
+									7,
+									"d",
+									"u32"
+								],
+								["myC1"]
+							]
+						]
+					]
+				],
+				[
+					13,
+					"myKey",
+					[
+						6,
+						[
+							7,
+							"std",
+							"mix"
+						],
+						[
+							[
+								8,
+								[
+									7,
+									[
+										7,
+										"swapLayout",
+										"$"
+									],
+									"lumaBuf"
+								],
+								"myIdx0"
+							],
+							[
+								8,
+								[
+									7,
+									[
+										7,
+										"swapLayout",
+										"$"
+									],
+									"lumaBuf"
+								],
+								"myIdx1"
+							],
+							[
+								1,
+								"myCol",
+								"-",
+								"myC0"
+							]
+						]
+					]
+				],
+				[
+					13,
+					"pC0",
+					[
+						6,
+						[
+							7,
+							"std",
+							"clamp"
+						],
+						[
+							[
+								6,
+								[
+									7,
+									"std",
+									"floor"
+								],
+								["partnerCol"]
+							],
+							[5, "0"],
+							"MAX_COL"
+						]
+					]
+				],
+				[
+					13,
+					"pC1",
+					[
+						6,
+						[
+							7,
+							"std",
+							"min"
+						],
+						[[
+							1,
+							"pC0",
+							"+",
+							[5, "1"]
+						], "MAX_COL"]
+					]
+				],
+				[
+					13,
+					"pIdx0",
+					[
+						105,
+						"vertical",
+						[
+							1,
+							[
+								1,
+								[
+									6,
+									[
+										7,
+										"d",
+										"u32"
+									],
+									["pC0"]
+								],
+								"*",
+								[
+									6,
+									[
+										7,
+										"d",
+										"u32"
+									],
+									["WORK"]
+								]
+							],
+							"+",
+							"fixedC"
+						],
+						[
+							1,
+							[
+								1,
+								"fixedC",
+								"*",
+								[
+									6,
+									[
+										7,
+										"d",
+										"u32"
+									],
+									["WORK"]
+								]
+							],
+							"+",
+							[
+								6,
+								[
+									7,
+									"d",
+									"u32"
+								],
+								["pC0"]
+							]
+						]
+					]
+				],
+				[
+					13,
+					"pIdx1",
+					[
+						105,
+						"vertical",
+						[
+							1,
+							[
+								1,
+								[
+									6,
+									[
+										7,
+										"d",
+										"u32"
+									],
+									["pC1"]
+								],
+								"*",
+								[
+									6,
+									[
+										7,
+										"d",
+										"u32"
+									],
+									["WORK"]
+								]
+							],
+							"+",
+							"fixedC"
+						],
+						[
+							1,
+							[
+								1,
+								"fixedC",
+								"*",
+								[
+									6,
+									[
+										7,
+										"d",
+										"u32"
+									],
+									["WORK"]
+								]
+							],
+							"+",
+							[
+								6,
+								[
+									7,
+									"d",
+									"u32"
+								],
+								["pC1"]
+							]
+						]
+					]
+				],
+				[
+					13,
+					"partnerKey",
+					[
+						6,
+						[
+							7,
+							"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,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								["partnerX"]
+							],
+							[
+								6,
+								[
+									7,
+									"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,
+								[
+									7,
+									"std",
+									"min"
+								],
+								["wMy", "wP"]
+							],
+							">",
+							"rnd"
+						]
+					]
+				],
+				[
+					13,
+					"keyDiff",
+					[
+						1,
+						[
+							1,
+							"myKey",
+							"-",
+							"partnerKey"
+						],
+						"*",
+						"dir"
+					]
+				],
+				[
+					13,
+					"takePartner",
+					[
+						6,
+						[
+							7,
+							"std",
+							"select"
+						],
+						[
+							[
+								1,
+								"keyDiff",
+								"<",
+								[5, "0"]
+							],
+							[
+								1,
+								"keyDiff",
+								">",
+								[5, "0"]
+							],
+							"isLeft"
+						]
+					]
+				],
+				[
+					13,
+					"newCol",
+					[
+						6,
+						[
+							7,
+							"std",
+							"select"
+						],
+						[
+							"myCol",
+							"partnerCol",
+							[
+								3,
+								"gate",
+								"&&",
+								"takePartner"
+							]
+						]
+					]
+				],
+				[
+					13,
+					"decayed",
+					[
+						6,
+						[
+							7,
+							"std",
+							"mix"
+						],
+						[
+							"newCol",
+							"lineCf",
+							[
+								7,
+								"p",
+								"decay"
+							]
+						]
+					]
+				],
+				[
+					2,
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"swapLayout",
+								"$"
+							],
+							"writeBuf"
+						],
+						"idx"
+					],
+					"=",
+					[
+						1,
+						"decayed",
+						"-",
+						"lineCf"
+					]
+				]
+			]],
+			"externalNames": [
+				"swapLayout",
+				"d",
+				"WORK",
+				"vertical",
+				"std",
+				"MAX_COL",
+				"parity",
+				"brushWeight",
+				"cellRand",
+				"dir"
+			]
+		},
+		externals: () => ({
+			swapLayout,
+			d,
+			WORK,
+			vertical,
+			std,
+			MAX_COL,
+			parity,
+			brushWeight,
+			cellRand,
+			dir
+		})
+	}) && $.f)({})).$name("pixelSortSwap");
+}
+function makeOutputKernel(vertical) {
+	return tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+		"use gpu";
+		const idx = __tsover_add(__tsover_mul(cy, d.u32(WORK)), cx);
+		const lineC = vertical ? cy : cx;
+		const col = std.clamp(__tsover_add(d.f32(lineC), outputLayout.$.srcBuf[idx]), 0, MAX_COL);
+		const u = __tsover_div(__tsover_add(col, .5), WORK_F);
+		std.textureStore(outputLayout.$.stateTex, d.vec2u(cx, cy), d.vec4f(u, 0, 0, 1));
+	}), {
+		v: 1,
+		name: void 0,
+		ast: {
+			"params": [{
+				"type": "i",
+				"name": "cx"
+			}, {
+				"type": "i",
+				"name": "cy"
+			}],
+			"body": [0, [
+				[
+					13,
+					"idx",
+					[
+						1,
+						[
+							1,
+							"cy",
+							"*",
+							[
+								6,
+								[
+									7,
+									"d",
+									"u32"
+								],
+								["WORK"]
+							]
+						],
+						"+",
+						"cx"
+					]
+				],
+				[
+					13,
+					"lineC",
+					[
+						105,
+						"vertical",
+						"cy",
+						"cx"
+					]
+				],
+				[
+					13,
+					"col",
+					[
+						6,
+						[
+							7,
+							"std",
+							"clamp"
+						],
+						[
+							[
+								1,
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									["lineC"]
+								],
+								"+",
+								[
+									8,
+									[
+										7,
+										[
+											7,
+											"outputLayout",
+											"$"
+										],
+										"srcBuf"
+									],
+									"idx"
+								]
+							],
+							[5, "0"],
+							"MAX_COL"
+						]
+					]
+				],
+				[
+					13,
+					"u",
+					[
+						1,
+						[
+							1,
+							"col",
+							"+",
+							[5, "0.5"]
+						],
+						"/",
+						"WORK_F"
+					]
+				],
+				[
+					6,
+					[
+						7,
+						"std",
+						"textureStore"
+					],
+					[
+						[
+							7,
+							[
+								7,
+								"outputLayout",
+								"$"
+							],
+							"stateTex"
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec2u"
+							],
+							["cx", "cy"]
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec4f"
+							],
+							[
+								"u",
+								[5, "0"],
+								[5, "0"],
+								[5, "1"]
+							]
+						]
+					]
+				]
+			]],
+			"externalNames": [
+				"d",
+				"WORK",
+				"vertical",
+				"std",
+				"outputLayout",
+				"MAX_COL",
+				"WORK_F"
+			]
+		},
+		externals: () => ({
+			d,
+			WORK,
+			vertical,
+			std,
+			outputLayout,
+			MAX_COL,
+			WORK_F
+		})
+	}) && $.f)({})).$name("pixelSortOutput");
+}
+const pixelSortUVVertical = tgpu.fn([d.vec2f, d.f32], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, srcCoord) => {
+	"use gpu";
+	return d.vec2f(uv.x, srcCoord);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "uv"
+		}, {
+			"type": "i",
+			"name": "srcCoord"
+		}],
+		"body": [0, [[10, [
+			6,
+			[
+				7,
+				"d",
+				"vec2f"
+			],
+			[[
+				7,
+				"uv",
+				"x"
+			], "srcCoord"]
+		]]]],
+		"externalNames": ["d"]
+	},
+	externals: () => ({ d })
+}) && $.f)({}));
+const pixelSortUVHorizontal = tgpu.fn([d.vec2f, d.f32], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, srcCoord) => {
+	"use gpu";
+	return d.vec2f(srcCoord, uv.y);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "uv"
+		}, {
+			"type": "i",
+			"name": "srcCoord"
+		}],
+		"body": [0, [[10, [
+			6,
+			[
+				7,
+				"d",
+				"vec2f"
+			],
+			["srcCoord", [
+				7,
+				"uv",
+				"y"
+			]]
+		]]]],
+		"externalNames": ["d"]
+	},
+	externals: () => ({ d })
+}) && $.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, d.f32, CELL_COUNT);
+		const bufferB = createStateBuffer(root, d.f32, CELL_COUNT);
+		const lumaBuf = createStateBuffer(root, d.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(d.struct({
+			inputWidth: d.f32,
+			inputHeight: d.f32
+		})), "lumaParams");
+		const swapParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(d.struct({
+			mouseX: d.f32,
+			mouseY: d.f32,
+			radius: d.f32,
+			falloff: d.f32,
+			decay: d.f32,
+			aspect: d.f32,
+			seed: d.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: 1,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "cx"
+				}, {
+					"type": "i",
+					"name": "cy"
+				}],
+				"body": [0, [[
+					6,
+					"lumaKernel",
+					["cx", "cy"]
+				]]],
+				"externalNames": ["lumaKernel"]
+			},
+			externals: () => ({ 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: 1,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "cx"
+				}, {
+					"type": "i",
+					"name": "cy"
+				}],
+				"body": [0, [[
+					6,
+					"swapKernel0",
+					["cx", "cy"]
+				]]],
+				"externalNames": ["swapKernel0"]
+			},
+			externals: () => ({ swapKernel0 })
+		}) && $.f)({}), { size });
+		const swap1 = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+			"use gpu";
+			swapKernel1(cx, cy);
+		}), {
+			v: 1,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "cx"
+				}, {
+					"type": "i",
+					"name": "cy"
+				}],
+				"body": [0, [[
+					6,
+					"swapKernel1",
+					["cx", "cy"]
+				]]],
+				"externalNames": ["swapKernel1"]
+			},
+			externals: () => ({ 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: 1,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "cx"
+				}, {
+					"type": "i",
+					"name": "cy"
+				}],
+				"body": [0, [[
+					6,
+					"outputKernel",
+					["cx", "cy"]
+				]]],
+				"externalNames": ["outputKernel"]
+			},
+			externals: () => ({ outputKernel })
+		}) && $.f)({}), { size });
+		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 };