shaders 3.1.462 → 3.2.464

package/dist/core/Dither-Aj5wYGgJ.js

@@ -1,2334 +0,0 @@
-import { At as step, Ft as vec3f, Kt as arrayOf, Lt as vec4f, Mt as vec2f, cn as i32, dt as dot, et as typegpu_default, f as arrayExpr, ht as fract, m as call, mt as floor, rt as select, sn as f32, v as floatE, vt as min, yt as mix } from "./edges-CV-BHMpI.js";
-import { x as defineRttFilter } from "./porters-j7yWJYy2.js";
-import { s as hash12 } from "./noise-eXd1Bfrw.js";
-import { a as transformColor } from "./transformations-u-UZrXjj.js";
-var transformPattern = (value) => {
-	return {
-		bayer2: 0,
-		bayer4: 1,
-		bayer8: 2,
-		clusteredDot: 3,
-		blueNoise: 4,
-		whiteNoise: 5,
-		floydSteinberg: 6
-	}[value] ?? 1;
-};
-var transformColorMode = (value) => value === "source" ? 1 : 0;
-var patternModeOf = (raw) => typeof raw === "number" ? raw : transformPattern(raw);
-var colorModeOf = (raw) => typeof raw === "number" ? raw : raw === "source" ? 1 : 0;
-const ditherCoord = typegpu_default.fn([
-	vec2f,
-	vec2f,
-	f32
-], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, gridRes, pixelSize) => {
-	"use gpu";
-	return floor(vec2f(__tsover_div(__tsover_mul(uv.x, gridRes.x), pixelSize), __tsover_div(__tsover_mul(uv.y, gridRes.y), pixelSize)));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "uv"
-			},
-			{
-				"type": "i",
-				"name": "gridRes"
-			},
-			{
-				"type": "i",
-				"name": "pixelSize"
-			}
-		],
-		"body": [0, [[10, [
-			6,
-			"std.floor",
-			[[
-				6,
-				"d.vec2f",
-				[[
-					1,
-					[
-						1,
-						[
-							7,
-							"uv",
-							"x"
-						],
-						"*",
-						[
-							7,
-							"gridRes",
-							"x"
-						]
-					],
-					"/",
-					"pixelSize"
-				], [
-					1,
-					[
-						1,
-						[
-							7,
-							"uv",
-							"y"
-						],
-						"*",
-						[
-							7,
-							"gridRes",
-							"y"
-						]
-					],
-					"/",
-					"pixelSize"
-				]]
-			]]
-		]]]]
-	},
-	externals: {
-		"std.floor": () => floor,
-		"d.vec2f": () => vec2f
-	}
-}) && $.f)({}));
-const ditherPixUV = typegpu_default.fn([
-	vec2f,
-	f32,
-	vec2f
-], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((coord, pixelSize, gridRes) => {
-	"use gpu";
-	return vec2f(__tsover_div(__tsover_mul(__tsover_add(coord.x, .5), pixelSize), gridRes.x), __tsover_div(__tsover_mul(__tsover_add(coord.y, .5), pixelSize), gridRes.y));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "coord"
-			},
-			{
-				"type": "i",
-				"name": "pixelSize"
-			},
-			{
-				"type": "i",
-				"name": "gridRes"
-			}
-		],
-		"body": [0, [[10, [
-			6,
-			"d.vec2f",
-			[[
-				1,
-				[
-					1,
-					[
-						1,
-						[
-							7,
-							"coord",
-							"x"
-						],
-						"+",
-						[5, "0.5"]
-					],
-					"*",
-					"pixelSize"
-				],
-				"/",
-				[
-					7,
-					"gridRes",
-					"x"
-				]
-			], [
-				1,
-				[
-					1,
-					[
-						1,
-						[
-							7,
-							"coord",
-							"y"
-						],
-						"+",
-						[5, "0.5"]
-					],
-					"*",
-					"pixelSize"
-				],
-				"/",
-				[
-					7,
-					"gridRes",
-					"y"
-				]
-			]]
-		]]]]
-	},
-	externals: { "d.vec2f": () => vec2f }
-}) && $.f)({}));
-const ditherLuma = typegpu_default.fn([vec4f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((c) => {
-	"use gpu";
-	return __tsover_mul(dot(vec3f(c.x, c.y, c.z), vec3f(.299, .587, .114)), c.w);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "c"
-		}],
-		"body": [0, [[10, [
-			1,
-			[
-				6,
-				"std.dot",
-				[[
-					6,
-					"d.vec3f",
-					[
-						[
-							7,
-							"c",
-							"x"
-						],
-						[
-							7,
-							"c",
-							"y"
-						],
-						[
-							7,
-							"c",
-							"z"
-						]
-					]
-				], [
-					6,
-					"d.vec3f",
-					[
-						[5, "0.299"],
-						[5, "0.587"],
-						[5, "0.114"]
-					]
-				]]
-			],
-			"*",
-			[
-				7,
-				"c",
-				"w"
-			]
-		]]]]
-	},
-	externals: {
-		"std.dot": () => dot,
-		"d.vec3f": () => vec3f
-	}
-}) && $.f)({}));
-const ditherBayerQuad = typegpu_default.fn([f32, f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((a, b) => {
-	"use gpu";
-	return __tsover_sub(__tsover_add(__tsover_mul(b, 3), __tsover_mul(a, 2)), __tsover_mul(__tsover_mul(a, b), 4));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "a"
-		}, {
-			"type": "i",
-			"name": "b"
-		}],
-		"body": [0, [[10, [
-			1,
-			[
-				1,
-				[
-					1,
-					"b",
-					"*",
-					[5, "3"]
-				],
-				"+",
-				[
-					1,
-					"a",
-					"*",
-					[5, "2"]
-				]
-			],
-			"-",
-			[
-				1,
-				[
-					1,
-					"a",
-					"*",
-					"b"
-				],
-				"*",
-				[5, "4"]
-			]
-		]]]]
-	},
-	externals: {}
-}) && $.f)({}));
-const ditherPeriodic = typegpu_default.fn([vec2f], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((coord) => {
-	"use gpu";
-	const tx = __tsover_sub(coord.x, __tsover_mul(8, floor(__tsover_div(coord.x, 8))));
-	const ty = __tsover_sub(coord.y, __tsover_mul(8, floor(__tsover_div(coord.y, 8))));
-	const x2 = __tsover_sub(tx, __tsover_mul(2, floor(__tsover_div(tx, 2))));
-	const y2 = __tsover_sub(ty, __tsover_mul(2, floor(__tsover_div(ty, 2))));
-	const x4 = __tsover_sub(tx, __tsover_mul(4, floor(__tsover_div(tx, 4))));
-	const y4 = __tsover_sub(ty, __tsover_mul(4, floor(__tsover_div(ty, 4))));
-	const x4h = floor(__tsover_div(x4, 2));
-	const y4h = floor(__tsover_div(y4, 2));
-	const x8h = floor(__tsover_div(tx, 4));
-	const y8h = floor(__tsover_div(ty, 4));
-	const b00 = ditherBayerQuad(x2, y2);
-	const b11 = ditherBayerQuad(x4h, y4h);
-	const b22 = ditherBayerQuad(x8h, y8h);
-	const bayer2 = __tsover_div(b00, 4);
-	const bayer4 = __tsover_div(__tsover_add(__tsover_mul(b00, 4), b11), 16);
-	const bayer8 = __tsover_div(__tsover_add(__tsover_add(__tsover_mul(b00, 16), __tsover_mul(b11, 4)), b22), 64);
-	const idx = __tsover_add(__tsover_mul(i32(y4), 4), i32(x4));
-	let cd = .75;
-	cd = select(cd, .3125, idx === 1);
-	cd = select(cd, .375, idx === 2);
-	cd = select(cd, .8125, idx === 3);
-	cd = select(cd, .25, idx === 4);
-	cd = select(cd, f32(0), idx === 5);
-	cd = select(cd, .0625, idx === 6);
-	cd = select(cd, .4375, idx === 7);
-	cd = select(cd, .6875, idx === 8);
-	cd = select(cd, .1875, idx === 9);
-	cd = select(cd, .125, idx === 10);
-	cd = select(cd, .5, idx === 11);
-	cd = select(cd, .9375, idx === 12);
-	cd = select(cd, .625, idx === 13);
-	cd = select(cd, .5625, idx === 14);
-	cd = select(cd, .875, idx === 15);
-	return vec4f(bayer2, bayer4, bayer8, cd);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "coord"
-		}],
-		"body": [0, [
-			[
-				13,
-				"tx",
-				[
-					1,
-					[
-						7,
-						"coord",
-						"x"
-					],
-					"-",
-					[
-						1,
-						[5, "8"],
-						"*",
-						[
-							6,
-							"std.floor",
-							[[
-								1,
-								[
-									7,
-									"coord",
-									"x"
-								],
-								"/",
-								[5, "8"]
-							]]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"ty",
-				[
-					1,
-					[
-						7,
-						"coord",
-						"y"
-					],
-					"-",
-					[
-						1,
-						[5, "8"],
-						"*",
-						[
-							6,
-							"std.floor",
-							[[
-								1,
-								[
-									7,
-									"coord",
-									"y"
-								],
-								"/",
-								[5, "8"]
-							]]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"x2",
-				[
-					1,
-					"tx",
-					"-",
-					[
-						1,
-						[5, "2"],
-						"*",
-						[
-							6,
-							"std.floor",
-							[[
-								1,
-								"tx",
-								"/",
-								[5, "2"]
-							]]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"y2",
-				[
-					1,
-					"ty",
-					"-",
-					[
-						1,
-						[5, "2"],
-						"*",
-						[
-							6,
-							"std.floor",
-							[[
-								1,
-								"ty",
-								"/",
-								[5, "2"]
-							]]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"x4",
-				[
-					1,
-					"tx",
-					"-",
-					[
-						1,
-						[5, "4"],
-						"*",
-						[
-							6,
-							"std.floor",
-							[[
-								1,
-								"tx",
-								"/",
-								[5, "4"]
-							]]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"y4",
-				[
-					1,
-					"ty",
-					"-",
-					[
-						1,
-						[5, "4"],
-						"*",
-						[
-							6,
-							"std.floor",
-							[[
-								1,
-								"ty",
-								"/",
-								[5, "4"]
-							]]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"x4h",
-				[
-					6,
-					"std.floor",
-					[[
-						1,
-						"x4",
-						"/",
-						[5, "2"]
-					]]
-				]
-			],
-			[
-				13,
-				"y4h",
-				[
-					6,
-					"std.floor",
-					[[
-						1,
-						"y4",
-						"/",
-						[5, "2"]
-					]]
-				]
-			],
-			[
-				13,
-				"x8h",
-				[
-					6,
-					"std.floor",
-					[[
-						1,
-						"tx",
-						"/",
-						[5, "4"]
-					]]
-				]
-			],
-			[
-				13,
-				"y8h",
-				[
-					6,
-					"std.floor",
-					[[
-						1,
-						"ty",
-						"/",
-						[5, "4"]
-					]]
-				]
-			],
-			[
-				13,
-				"b00",
-				[
-					6,
-					"ditherBayerQuad",
-					["x2", "y2"]
-				]
-			],
-			[
-				13,
-				"b11",
-				[
-					6,
-					"ditherBayerQuad",
-					["x4h", "y4h"]
-				]
-			],
-			[
-				13,
-				"b22",
-				[
-					6,
-					"ditherBayerQuad",
-					["x8h", "y8h"]
-				]
-			],
-			[
-				13,
-				"bayer2",
-				[
-					1,
-					"b00",
-					"/",
-					[5, "4"]
-				]
-			],
-			[
-				13,
-				"bayer4",
-				[
-					1,
-					[
-						1,
-						[
-							1,
-							"b00",
-							"*",
-							[5, "4"]
-						],
-						"+",
-						"b11"
-					],
-					"/",
-					[5, "16"]
-				]
-			],
-			[
-				13,
-				"bayer8",
-				[
-					1,
-					[
-						1,
-						[
-							1,
-							[
-								1,
-								"b00",
-								"*",
-								[5, "16"]
-							],
-							"+",
-							[
-								1,
-								"b11",
-								"*",
-								[5, "4"]
-							]
-						],
-						"+",
-						"b22"
-					],
-					"/",
-					[5, "64"]
-				]
-			],
-			[
-				13,
-				"idx",
-				[
-					1,
-					[
-						1,
-						[
-							6,
-							"d.i32",
-							["y4"]
-						],
-						"*",
-						[5, "4"]
-					],
-					"+",
-					[
-						6,
-						"d.i32",
-						["x4"]
-					]
-				]
-			],
-			[
-				12,
-				"cd",
-				[5, "0.75"]
-			],
-			[
-				2,
-				"cd",
-				"=",
-				[
-					6,
-					"std.select",
-					[
-						"cd",
-						[5, "0.3125"],
-						[
-							1,
-							"idx",
-							"===",
-							[5, "1"]
-						]
-					]
-				]
-			],
-			[
-				2,
-				"cd",
-				"=",
-				[
-					6,
-					"std.select",
-					[
-						"cd",
-						[5, "0.375"],
-						[
-							1,
-							"idx",
-							"===",
-							[5, "2"]
-						]
-					]
-				]
-			],
-			[
-				2,
-				"cd",
-				"=",
-				[
-					6,
-					"std.select",
-					[
-						"cd",
-						[5, "0.8125"],
-						[
-							1,
-							"idx",
-							"===",
-							[5, "3"]
-						]
-					]
-				]
-			],
-			[
-				2,
-				"cd",
-				"=",
-				[
-					6,
-					"std.select",
-					[
-						"cd",
-						[5, "0.25"],
-						[
-							1,
-							"idx",
-							"===",
-							[5, "4"]
-						]
-					]
-				]
-			],
-			[
-				2,
-				"cd",
-				"=",
-				[
-					6,
-					"std.select",
-					[
-						"cd",
-						[
-							6,
-							"d.f32",
-							[[5, "0"]]
-						],
-						[
-							1,
-							"idx",
-							"===",
-							[5, "5"]
-						]
-					]
-				]
-			],
-			[
-				2,
-				"cd",
-				"=",
-				[
-					6,
-					"std.select",
-					[
-						"cd",
-						[5, "0.0625"],
-						[
-							1,
-							"idx",
-							"===",
-							[5, "6"]
-						]
-					]
-				]
-			],
-			[
-				2,
-				"cd",
-				"=",
-				[
-					6,
-					"std.select",
-					[
-						"cd",
-						[5, "0.4375"],
-						[
-							1,
-							"idx",
-							"===",
-							[5, "7"]
-						]
-					]
-				]
-			],
-			[
-				2,
-				"cd",
-				"=",
-				[
-					6,
-					"std.select",
-					[
-						"cd",
-						[5, "0.6875"],
-						[
-							1,
-							"idx",
-							"===",
-							[5, "8"]
-						]
-					]
-				]
-			],
-			[
-				2,
-				"cd",
-				"=",
-				[
-					6,
-					"std.select",
-					[
-						"cd",
-						[5, "0.1875"],
-						[
-							1,
-							"idx",
-							"===",
-							[5, "9"]
-						]
-					]
-				]
-			],
-			[
-				2,
-				"cd",
-				"=",
-				[
-					6,
-					"std.select",
-					[
-						"cd",
-						[5, "0.125"],
-						[
-							1,
-							"idx",
-							"===",
-							[5, "10"]
-						]
-					]
-				]
-			],
-			[
-				2,
-				"cd",
-				"=",
-				[
-					6,
-					"std.select",
-					[
-						"cd",
-						[5, "0.5"],
-						[
-							1,
-							"idx",
-							"===",
-							[5, "11"]
-						]
-					]
-				]
-			],
-			[
-				2,
-				"cd",
-				"=",
-				[
-					6,
-					"std.select",
-					[
-						"cd",
-						[5, "0.9375"],
-						[
-							1,
-							"idx",
-							"===",
-							[5, "12"]
-						]
-					]
-				]
-			],
-			[
-				2,
-				"cd",
-				"=",
-				[
-					6,
-					"std.select",
-					[
-						"cd",
-						[5, "0.625"],
-						[
-							1,
-							"idx",
-							"===",
-							[5, "13"]
-						]
-					]
-				]
-			],
-			[
-				2,
-				"cd",
-				"=",
-				[
-					6,
-					"std.select",
-					[
-						"cd",
-						[5, "0.5625"],
-						[
-							1,
-							"idx",
-							"===",
-							[5, "14"]
-						]
-					]
-				]
-			],
-			[
-				2,
-				"cd",
-				"=",
-				[
-					6,
-					"std.select",
-					[
-						"cd",
-						[5, "0.875"],
-						[
-							1,
-							"idx",
-							"===",
-							[5, "15"]
-						]
-					]
-				]
-			],
-			[10, [
-				6,
-				"d.vec4f",
-				[
-					"bayer2",
-					"bayer4",
-					"bayer8",
-					"cd"
-				]
-			]]
-		]]
-	},
-	externals: {
-		"std.floor": () => floor,
-		"ditherBayerQuad": () => ditherBayerQuad,
-		"d.i32": () => i32,
-		"std.select": () => select,
-		"d.f32": () => f32,
-		"d.vec4f": () => vec4f
-	}
-}) && $.f)({}));
-const ditherBlueNoise = typegpu_default.fn([vec2f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((coord) => {
-	"use gpu";
-	const c = coord.add(vec2f(.5, .5));
-	return fract(__tsover_mul(52.9829189, fract(__tsover_add(__tsover_mul(c.x, .06711056), __tsover_mul(c.y, .00583715)))));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "coord"
-		}],
-		"body": [0, [[
-			13,
-			"c",
-			[
-				6,
-				[
-					7,
-					"coord",
-					"add"
-				],
-				[[
-					6,
-					"d.vec2f",
-					[[5, "0.5"], [5, "0.5"]]
-				]]
-			]
-		], [10, [
-			6,
-			"std.fract",
-			[[
-				1,
-				[5, "52.9829189"],
-				"*",
-				[
-					6,
-					"std.fract",
-					[[
-						1,
-						[
-							1,
-							[
-								7,
-								"c",
-								"x"
-							],
-							"*",
-							[5, "0.06711056"]
-						],
-						"+",
-						[
-							1,
-							[
-								7,
-								"c",
-								"y"
-							],
-							"*",
-							[5, "0.00583715"]
-						]
-					]]
-				]
-			]]
-		]]]]
-	},
-	externals: {
-		"d.vec2f": () => vec2f,
-		"std.fract": () => fract
-	}
-}) && $.f)({}));
-const ditherWhiteNoise = typegpu_default.fn([vec2f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((coord) => {
-	"use gpu";
-	return hash12(coord);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "coord"
-		}],
-		"body": [0, [[10, [
-			6,
-			"noise.hash12",
-			["coord"]
-		]]]]
-	},
-	externals: { "noise.hash12": () => hash12 }
-}) && $.f)({}));
-const ditherOrderedResult = typegpu_default.fn([
-	f32,
-	f32,
-	f32,
-	f32
-], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((ditherValue, luminance, threshold, spread) => {
-	"use gpu";
-	return step(__tsover_add(.5, __tsover_mul(__tsover_sub(ditherValue, .5), spread)), __tsover_add(luminance, __tsover_sub(threshold, .5)));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "ditherValue"
-			},
-			{
-				"type": "i",
-				"name": "luminance"
-			},
-			{
-				"type": "i",
-				"name": "threshold"
-			},
-			{
-				"type": "i",
-				"name": "spread"
-			}
-		],
-		"body": [0, [[
-			13,
-			"adjustedDither",
-			[
-				1,
-				[5, "0.5"],
-				"+",
-				[
-					1,
-					[
-						1,
-						"ditherValue",
-						"-",
-						[5, "0.5"]
-					],
-					"*",
-					"spread"
-				]
-			]
-		], [10, [
-			6,
-			"std.step",
-			["adjustedDither", [
-				1,
-				"luminance",
-				"+",
-				[
-					1,
-					"threshold",
-					"-",
-					[5, "0.5"]
-				]
-			]]
-		]]]]
-	},
-	externals: { "std.step": () => step }
-}) && $.f)({}));
-const ditherBlockOrigin = typegpu_default.fn([vec2f], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((coord) => {
-	"use gpu";
-	return floor(coord.div(vec2f(8, 8))).mul(vec2f(8, 8));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "coord"
-		}],
-		"body": [0, [[10, [
-			6,
-			[
-				7,
-				[
-					6,
-					"std.floor",
-					[[
-						6,
-						[
-							7,
-							"coord",
-							"div"
-						],
-						[[
-							6,
-							"d.vec2f",
-							[[5, "8"], [5, "8"]]
-						]]
-					]]
-				],
-				"mul"
-			],
-			[[
-				6,
-				"d.vec2f",
-				[[5, "8"], [5, "8"]]
-			]]
-		]]]]
-	},
-	externals: {
-		"std.floor": () => floor,
-		"d.vec2f": () => vec2f
-	}
-}) && $.f)({}));
-const ditherLocalCellIndex = typegpu_default.fn([vec2f, vec2f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((coord, blockOrigin) => {
-	"use gpu";
-	return __tsover_add(__tsover_mul(__tsover_sub(coord.y, blockOrigin.y), 8), __tsover_sub(coord.x, blockOrigin.x));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "coord"
-		}, {
-			"type": "i",
-			"name": "blockOrigin"
-		}],
-		"body": [0, [[10, [
-			1,
-			[
-				1,
-				[
-					1,
-					[
-						7,
-						"coord",
-						"y"
-					],
-					"-",
-					[
-						7,
-						"blockOrigin",
-						"y"
-					]
-				],
-				"*",
-				[5, "8"]
-			],
-			"+",
-			[
-				1,
-				[
-					7,
-					"coord",
-					"x"
-				],
-				"-",
-				[
-					7,
-					"blockOrigin",
-					"x"
-				]
-			]
-		]]]]
-	},
-	externals: {}
-}) && $.f)({}));
-const ditherCellUV = typegpu_default.fn([
-	vec2f,
-	f32,
-	f32,
-	f32,
-	vec2f
-], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((blockOrigin, lx, ly, pixelSize, gridRes) => {
-	"use gpu";
-	return vec2f(__tsover_div(__tsover_mul(__tsover_add(__tsover_add(blockOrigin.x, lx), .5), pixelSize), gridRes.x), __tsover_div(__tsover_mul(__tsover_add(__tsover_add(blockOrigin.y, ly), .5), pixelSize), gridRes.y));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "blockOrigin"
-			},
-			{
-				"type": "i",
-				"name": "lx"
-			},
-			{
-				"type": "i",
-				"name": "ly"
-			},
-			{
-				"type": "i",
-				"name": "pixelSize"
-			},
-			{
-				"type": "i",
-				"name": "gridRes"
-			}
-		],
-		"body": [0, [[10, [
-			6,
-			"d.vec2f",
-			[[
-				1,
-				[
-					1,
-					[
-						1,
-						[
-							1,
-							[
-								7,
-								"blockOrigin",
-								"x"
-							],
-							"+",
-							"lx"
-						],
-						"+",
-						[5, "0.5"]
-					],
-					"*",
-					"pixelSize"
-				],
-				"/",
-				[
-					7,
-					"gridRes",
-					"x"
-				]
-			], [
-				1,
-				[
-					1,
-					[
-						1,
-						[
-							1,
-							[
-								7,
-								"blockOrigin",
-								"y"
-							],
-							"+",
-							"ly"
-						],
-						"+",
-						[5, "0.5"]
-					],
-					"*",
-					"pixelSize"
-				],
-				"/",
-				[
-					7,
-					"gridRes",
-					"y"
-				]
-			]]
-		]]]]
-	},
-	externals: { "d.vec2f": () => vec2f }
-}) && $.f)({}));
-const ditherFloydSteinberg = typegpu_default.fn([
-	arrayOf(f32, 64),
-	f32,
-	f32,
-	f32
-], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((lum, lic, threshold, spread) => {
-	"use gpu";
-	const thr = __tsover_sub(.5, __tsover_sub(threshold, .5));
-	const ecur = arrayOf(f32, 8)();
-	const enext = arrayOf(f32, 8)();
-	const licInt = i32(lic);
-	let result = f32(0);
-	for (let y = 0; y < 8; y++) {
-		const ltr = (y & 1) === 0;
-		for (let xi = 0; xi < 8; xi++) {
-			const x = select(__tsover_sub(7, xi), xi, ltr);
-			const idx = __tsover_add(__tsover_mul(y, 8), x);
-			const val = __tsover_add(lum[idx], ecur[x]);
-			const qv = step(thr, val);
-			result = select(result, qv, idx === licInt);
-			const e = __tsover_mul(__tsover_sub(val, qv), spread);
-			const dir = select(-1, 1, ltr);
-			const xr = __tsover_add(x, dir);
-			if (xr >= 0) {
-				if (xr < 8) ecur[xr] = __tsover_add(ecur[xr], __tsover_mul(e, .4375));
-			}
-			if (y < 7) {
-				const xbl = __tsover_sub(x, dir);
-				const xbr = __tsover_add(x, dir);
-				if (xbl >= 0) {
-					if (xbl < 8) enext[xbl] = __tsover_add(enext[xbl], __tsover_mul(e, .1875));
-				}
-				enext[x] = __tsover_add(enext[x], __tsover_mul(e, .3125));
-				if (xbr >= 0) {
-					if (xbr < 8) enext[xbr] = __tsover_add(enext[xbr], __tsover_mul(e, .0625));
-				}
-			}
-		}
-		for (let k = 0; k < 8; k++) {
-			ecur[k] = enext[k];
-			enext[k] = f32(0);
-		}
-	}
-	return result;
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "lum"
-			},
-			{
-				"type": "i",
-				"name": "lic"
-			},
-			{
-				"type": "i",
-				"name": "threshold"
-			},
-			{
-				"type": "i",
-				"name": "spread"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"thr",
-				[
-					1,
-					[5, "0.5"],
-					"-",
-					[
-						1,
-						"threshold",
-						"-",
-						[5, "0.5"]
-					]
-				]
-			],
-			[
-				13,
-				"ecur",
-				[
-					6,
-					[
-						6,
-						"d.arrayOf",
-						["d.f32", [5, "8"]]
-					],
-					[]
-				]
-			],
-			[
-				13,
-				"enext",
-				[
-					6,
-					[
-						6,
-						"d.arrayOf",
-						["d.f32", [5, "8"]]
-					],
-					[]
-				]
-			],
-			[
-				13,
-				"licInt",
-				[
-					6,
-					"d.i32",
-					["lic"]
-				]
-			],
-			[
-				12,
-				"result",
-				[
-					6,
-					"d.f32",
-					[[5, "0"]]
-				]
-			],
-			[
-				14,
-				[
-					12,
-					"y",
-					[5, "0"]
-				],
-				[
-					1,
-					"y",
-					"<",
-					[5, "8"]
-				],
-				[
-					102,
-					"++",
-					"y"
-				],
-				[0, [
-					[
-						13,
-						"ltr",
-						[
-							1,
-							[
-								1,
-								"y",
-								"&",
-								[5, "1"]
-							],
-							"===",
-							[5, "0"]
-						]
-					],
-					[
-						14,
-						[
-							12,
-							"xi",
-							[5, "0"]
-						],
-						[
-							1,
-							"xi",
-							"<",
-							[5, "8"]
-						],
-						[
-							102,
-							"++",
-							"xi"
-						],
-						[0, [
-							[
-								13,
-								"x",
-								[
-									6,
-									"std.select",
-									[
-										[
-											1,
-											[5, "7"],
-											"-",
-											"xi"
-										],
-										"xi",
-										"ltr"
-									]
-								]
-							],
-							[
-								13,
-								"idx",
-								[
-									1,
-									[
-										1,
-										"y",
-										"*",
-										[5, "8"]
-									],
-									"+",
-									"x"
-								]
-							],
-							[
-								13,
-								"val",
-								[
-									1,
-									[
-										8,
-										"lum",
-										"idx"
-									],
-									"+",
-									[
-										8,
-										"ecur",
-										"x"
-									]
-								]
-							],
-							[
-								13,
-								"qv",
-								[
-									6,
-									"std.step",
-									["thr", "val"]
-								]
-							],
-							[
-								2,
-								"result",
-								"=",
-								[
-									6,
-									"std.select",
-									[
-										"result",
-										"qv",
-										[
-											1,
-											"idx",
-											"===",
-											"licInt"
-										]
-									]
-								]
-							],
-							[
-								13,
-								"e",
-								[
-									1,
-									[
-										1,
-										"val",
-										"-",
-										"qv"
-									],
-									"*",
-									"spread"
-								]
-							],
-							[
-								13,
-								"dir",
-								[
-									6,
-									"std.select",
-									[
-										[
-											4,
-											"-",
-											[5, "1"]
-										],
-										[5, "1"],
-										"ltr"
-									]
-								]
-							],
-							[
-								13,
-								"xr",
-								[
-									1,
-									"x",
-									"+",
-									"dir"
-								]
-							],
-							[
-								11,
-								[
-									1,
-									"xr",
-									">=",
-									[5, "0"]
-								],
-								[0, [[
-									11,
-									[
-										1,
-										"xr",
-										"<",
-										[5, "8"]
-									],
-									[0, [[
-										2,
-										[
-											8,
-											"ecur",
-											"xr"
-										],
-										"=",
-										[
-											1,
-											[
-												8,
-												"ecur",
-												"xr"
-											],
-											"+",
-											[
-												1,
-												"e",
-												"*",
-												[5, "0.4375"]
-											]
-										]
-									]]]
-								]]]
-							],
-							[
-								11,
-								[
-									1,
-									"y",
-									"<",
-									[5, "7"]
-								],
-								[0, [
-									[
-										13,
-										"xbl",
-										[
-											1,
-											"x",
-											"-",
-											"dir"
-										]
-									],
-									[
-										13,
-										"xbr",
-										[
-											1,
-											"x",
-											"+",
-											"dir"
-										]
-									],
-									[
-										11,
-										[
-											1,
-											"xbl",
-											">=",
-											[5, "0"]
-										],
-										[0, [[
-											11,
-											[
-												1,
-												"xbl",
-												"<",
-												[5, "8"]
-											],
-											[0, [[
-												2,
-												[
-													8,
-													"enext",
-													"xbl"
-												],
-												"=",
-												[
-													1,
-													[
-														8,
-														"enext",
-														"xbl"
-													],
-													"+",
-													[
-														1,
-														"e",
-														"*",
-														[5, "0.1875"]
-													]
-												]
-											]]]
-										]]]
-									],
-									[
-										2,
-										[
-											8,
-											"enext",
-											"x"
-										],
-										"=",
-										[
-											1,
-											[
-												8,
-												"enext",
-												"x"
-											],
-											"+",
-											[
-												1,
-												"e",
-												"*",
-												[5, "0.3125"]
-											]
-										]
-									],
-									[
-										11,
-										[
-											1,
-											"xbr",
-											">=",
-											[5, "0"]
-										],
-										[0, [[
-											11,
-											[
-												1,
-												"xbr",
-												"<",
-												[5, "8"]
-											],
-											[0, [[
-												2,
-												[
-													8,
-													"enext",
-													"xbr"
-												],
-												"=",
-												[
-													1,
-													[
-														8,
-														"enext",
-														"xbr"
-													],
-													"+",
-													[
-														1,
-														"e",
-														"*",
-														[5, "0.0625"]
-													]
-												]
-											]]]
-										]]]
-									]
-								]]
-							]
-						]]
-					],
-					[
-						14,
-						[
-							12,
-							"k",
-							[5, "0"]
-						],
-						[
-							1,
-							"k",
-							"<",
-							[5, "8"]
-						],
-						[
-							102,
-							"++",
-							"k"
-						],
-						[0, [[
-							2,
-							[
-								8,
-								"ecur",
-								"k"
-							],
-							"=",
-							[
-								8,
-								"enext",
-								"k"
-							]
-						], [
-							2,
-							[
-								8,
-								"enext",
-								"k"
-							],
-							"=",
-							[
-								6,
-								"d.f32",
-								[[5, "0"]]
-							]
-						]]]
-					]
-				]]
-			],
-			[10, "result"]
-		]]
-	},
-	externals: {
-		"d.arrayOf": () => arrayOf,
-		"d.f32": () => f32,
-		"d.i32": () => i32,
-		"std.select": () => select,
-		"std.step": () => step
-	}
-}) && $.f)({}));
-const ditherComposeCustom = typegpu_default.fn([
-	vec4f,
-	vec4f,
-	f32
-], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((colorA, colorB, ditherResult) => {
-	"use gpu";
-	const rgb = mix(vec3f(colorA.x, colorA.y, colorA.z), vec3f(colorB.x, colorB.y, colorB.z), vec3f(ditherResult));
-	const a = mix(colorA.w, colorB.w, ditherResult);
-	return vec4f(rgb.x, rgb.y, rgb.z, a);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "colorA"
-			},
-			{
-				"type": "i",
-				"name": "colorB"
-			},
-			{
-				"type": "i",
-				"name": "ditherResult"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"rgb",
-				[
-					6,
-					"std.mix",
-					[
-						[
-							6,
-							"d.vec3f",
-							[
-								[
-									7,
-									"colorA",
-									"x"
-								],
-								[
-									7,
-									"colorA",
-									"y"
-								],
-								[
-									7,
-									"colorA",
-									"z"
-								]
-							]
-						],
-						[
-							6,
-							"d.vec3f",
-							[
-								[
-									7,
-									"colorB",
-									"x"
-								],
-								[
-									7,
-									"colorB",
-									"y"
-								],
-								[
-									7,
-									"colorB",
-									"z"
-								]
-							]
-						],
-						[
-							6,
-							"d.vec3f",
-							["ditherResult"]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"a",
-				[
-					6,
-					"std.mix",
-					[
-						[
-							7,
-							"colorA",
-							"w"
-						],
-						[
-							7,
-							"colorB",
-							"w"
-						],
-						"ditherResult"
-					]
-				]
-			],
-			[10, [
-				6,
-				"d.vec4f",
-				[
-					[
-						7,
-						"rgb",
-						"x"
-					],
-					[
-						7,
-						"rgb",
-						"y"
-					],
-					[
-						7,
-						"rgb",
-						"z"
-					],
-					"a"
-				]
-			]]
-		]]
-	},
-	externals: {
-		"std.mix": () => mix,
-		"d.vec3f": () => vec3f,
-		"d.vec4f": () => vec4f
-	}
-}) && $.f)({}));
-const ditherComposeSource = typegpu_default.fn([vec4f, f32], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sourceColor, ditherResult) => {
-	"use gpu";
-	const rgb = vec3f(sourceColor.x, sourceColor.y, sourceColor.z);
-	const out = mix(rgb.mul(.3), min(rgb.mul(1.3), vec3f(1, 1, 1)), vec3f(ditherResult));
-	return vec4f(out.x, out.y, out.z, sourceColor.w);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "sourceColor"
-		}, {
-			"type": "i",
-			"name": "ditherResult"
-		}],
-		"body": [0, [
-			[
-				13,
-				"rgb",
-				[
-					6,
-					"d.vec3f",
-					[
-						[
-							7,
-							"sourceColor",
-							"x"
-						],
-						[
-							7,
-							"sourceColor",
-							"y"
-						],
-						[
-							7,
-							"sourceColor",
-							"z"
-						]
-					]
-				]
-			],
-			[
-				13,
-				"dark",
-				[
-					6,
-					[
-						7,
-						"rgb",
-						"mul"
-					],
-					[[5, "0.3"]]
-				]
-			],
-			[
-				13,
-				"bright",
-				[
-					6,
-					"std.min",
-					[[
-						6,
-						[
-							7,
-							"rgb",
-							"mul"
-						],
-						[[5, "1.3"]]
-					], [
-						6,
-						"d.vec3f",
-						[
-							[5, "1"],
-							[5, "1"],
-							[5, "1"]
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"out",
-				[
-					6,
-					"std.mix",
-					[
-						"dark",
-						"bright",
-						[
-							6,
-							"d.vec3f",
-							["ditherResult"]
-						]
-					]
-				]
-			],
-			[10, [
-				6,
-				"d.vec4f",
-				[
-					[
-						7,
-						"out",
-						"x"
-					],
-					[
-						7,
-						"out",
-						"y"
-					],
-					[
-						7,
-						"out",
-						"z"
-					],
-					[
-						7,
-						"sourceColor",
-						"w"
-					]
-				]
-			]]
-		]]
-	},
-	externals: {
-		"d.vec3f": () => vec3f,
-		"std.min": () => min,
-		"std.mix": () => mix,
-		"d.vec4f": () => vec4f
-	}
-}) && $.f)({}));
-const componentDefinition = defineRttFilter({
-	name: "Dither",
-	category: "Stylize",
-	description: "Dithering effect with multiple pattern options",
-	blendWithChildren: false,
-	boundingBoxDeclaration: { aspectRatio: null },
-	props: {
-		pattern: {
-			default: "bayer4",
-			transform: transformPattern,
-			compileTime: true,
-			description: "Dithering pattern algorithm",
-			ui: {
-				type: "select",
-				options: [
-					{
-						label: "Bayer 2x2",
-						value: "bayer2"
-					},
-					{
-						label: "Bayer 4x4",
-						value: "bayer4"
-					},
-					{
-						label: "Bayer 8x8",
-						value: "bayer8"
-					},
-					{
-						label: "Clustered Dot",
-						value: "clusteredDot"
-					},
-					{
-						label: "Blue Noise",
-						value: "blueNoise"
-					},
-					{
-						label: "White Noise",
-						value: "whiteNoise"
-					},
-					{
-						label: "Floyd-Steinberg",
-						value: "floydSteinberg"
-					}
-				],
-				label: "Pattern",
-				group: "Effect"
-			}
-		},
-		pixelSize: {
-			default: 4,
-			description: "Size of dithering pixels",
-			ui: {
-				type: "range",
-				min: 1,
-				max: 20,
-				step: 1,
-				label: "Pixel Size",
-				group: "Effect"
-			}
-		},
-		threshold: {
-			default: .5,
-			description: "Luminance threshold for dithering",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Threshold",
-				group: "Effect"
-			}
-		},
-		spread: {
-			default: 1,
-			description: "How much of the luminance range participates in dithering (lower = more solid areas)",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Spread",
-				group: "Effect"
-			}
-		},
-		colorMode: {
-			default: "custom",
-			transform: transformColorMode,
-			compileTime: true,
-			description: "How colors are determined",
-			ui: {
-				type: "select",
-				options: [{
-					label: "Custom Colors",
-					value: "custom"
-				}, {
-					label: "Source Colors",
-					value: "source"
-				}],
-				label: "Color Mode",
-				group: "Colors"
-			}
-		},
-		colorA: {
-			default: "transparent",
-			transform: transformColor,
-			description: "Dark color for dithering",
-			ui: {
-				type: "color",
-				label: "Dark Color",
-				condition: { colorMode: "custom" },
-				group: "Colors"
-			}
-		},
-		colorB: {
-			default: "#ffffff",
-			transform: transformColor,
-			description: "Light color for dithering",
-			ui: {
-				type: "color",
-				label: "Light Color",
-				condition: { colorMode: "custom" },
-				group: "Colors"
-			}
-		}
-	},
-	resultAlpha: "straight",
-	build: ({ sampleStraight, ctx, uniforms, propValues }) => {
-		const gridRes = ctx.logicalViewportSize;
-		const pixelSize = uniforms.pixelSize;
-		const threshold = uniforms.threshold;
-		const spread = uniforms.spread;
-		const coord = call(ditherCoord, "ditherCoord", [
-			ctx.uv,
-			gridRes,
-			pixelSize
-		]);
-		const sourceColor = sampleStraight(call(ditherPixUV, "ditherPixUV", [
-			coord,
-			pixelSize,
-			gridRes
-		]));
-		const luminance = call(ditherLuma, "ditherLuma", [sourceColor]);
-		const pattern = patternModeOf(propValues.pattern);
-		let ditherResult;
-		if (pattern === 6) {
-			const blockOrigin = call(ditherBlockOrigin, "ditherBlockOrigin", [coord]);
-			const lic = call(ditherLocalCellIndex, "ditherLocalCellIndex", [coord, blockOrigin]);
-			const lums = [];
-			for (let ly = 0; ly < 8; ly++) for (let lx = 0; lx < 8; lx++) {
-				const cellUV = call(ditherCellUV, "ditherCellUV", [
-					blockOrigin,
-					floatE(lx),
-					floatE(ly),
-					pixelSize,
-					gridRes
-				]);
-				lums.push(call(ditherLuma, "ditherLuma", [sampleStraight(cellUV)]));
-			}
-			ditherResult = call(ditherFloydSteinberg, "ditherFloydSteinberg", [
-				arrayExpr("f32", lums),
-				lic,
-				threshold,
-				spread
-			]);
-		} else {
-			const periodic = call(ditherPeriodic, "ditherPeriodic", [coord]);
-			let ditherValue;
-			switch (pattern) {
-				case 0:
-					ditherValue = periodic.member("x");
-					break;
-				case 1:
-					ditherValue = periodic.member("y");
-					break;
-				case 2:
-					ditherValue = periodic.member("z");
-					break;
-				case 3:
-					ditherValue = periodic.member("w");
-					break;
-				case 4:
-					ditherValue = call(ditherBlueNoise, "ditherBlueNoise", [coord]);
-					break;
-				default: ditherValue = call(ditherWhiteNoise, "ditherWhiteNoise", [coord]);
-			}
-			ditherResult = call(ditherOrderedResult, "ditherOrderedResult", [
-				ditherValue,
-				luminance,
-				threshold,
-				spread
-			]);
-		}
-		if (colorModeOf(propValues.colorMode) === 0) return call(ditherComposeCustom, "ditherComposeCustom", [
-			uniforms.colorA,
-			uniforms.colorB,
-			ditherResult
-		]);
-		return call(ditherComposeSource, "ditherComposeSource", [sourceColor, ditherResult]);
-	}
-});
-var Dither_default = componentDefinition;
-export { ditherBlueNoise as a, ditherComposeSource as c, ditherLocalCellIndex as d, ditherLuma as f, ditherWhiteNoise as g, ditherPixUV as h, ditherBlockOrigin as i, ditherCoord as l, ditherPeriodic as m, componentDefinition as n, ditherCellUV as o, ditherOrderedResult as p, ditherBayerQuad as r, ditherComposeCustom as s, Dither_default as t, ditherFloydSteinberg as u };