shaders 3.2.474 → 4.0.0

package/dist/core/media-DXUY3ltG.js

@@ -1,832 +0,0 @@
-import { Gn as typegpu_default, Mr as vec4f, Or as vec2f, Tt as srgbToLinear, ct as call, er as select, gr as min, hr as max, jr as vec3f, qr as f32 } from "./lower-Bd2jez_2.js";
-import { i as decodeImageSource, n as createUrlSourceLoader, r as createVideoElementSource, s as registerNaturalSize, t as createSwappableMediaTexture } from "./mediaLifecycle-BTPb5i1-.js";
-const scaleCover = typegpu_default.fn([vec2f, vec2f], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((dims, vp) => {
-	"use gpu";
-	const aspect = __tsover_div(dims.x, dims.y);
-	const viewportAspect = __tsover_div(vp.x, vp.y);
-	const coverScale = max(__tsover_div(viewportAspect, aspect), 1);
-	return vec2f(__tsover_mul(__tsover_div(aspect, viewportAspect), coverScale), coverScale);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "dims"
-		}, {
-			"type": "i",
-			"name": "vp"
-		}],
-		"body": [0, [
-			[
-				13,
-				"aspect",
-				[
-					1,
-					[
-						7,
-						"dims",
-						"x"
-					],
-					"/",
-					[
-						7,
-						"dims",
-						"y"
-					]
-				]
-			],
-			[
-				13,
-				"viewportAspect",
-				[
-					1,
-					[
-						7,
-						"vp",
-						"x"
-					],
-					"/",
-					[
-						7,
-						"vp",
-						"y"
-					]
-				]
-			],
-			[
-				13,
-				"coverScale",
-				[
-					6,
-					"std.max",
-					[[
-						1,
-						"viewportAspect",
-						"/",
-						"aspect"
-					], [5, "1"]]
-				]
-			],
-			[10, [
-				6,
-				"d.vec2f",
-				[[
-					1,
-					[
-						1,
-						"aspect",
-						"/",
-						"viewportAspect"
-					],
-					"*",
-					"coverScale"
-				], "coverScale"]
-			]]
-		]]
-	},
-	externals: {
-		"std.max": () => max,
-		"d.vec2f": () => vec2f
-	}
-}) && $.f)({}));
-const scaleContain = typegpu_default.fn([vec2f, vec2f], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((dims, vp) => {
-	"use gpu";
-	const aspect = __tsover_div(dims.x, dims.y);
-	const viewportAspect = __tsover_div(vp.x, vp.y);
-	const containScale = min(__tsover_div(viewportAspect, aspect), 1);
-	return vec2f(__tsover_mul(__tsover_div(aspect, viewportAspect), containScale), containScale);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "dims"
-		}, {
-			"type": "i",
-			"name": "vp"
-		}],
-		"body": [0, [
-			[
-				13,
-				"aspect",
-				[
-					1,
-					[
-						7,
-						"dims",
-						"x"
-					],
-					"/",
-					[
-						7,
-						"dims",
-						"y"
-					]
-				]
-			],
-			[
-				13,
-				"viewportAspect",
-				[
-					1,
-					[
-						7,
-						"vp",
-						"x"
-					],
-					"/",
-					[
-						7,
-						"vp",
-						"y"
-					]
-				]
-			],
-			[
-				13,
-				"containScale",
-				[
-					6,
-					"std.min",
-					[[
-						1,
-						"viewportAspect",
-						"/",
-						"aspect"
-					], [5, "1"]]
-				]
-			],
-			[10, [
-				6,
-				"d.vec2f",
-				[[
-					1,
-					[
-						1,
-						"aspect",
-						"/",
-						"viewportAspect"
-					],
-					"*",
-					"containScale"
-				], "containScale"]
-			]]
-		]]
-	},
-	externals: {
-		"std.min": () => min,
-		"d.vec2f": () => vec2f
-	}
-}) && $.f)({}));
-const scaleFill = typegpu_default.fn([], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = (() => {
-	"use gpu";
-	return vec2f(1, 1);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [],
-		"body": [0, [[10, [
-			6,
-			"d.vec2f",
-			[[5, "1"], [5, "1"]]
-		]]]]
-	},
-	externals: { "d.vec2f": () => vec2f }
-}) && $.f)({}));
-const scaleScaleDown = typegpu_default.fn([vec2f, vec2f], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((dims, vp) => {
-	"use gpu";
-	const aspect = __tsover_div(dims.x, dims.y);
-	const viewportAspect = __tsover_div(vp.x, vp.y);
-	const scaleDownScale = min(min(__tsover_div(viewportAspect, aspect), 1), min(__tsover_div(vp.x, dims.x), __tsover_div(vp.y, dims.y)));
-	return vec2f(__tsover_mul(__tsover_div(aspect, viewportAspect), scaleDownScale), scaleDownScale);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "dims"
-		}, {
-			"type": "i",
-			"name": "vp"
-		}],
-		"body": [0, [
-			[
-				13,
-				"aspect",
-				[
-					1,
-					[
-						7,
-						"dims",
-						"x"
-					],
-					"/",
-					[
-						7,
-						"dims",
-						"y"
-					]
-				]
-			],
-			[
-				13,
-				"viewportAspect",
-				[
-					1,
-					[
-						7,
-						"vp",
-						"x"
-					],
-					"/",
-					[
-						7,
-						"vp",
-						"y"
-					]
-				]
-			],
-			[
-				13,
-				"containScale",
-				[
-					6,
-					"std.min",
-					[[
-						1,
-						"viewportAspect",
-						"/",
-						"aspect"
-					], [5, "1"]]
-				]
-			],
-			[
-				13,
-				"naturalScale",
-				[
-					6,
-					"std.min",
-					[[
-						1,
-						[
-							7,
-							"vp",
-							"x"
-						],
-						"/",
-						[
-							7,
-							"dims",
-							"x"
-						]
-					], [
-						1,
-						[
-							7,
-							"vp",
-							"y"
-						],
-						"/",
-						[
-							7,
-							"dims",
-							"y"
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"scaleDownScale",
-				[
-					6,
-					"std.min",
-					["containScale", "naturalScale"]
-				]
-			],
-			[10, [
-				6,
-				"d.vec2f",
-				[[
-					1,
-					[
-						1,
-						"aspect",
-						"/",
-						"viewportAspect"
-					],
-					"*",
-					"scaleDownScale"
-				], "scaleDownScale"]
-			]]
-		]]
-	},
-	externals: {
-		"std.min": () => min,
-		"d.vec2f": () => vec2f
-	}
-}) && $.f)({}));
-const scaleNone = typegpu_default.fn([vec2f, vec2f], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((dims, vp) => {
-	"use gpu";
-	const aspect = __tsover_div(dims.x, dims.y);
-	const viewportAspect = __tsover_div(vp.x, vp.y);
-	const noneScale = min(__tsover_div(vp.x, dims.x), __tsover_div(vp.y, dims.y));
-	return vec2f(__tsover_mul(__tsover_div(aspect, viewportAspect), noneScale), noneScale);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "dims"
-		}, {
-			"type": "i",
-			"name": "vp"
-		}],
-		"body": [0, [
-			[
-				13,
-				"aspect",
-				[
-					1,
-					[
-						7,
-						"dims",
-						"x"
-					],
-					"/",
-					[
-						7,
-						"dims",
-						"y"
-					]
-				]
-			],
-			[
-				13,
-				"viewportAspect",
-				[
-					1,
-					[
-						7,
-						"vp",
-						"x"
-					],
-					"/",
-					[
-						7,
-						"vp",
-						"y"
-					]
-				]
-			],
-			[
-				13,
-				"noneScale",
-				[
-					6,
-					"std.min",
-					[[
-						1,
-						[
-							7,
-							"vp",
-							"x"
-						],
-						"/",
-						[
-							7,
-							"dims",
-							"x"
-						]
-					], [
-						1,
-						[
-							7,
-							"vp",
-							"y"
-						],
-						"/",
-						[
-							7,
-							"dims",
-							"y"
-						]
-					]]
-				]
-			],
-			[10, [
-				6,
-				"d.vec2f",
-				[[
-					1,
-					[
-						1,
-						"aspect",
-						"/",
-						"viewportAspect"
-					],
-					"*",
-					"noneScale"
-				], "noneScale"]
-			]]
-		]]
-	},
-	externals: {
-		"std.min": () => min,
-		"d.vec2f": () => vec2f
-	}
-}) && $.f)({}));
-const sampleUV = typegpu_default.fn([vec2f, vec2f], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, uvScale) => {
-	"use gpu";
-	const centeredUV = uv.sub(vec2f(.5, .5));
-	return vec2f(__tsover_div(centeredUV.x, uvScale.x), __tsover_div(centeredUV.y, uvScale.y)).add(vec2f(.5, .5));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "uv"
-		}, {
-			"type": "i",
-			"name": "uvScale"
-		}],
-		"body": [0, [
-			[
-				13,
-				"centeredUV",
-				[
-					6,
-					[
-						7,
-						"uv",
-						"sub"
-					],
-					[[
-						6,
-						"d.vec2f",
-						[[5, "0.5"], [5, "0.5"]]
-					]]
-				]
-			],
-			[
-				13,
-				"scaledUV",
-				[
-					6,
-					"d.vec2f",
-					[[
-						1,
-						[
-							7,
-							"centeredUV",
-							"x"
-						],
-						"/",
-						[
-							7,
-							"uvScale",
-							"x"
-						]
-					], [
-						1,
-						[
-							7,
-							"centeredUV",
-							"y"
-						],
-						"/",
-						[
-							7,
-							"uvScale",
-							"y"
-						]
-					]]
-				]
-			],
-			[10, [
-				6,
-				[
-					7,
-					"scaledUV",
-					"add"
-				],
-				[[
-					6,
-					"d.vec2f",
-					[[5, "0.5"], [5, "0.5"]]
-				]]
-			]]
-		]]
-	},
-	externals: { "d.vec2f": () => vec2f }
-}) && $.f)({}));
-const applyMirror = typegpu_default.fn([vec2f, f32], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, mirror) => {
-	"use gpu";
-	return vec2f(select(uv.x, __tsover_sub(1, uv.x), mirror > 0), uv.y);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "uv"
-		}, {
-			"type": "i",
-			"name": "mirror"
-		}],
-		"body": [0, [[
-			13,
-			"mirroredX",
-			[
-				6,
-				"std.select",
-				[
-					[
-						7,
-						"uv",
-						"x"
-					],
-					[
-						1,
-						[5, "1"],
-						"-",
-						[
-							7,
-							"uv",
-							"x"
-						]
-					],
-					[
-						1,
-						"mirror",
-						">",
-						[5, "0"]
-					]
-				]
-			]
-		], [10, [
-			6,
-			"d.vec2f",
-			["mirroredX", [
-				7,
-				"uv",
-				"y"
-			]]
-		]]]]
-	},
-	externals: {
-		"std.select": () => select,
-		"d.vec2f": () => vec2f
-	}
-}) && $.f)({}));
-const alphaCutLinear = typegpu_default.fn([vec4f, vec2f], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, uv) => {
-	"use gpu";
-	const linear = srgbToLinear(vec3f(color.x, color.y, color.z));
-	const outOfBounds = uv.x < 0 || uv.x > 1 || uv.y < 0 || uv.y > 1;
-	const alpha = select(color.w, 0, outOfBounds);
-	return vec4f(linear.x, linear.y, linear.z, alpha);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "color"
-		}, {
-			"type": "i",
-			"name": "uv"
-		}],
-		"body": [0, [
-			[
-				13,
-				"linear",
-				[
-					6,
-					"srgbToLinear",
-					[[
-						6,
-						"d.vec3f",
-						[
-							[
-								7,
-								"color",
-								"x"
-							],
-							[
-								7,
-								"color",
-								"y"
-							],
-							[
-								7,
-								"color",
-								"z"
-							]
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"outOfBounds",
-				[
-					3,
-					[
-						3,
-						[
-							3,
-							[
-								1,
-								[
-									7,
-									"uv",
-									"x"
-								],
-								"<",
-								[5, "0"]
-							],
-							"||",
-							[
-								1,
-								[
-									7,
-									"uv",
-									"x"
-								],
-								">",
-								[5, "1"]
-							]
-						],
-						"||",
-						[
-							1,
-							[
-								7,
-								"uv",
-								"y"
-							],
-							"<",
-							[5, "0"]
-						]
-					],
-					"||",
-					[
-						1,
-						[
-							7,
-							"uv",
-							"y"
-						],
-						">",
-						[5, "1"]
-					]
-				]
-			],
-			[
-				13,
-				"alpha",
-				[
-					6,
-					"std.select",
-					[
-						[
-							7,
-							"color",
-							"w"
-						],
-						[5, "0"],
-						"outOfBounds"
-					]
-				]
-			],
-			[10, [
-				6,
-				"d.vec4f",
-				[
-					[
-						7,
-						"linear",
-						"x"
-					],
-					[
-						7,
-						"linear",
-						"y"
-					],
-					[
-						7,
-						"linear",
-						"z"
-					],
-					"alpha"
-				]
-			]]
-		]]
-	},
-	externals: {
-		"srgbToLinear": () => srgbToLinear,
-		"d.vec3f": () => vec3f,
-		"std.select": () => select,
-		"d.vec4f": () => vec4f
-	}
-}) && $.f)({}));
-const OBJECT_FIT_MODES = {
-	cover: 0,
-	contain: 1,
-	fill: 2,
-	"scale-down": 3,
-	none: 2
-};
-const OBJECT_FIT_MODES_ALLOW_NONE = {
-	cover: 0,
-	contain: 1,
-	fill: 2,
-	"scale-down": 3,
-	none: 4
-};
-function mediaSurface(opts) {
-	const table = opts.allowNone ? OBJECT_FIT_MODES_ALLOW_NONE : OBJECT_FIT_MODES;
-	const fallback = opts.allowNone ? 0 : 2;
-	const mode = typeof opts.fit === "number" ? opts.fit : table[opts.fit] ?? fallback;
-	const dims = opts.texture.dimensions();
-	let uvScale;
-	if (mode === 1) uvScale = call(scaleContain, "scaleContain", [dims, opts.viewport]);
-	else if (mode === 2) uvScale = call(scaleFill, "scaleFill", []);
-	else if (mode === 3) uvScale = call(scaleScaleDown, "scaleScaleDown", [dims, opts.viewport]);
-	else if (mode === 4 && opts.allowNone) uvScale = call(scaleNone, "scaleNone", [dims, opts.viewport]);
-	else uvScale = call(scaleCover, "scaleCover", [dims, opts.viewport]);
-	const fitUV = call(sampleUV, "mediaSampleUV", [opts.uv, uvScale]);
-	const finalUV = opts.uvPostProcess ? opts.uvPostProcess(fitUV) : fitUV;
-	return call(alphaCutLinear, "mediaAlphaCut", [opts.texture.sample(finalUV), finalUV]);
-}
-function fitSurface(params, slots, texture, extra) {
-	const { ctx, propValues, uvContext, effectiveViewportSize } = params;
-	return mediaSurface({
-		texture,
-		uv: uvContext ?? ctx.uv,
-		viewport: effectiveViewportSize ?? ctx.viewportSize,
-		fit: propValues[slots.fit.name],
-		decode: slots.decode,
-		...extra
-	});
-}
-function imageMedia(opts) {
-	return { gpu: { fragment: (params) => {
-		const tex = createSwappableMediaTexture(params, { label: opts.label });
-		createUrlSourceLoader(params, {
-			prop: opts.src.name,
-			async load(url, loadCtx) {
-				const decoded = await decodeImageSource(url);
-				if (loadCtx.isDisposed()) {
-					decoded.close();
-					return;
-				}
-				loadCtx.commit();
-				registerNaturalSize(url, decoded.naturalWidth, decoded.naturalHeight);
-				tex.ensureSize(decoded.width, decoded.height);
-				tex.write(decoded.source);
-				decoded.close();
-			},
-			onError: opts.onError
-		});
-		return fitSurface(params, opts, tex.kit);
-	} } };
-}
-function videoMedia(opts) {
-	return { gpu: { fragment: (params) => {
-		const source = createVideoElementSource(params, {
-			source: {
-				kind: "url",
-				prop: opts.src.name
-			},
-			loop: { prop: opts.loop.name },
-			metadataTimeoutMs: opts.metadataTimeoutMs,
-			onError: opts.onError
-		});
-		return fitSurface(params, opts, params.registerExternalTexture(source.getSource));
-	} } };
-}
-function webcamMedia(opts) {
-	return { gpu: { fragment: (params) => {
-		const source = createVideoElementSource(params, {
-			source: {
-				kind: "webcam",
-				constraints: opts.constraints
-			},
-			naturalSizeKey: opts.naturalSizeKey,
-			autoplayRequired: true,
-			onError: opts.onError
-		});
-		return fitSurface(params, opts, params.registerExternalTexture(source.getSource), {
-			allowNone: true,
-			uvPostProcess: (uv) => call(applyMirror, "applyMirror", [uv, params.uniforms[opts.mirror.name]])
-		});
-	} } };
-}
-export { videoMedia as n, webcamMedia as r, imageMedia as t };