shaders 3.2.464 → 3.2.466

package/dist/core/aa-BfXCHL6-.js

@@ -1,915 +0,0 @@
-import { Fn as min, Jn as vec2f, Kn as step, Mn as fract, Pn as max, Tn as clamp, Wn as smoothstep, hr as f32, jn as floor, mn as typegpu_default, xn as abs } from "./lower-z2vuXP8M.js";
-import { C as dpdx, w as dpdy } from "./noise-B3Oq1k3_.js";
-const footprint1 = typegpu_default.fn([f32, f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x, softness) => {
-	"use gpu";
-	const baseW = max(abs(dpdx(x)), abs(dpdy(x)));
-	return max(__tsover_add(baseW, softness), 1e-5);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "x"
-		}, {
-			"type": "i",
-			"name": "softness"
-		}],
-		"body": [0, [[
-			13,
-			"baseW",
-			[
-				6,
-				"std.max",
-				[[
-					6,
-					"std.abs",
-					[[
-						6,
-						"std.dpdx",
-						["x"]
-					]]
-				], [
-					6,
-					"std.abs",
-					[[
-						6,
-						"std.dpdy",
-						["x"]
-					]]
-				]]
-			]
-		], [10, [
-			6,
-			"std.max",
-			[[
-				1,
-				"baseW",
-				"+",
-				"softness"
-			], [5, "0.00001"]]
-		]]]]
-	},
-	externals: {
-		"std.max": () => max,
-		"std.abs": () => abs,
-		"std.dpdx": () => dpdx,
-		"std.dpdy": () => dpdy
-	}
-}) && $.f)({}));
-const footprint2 = typegpu_default.fn([vec2f, f32], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p, softness) => {
-	"use gpu";
-	const dpx = dpdx(p);
-	const dpy = dpdy(p);
-	const baseW = vec2f(max(abs(dpx.x), abs(dpy.x)), max(abs(dpx.y), abs(dpy.y)));
-	return vec2f(max(__tsover_add(baseW.x, softness), 1e-5), max(__tsover_add(baseW.y, softness), 1e-5));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "p"
-		}, {
-			"type": "i",
-			"name": "softness"
-		}],
-		"body": [0, [
-			[
-				13,
-				"dpx",
-				[
-					6,
-					"std.dpdx",
-					["p"]
-				]
-			],
-			[
-				13,
-				"dpy",
-				[
-					6,
-					"std.dpdy",
-					["p"]
-				]
-			],
-			[
-				13,
-				"baseW",
-				[
-					6,
-					"d.vec2f",
-					[[
-						6,
-						"std.max",
-						[[
-							6,
-							"std.abs",
-							[[
-								7,
-								"dpx",
-								"x"
-							]]
-						], [
-							6,
-							"std.abs",
-							[[
-								7,
-								"dpy",
-								"x"
-							]]
-						]]
-					], [
-						6,
-						"std.max",
-						[[
-							6,
-							"std.abs",
-							[[
-								7,
-								"dpx",
-								"y"
-							]]
-						], [
-							6,
-							"std.abs",
-							[[
-								7,
-								"dpy",
-								"y"
-							]]
-						]]
-					]]
-				]
-			],
-			[10, [
-				6,
-				"d.vec2f",
-				[[
-					6,
-					"std.max",
-					[[
-						1,
-						[
-							7,
-							"baseW",
-							"x"
-						],
-						"+",
-						"softness"
-					], [5, "0.00001"]]
-				], [
-					6,
-					"std.max",
-					[[
-						1,
-						[
-							7,
-							"baseW",
-							"y"
-						],
-						"+",
-						"softness"
-					], [5, "0.00001"]]
-				]]
-			]]
-		]]
-	},
-	externals: {
-		"std.dpdx": () => dpdx,
-		"std.dpdy": () => dpdy,
-		"d.vec2f": () => vec2f,
-		"std.max": () => max,
-		"std.abs": () => abs
-	}
-}) && $.f)({}));
-const quilezStepFilter = typegpu_default.fn([
-	f32,
-	f32,
-	f32
-], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p, w, threshold) => {
-	"use gpu";
-	const a = __tsover_add(p, __tsover_mul(w, .5));
-	const b = __tsover_sub(p, __tsover_mul(w, .5));
-	const oneMinusThreshold = __tsover_sub(1, threshold);
-	const Fa = __tsover_add(__tsover_mul(floor(a), oneMinusThreshold), max(__tsover_sub(fract(a), threshold), 0));
-	const Fb = __tsover_add(__tsover_mul(floor(b), oneMinusThreshold), max(__tsover_sub(fract(b), threshold), 0));
-	return clamp(__tsover_div(__tsover_sub(Fa, Fb), w), 0, 1);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "p"
-			},
-			{
-				"type": "i",
-				"name": "w"
-			},
-			{
-				"type": "i",
-				"name": "threshold"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"a",
-				[
-					1,
-					"p",
-					"+",
-					[
-						1,
-						"w",
-						"*",
-						[5, "0.5"]
-					]
-				]
-			],
-			[
-				13,
-				"b",
-				[
-					1,
-					"p",
-					"-",
-					[
-						1,
-						"w",
-						"*",
-						[5, "0.5"]
-					]
-				]
-			],
-			[
-				13,
-				"oneMinusThreshold",
-				[
-					1,
-					[5, "1"],
-					"-",
-					"threshold"
-				]
-			],
-			[
-				13,
-				"Fa",
-				[
-					1,
-					[
-						1,
-						[
-							6,
-							"std.floor",
-							["a"]
-						],
-						"*",
-						"oneMinusThreshold"
-					],
-					"+",
-					[
-						6,
-						"std.max",
-						[[
-							1,
-							[
-								6,
-								"std.fract",
-								["a"]
-							],
-							"-",
-							"threshold"
-						], [5, "0"]]
-					]
-				]
-			],
-			[
-				13,
-				"Fb",
-				[
-					1,
-					[
-						1,
-						[
-							6,
-							"std.floor",
-							["b"]
-						],
-						"*",
-						"oneMinusThreshold"
-					],
-					"+",
-					[
-						6,
-						"std.max",
-						[[
-							1,
-							[
-								6,
-								"std.fract",
-								["b"]
-							],
-							"-",
-							"threshold"
-						], [5, "0"]]
-					]
-				]
-			],
-			[10, [
-				6,
-				"std.clamp",
-				[
-					[
-						1,
-						[
-							1,
-							"Fa",
-							"-",
-							"Fb"
-						],
-						"/",
-						"w"
-					],
-					[5, "0"],
-					[5, "1"]
-				]
-			]]
-		]]
-	},
-	externals: {
-		"std.floor": () => floor,
-		"std.max": () => max,
-		"std.fract": () => fract,
-		"std.clamp": () => clamp
-	}
-}) && $.f)({}));
-const quilezLineFilterAxis = typegpu_default.fn([
-	f32,
-	f32,
-	f32
-], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p, w, N) => {
-	"use gpu";
-	const a = __tsover_add(p, __tsover_mul(w, .5));
-	const b = __tsover_sub(p, __tsover_mul(w, .5));
-	return __tsover_div(__tsover_sub(__tsover_sub(__tsover_add(floor(a), min(__tsover_mul(fract(a), N), 1)), floor(b)), min(__tsover_mul(fract(b), N), 1)), __tsover_mul(N, w));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "p"
-			},
-			{
-				"type": "i",
-				"name": "w"
-			},
-			{
-				"type": "i",
-				"name": "N"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"a",
-				[
-					1,
-					"p",
-					"+",
-					[
-						1,
-						"w",
-						"*",
-						[5, "0.5"]
-					]
-				]
-			],
-			[
-				13,
-				"b",
-				[
-					1,
-					"p",
-					"-",
-					[
-						1,
-						"w",
-						"*",
-						[5, "0.5"]
-					]
-				]
-			],
-			[10, [
-				1,
-				[
-					1,
-					[
-						1,
-						[
-							1,
-							[
-								6,
-								"std.floor",
-								["a"]
-							],
-							"+",
-							[
-								6,
-								"std.min",
-								[[
-									1,
-									[
-										6,
-										"std.fract",
-										["a"]
-									],
-									"*",
-									"N"
-								], [5, "1"]]
-							]
-						],
-						"-",
-						[
-							6,
-							"std.floor",
-							["b"]
-						]
-					],
-					"-",
-					[
-						6,
-						"std.min",
-						[[
-							1,
-							[
-								6,
-								"std.fract",
-								["b"]
-							],
-							"*",
-							"N"
-						], [5, "1"]]
-					]
-				],
-				"/",
-				[
-					1,
-					"N",
-					"*",
-					"w"
-				]
-			]]
-		]]
-	},
-	externals: {
-		"std.floor": () => floor,
-		"std.min": () => min,
-		"std.fract": () => fract
-	}
-}) && $.f)({}));
-const quilezCheckerFilter = typegpu_default.fn([vec2f, vec2f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p, w) => {
-	"use gpu";
-	const aHalf = vec2f(__tsover_mul(w.x, .5), __tsover_mul(w.y, .5));
-	const minusSideX = abs(__tsover_sub(fract(__tsover_mul(__tsover_sub(p.x, aHalf.x), .5)), .5));
-	const minusSideY = abs(__tsover_sub(fract(__tsover_mul(__tsover_sub(p.y, aHalf.y), .5)), .5));
-	const plusSideX = abs(__tsover_sub(fract(__tsover_mul(__tsover_add(p.x, aHalf.x), .5)), .5));
-	const plusSideY = abs(__tsover_sub(fract(__tsover_mul(__tsover_add(p.y, aHalf.y), .5)), .5));
-	const iX = __tsover_div(__tsover_mul(__tsover_sub(minusSideX, plusSideX), 2), w.x);
-	const iY = __tsover_div(__tsover_mul(__tsover_sub(minusSideY, plusSideY), 2), w.y);
-	return clamp(__tsover_sub(.5, __tsover_mul(__tsover_mul(iX, iY), .5)), 0, 1);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "p"
-		}, {
-			"type": "i",
-			"name": "w"
-		}],
-		"body": [0, [
-			[
-				13,
-				"aHalf",
-				[
-					6,
-					"d.vec2f",
-					[[
-						1,
-						[
-							7,
-							"w",
-							"x"
-						],
-						"*",
-						[5, "0.5"]
-					], [
-						1,
-						[
-							7,
-							"w",
-							"y"
-						],
-						"*",
-						[5, "0.5"]
-					]]
-				]
-			],
-			[
-				13,
-				"minusSideX",
-				[
-					6,
-					"std.abs",
-					[[
-						1,
-						[
-							6,
-							"std.fract",
-							[[
-								1,
-								[
-									1,
-									[
-										7,
-										"p",
-										"x"
-									],
-									"-",
-									[
-										7,
-										"aHalf",
-										"x"
-									]
-								],
-								"*",
-								[5, "0.5"]
-							]]
-						],
-						"-",
-						[5, "0.5"]
-					]]
-				]
-			],
-			[
-				13,
-				"minusSideY",
-				[
-					6,
-					"std.abs",
-					[[
-						1,
-						[
-							6,
-							"std.fract",
-							[[
-								1,
-								[
-									1,
-									[
-										7,
-										"p",
-										"y"
-									],
-									"-",
-									[
-										7,
-										"aHalf",
-										"y"
-									]
-								],
-								"*",
-								[5, "0.5"]
-							]]
-						],
-						"-",
-						[5, "0.5"]
-					]]
-				]
-			],
-			[
-				13,
-				"plusSideX",
-				[
-					6,
-					"std.abs",
-					[[
-						1,
-						[
-							6,
-							"std.fract",
-							[[
-								1,
-								[
-									1,
-									[
-										7,
-										"p",
-										"x"
-									],
-									"+",
-									[
-										7,
-										"aHalf",
-										"x"
-									]
-								],
-								"*",
-								[5, "0.5"]
-							]]
-						],
-						"-",
-						[5, "0.5"]
-					]]
-				]
-			],
-			[
-				13,
-				"plusSideY",
-				[
-					6,
-					"std.abs",
-					[[
-						1,
-						[
-							6,
-							"std.fract",
-							[[
-								1,
-								[
-									1,
-									[
-										7,
-										"p",
-										"y"
-									],
-									"+",
-									[
-										7,
-										"aHalf",
-										"y"
-									]
-								],
-								"*",
-								[5, "0.5"]
-							]]
-						],
-						"-",
-						[5, "0.5"]
-					]]
-				]
-			],
-			[
-				13,
-				"iX",
-				[
-					1,
-					[
-						1,
-						[
-							1,
-							"minusSideX",
-							"-",
-							"plusSideX"
-						],
-						"*",
-						[5, "2"]
-					],
-					"/",
-					[
-						7,
-						"w",
-						"x"
-					]
-				]
-			],
-			[
-				13,
-				"iY",
-				[
-					1,
-					[
-						1,
-						[
-							1,
-							"minusSideY",
-							"-",
-							"plusSideY"
-						],
-						"*",
-						[5, "2"]
-					],
-					"/",
-					[
-						7,
-						"w",
-						"y"
-					]
-				]
-			],
-			[10, [
-				6,
-				"std.clamp",
-				[
-					[
-						1,
-						[5, "0.5"],
-						"-",
-						[
-							1,
-							[
-								1,
-								"iX",
-								"*",
-								"iY"
-							],
-							"*",
-							[5, "0.5"]
-						]
-					],
-					[5, "0"],
-					[5, "1"]
-				]
-			]]
-		]]
-	},
-	externals: {
-		"d.vec2f": () => vec2f,
-		"std.abs": () => abs,
-		"std.fract": () => fract,
-		"std.clamp": () => clamp
-	}
-}) && $.f)({}));
-const lineMaskFromField = typegpu_default.fn([
-	f32,
-	f32,
-	f32,
-	f32
-], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((field, lineWidth, lo, hi) => {
-	"use gpu";
-	return __tsover_mul(__tsover_sub(1, smoothstep(lo, hi, field)), step(1e-4, lineWidth));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "field"
-			},
-			{
-				"type": "i",
-				"name": "lineWidth"
-			},
-			{
-				"type": "i",
-				"name": "lo"
-			},
-			{
-				"type": "i",
-				"name": "hi"
-			}
-		],
-		"body": [0, [[10, [
-			1,
-			[
-				1,
-				[5, "1"],
-				"-",
-				[
-					6,
-					"std.smoothstep",
-					[
-						"lo",
-						"hi",
-						"field"
-					]
-				]
-			],
-			"*",
-			[
-				6,
-				"std.step",
-				[[5, "0.0001"], "lineWidth"]
-			]
-		]]]]
-	},
-	externals: {
-		"std.smoothstep": () => smoothstep,
-		"std.step": () => step
-	}
-}) && $.f)({}));
-const bandMask = typegpu_default.fn([
-	f32,
-	f32,
-	f32
-], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x, lo, hi) => {
-	"use gpu";
-	return __tsover_mul(smoothstep(lo, hi, x), smoothstep(lo, hi, __tsover_sub(1, x)));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "x"
-			},
-			{
-				"type": "i",
-				"name": "lo"
-			},
-			{
-				"type": "i",
-				"name": "hi"
-			}
-		],
-		"body": [0, [[10, [
-			1,
-			[
-				6,
-				"std.smoothstep",
-				[
-					"lo",
-					"hi",
-					"x"
-				]
-			],
-			"*",
-			[
-				6,
-				"std.smoothstep",
-				[
-					"lo",
-					"hi",
-					[
-						1,
-						[5, "1"],
-						"-",
-						"x"
-					]
-				]
-			]
-		]]]]
-	},
-	externals: { "std.smoothstep": () => smoothstep }
-}) && $.f)({}));
-const discCoverage = typegpu_default.fn([
-	f32,
-	f32,
-	f32
-], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((dist, radius, footprint) => {
-	"use gpu";
-	return __tsover_sub(1, smoothstep(__tsover_sub(radius, __tsover_mul(footprint, .5)), radius, dist));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "dist"
-			},
-			{
-				"type": "i",
-				"name": "radius"
-			},
-			{
-				"type": "i",
-				"name": "footprint"
-			}
-		],
-		"body": [0, [[10, [
-			1,
-			[5, "1"],
-			"-",
-			[
-				6,
-				"std.smoothstep",
-				[
-					[
-						1,
-						"radius",
-						"-",
-						[
-							1,
-							"footprint",
-							"*",
-							[5, "0.5"]
-						]
-					],
-					"radius",
-					"dist"
-				]
-			]
-		]]]]
-	},
-	externals: { "std.smoothstep": () => smoothstep }
-}) && $.f)({}));
-export { lineMaskFromField as a, quilezStepFilter as c, footprint2 as i, discCoverage as n, quilezCheckerFilter as o, footprint1 as r, quilezLineFilterAxis as s, bandMask as t };