shaders 3.0.453 → 3.1.455

package/dist/core/VideoTexture--U8aiyP1.js

@@ -1,927 +0,0 @@
-import { At as max, Gt as data_exports, Pt as pow, cn as vec4f, gt as select, ht as le, it as std_exports, jt as min, m as call, nt as src_default, on as vec3f, rn as vec2f } from "./edges-B7Yet3LV.js";
-import { r as registerNaturalSize } from "./naturalSize-BPCi_I-Z.js";
-const videoScaleCover = src_default.fn([vec2f, vec2f], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((videoDims, vp) => {
-	"use gpu";
-	const videoAspect = __tsover_div(videoDims.x, videoDims.y);
-	const viewportAspect = __tsover_div(vp.x, vp.y);
-	const coverScale = max(__tsover_div(viewportAspect, videoAspect), 1);
-	return vec2f(__tsover_mul(__tsover_div(videoAspect, viewportAspect), coverScale), coverScale);
-}), {
-	v: 1,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "videoDims"
-		}, {
-			"type": "i",
-			"name": "vp"
-		}],
-		"body": [0, [
-			[
-				13,
-				"videoAspect",
-				[
-					1,
-					[
-						7,
-						"videoDims",
-						"x"
-					],
-					"/",
-					[
-						7,
-						"videoDims",
-						"y"
-					]
-				]
-			],
-			[
-				13,
-				"viewportAspect",
-				[
-					1,
-					[
-						7,
-						"vp",
-						"x"
-					],
-					"/",
-					[
-						7,
-						"vp",
-						"y"
-					]
-				]
-			],
-			[
-				13,
-				"coverScale",
-				[
-					6,
-					[
-						7,
-						"std",
-						"max"
-					],
-					[[
-						1,
-						"viewportAspect",
-						"/",
-						"videoAspect"
-					], [5, "1"]]
-				]
-			],
-			[10, [
-				6,
-				[
-					7,
-					"d",
-					"vec2f"
-				],
-				[[
-					1,
-					[
-						1,
-						"videoAspect",
-						"/",
-						"viewportAspect"
-					],
-					"*",
-					"coverScale"
-				], "coverScale"]
-			]]
-		]],
-		"externalNames": ["std", "d"]
-	},
-	externals: () => ({
-		std: std_exports,
-		d: data_exports
-	})
-}) && $.f)({}));
-const videoScaleContain = src_default.fn([vec2f, vec2f], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((videoDims, vp) => {
-	"use gpu";
-	const videoAspect = __tsover_div(videoDims.x, videoDims.y);
-	const viewportAspect = __tsover_div(vp.x, vp.y);
-	const containScale = min(__tsover_div(viewportAspect, videoAspect), 1);
-	return vec2f(__tsover_mul(__tsover_div(videoAspect, viewportAspect), containScale), containScale);
-}), {
-	v: 1,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "videoDims"
-		}, {
-			"type": "i",
-			"name": "vp"
-		}],
-		"body": [0, [
-			[
-				13,
-				"videoAspect",
-				[
-					1,
-					[
-						7,
-						"videoDims",
-						"x"
-					],
-					"/",
-					[
-						7,
-						"videoDims",
-						"y"
-					]
-				]
-			],
-			[
-				13,
-				"viewportAspect",
-				[
-					1,
-					[
-						7,
-						"vp",
-						"x"
-					],
-					"/",
-					[
-						7,
-						"vp",
-						"y"
-					]
-				]
-			],
-			[
-				13,
-				"containScale",
-				[
-					6,
-					[
-						7,
-						"std",
-						"min"
-					],
-					[[
-						1,
-						"viewportAspect",
-						"/",
-						"videoAspect"
-					], [5, "1"]]
-				]
-			],
-			[10, [
-				6,
-				[
-					7,
-					"d",
-					"vec2f"
-				],
-				[[
-					1,
-					[
-						1,
-						"videoAspect",
-						"/",
-						"viewportAspect"
-					],
-					"*",
-					"containScale"
-				], "containScale"]
-			]]
-		]],
-		"externalNames": ["std", "d"]
-	},
-	externals: () => ({
-		std: std_exports,
-		d: data_exports
-	})
-}) && $.f)({}));
-const videoScaleFill = src_default.fn([], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = (() => {
-	"use gpu";
-	return vec2f(1, 1);
-}), {
-	v: 1,
-	name: void 0,
-	ast: {
-		"params": [],
-		"body": [0, [[10, [
-			6,
-			[
-				7,
-				"d",
-				"vec2f"
-			],
-			[[5, "1"], [5, "1"]]
-		]]]],
-		"externalNames": ["d"]
-	},
-	externals: () => ({ d: data_exports })
-}) && $.f)({}));
-const videoScaleScaleDown = src_default.fn([vec2f, vec2f], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((videoDims, vp) => {
-	"use gpu";
-	const videoAspect = __tsover_div(videoDims.x, videoDims.y);
-	const viewportAspect = __tsover_div(vp.x, vp.y);
-	const scaleDownScale = min(min(__tsover_div(viewportAspect, videoAspect), 1), min(__tsover_div(vp.x, videoDims.x), __tsover_div(vp.y, videoDims.y)));
-	return vec2f(__tsover_mul(__tsover_div(videoAspect, viewportAspect), scaleDownScale), scaleDownScale);
-}), {
-	v: 1,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "videoDims"
-		}, {
-			"type": "i",
-			"name": "vp"
-		}],
-		"body": [0, [
-			[
-				13,
-				"videoAspect",
-				[
-					1,
-					[
-						7,
-						"videoDims",
-						"x"
-					],
-					"/",
-					[
-						7,
-						"videoDims",
-						"y"
-					]
-				]
-			],
-			[
-				13,
-				"viewportAspect",
-				[
-					1,
-					[
-						7,
-						"vp",
-						"x"
-					],
-					"/",
-					[
-						7,
-						"vp",
-						"y"
-					]
-				]
-			],
-			[
-				13,
-				"containScale",
-				[
-					6,
-					[
-						7,
-						"std",
-						"min"
-					],
-					[[
-						1,
-						"viewportAspect",
-						"/",
-						"videoAspect"
-					], [5, "1"]]
-				]
-			],
-			[
-				13,
-				"naturalScale",
-				[
-					6,
-					[
-						7,
-						"std",
-						"min"
-					],
-					[[
-						1,
-						[
-							7,
-							"vp",
-							"x"
-						],
-						"/",
-						[
-							7,
-							"videoDims",
-							"x"
-						]
-					], [
-						1,
-						[
-							7,
-							"vp",
-							"y"
-						],
-						"/",
-						[
-							7,
-							"videoDims",
-							"y"
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"scaleDownScale",
-				[
-					6,
-					[
-						7,
-						"std",
-						"min"
-					],
-					["containScale", "naturalScale"]
-				]
-			],
-			[10, [
-				6,
-				[
-					7,
-					"d",
-					"vec2f"
-				],
-				[[
-					1,
-					[
-						1,
-						"videoAspect",
-						"/",
-						"viewportAspect"
-					],
-					"*",
-					"scaleDownScale"
-				], "scaleDownScale"]
-			]]
-		]],
-		"externalNames": ["std", "d"]
-	},
-	externals: () => ({
-		std: std_exports,
-		d: data_exports
-	})
-}) && $.f)({}));
-const videoSampleUV = src_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: 1,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "uv"
-		}, {
-			"type": "i",
-			"name": "uvScale"
-		}],
-		"body": [0, [
-			[
-				13,
-				"centeredUV",
-				[
-					6,
-					[
-						7,
-						"uv",
-						"sub"
-					],
-					[[
-						6,
-						[
-							7,
-							"d",
-							"vec2f"
-						],
-						[[5, "0.5"], [5, "0.5"]]
-					]]
-				]
-			],
-			[
-				13,
-				"scaledUV",
-				[
-					6,
-					[
-						7,
-						"d",
-						"vec2f"
-					],
-					[[
-						1,
-						[
-							7,
-							"centeredUV",
-							"x"
-						],
-						"/",
-						[
-							7,
-							"uvScale",
-							"x"
-						]
-					], [
-						1,
-						[
-							7,
-							"centeredUV",
-							"y"
-						],
-						"/",
-						[
-							7,
-							"uvScale",
-							"y"
-						]
-					]]
-				]
-			],
-			[10, [
-				6,
-				[
-					7,
-					"scaledUV",
-					"add"
-				],
-				[[
-					6,
-					[
-						7,
-						"d",
-						"vec2f"
-					],
-					[[5, "0.5"], [5, "0.5"]]
-				]]
-			]]
-		]],
-		"externalNames": ["d"]
-	},
-	externals: () => ({ d: data_exports })
-}) && $.f)({}));
-const srgbToLinear = src_default.fn([vec3f], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color) => {
-	"use gpu";
-	return select(pow(color.add(vec3f(.055)).div(vec3f(1.055)), vec3f(2.4)), color.div(vec3f(12.92)), le(color, vec3f(.04045)));
-}), {
-	v: 1,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "color"
-		}],
-		"body": [0, [
-			[
-				13,
-				"hi",
-				[
-					6,
-					[
-						7,
-						"std",
-						"pow"
-					],
-					[[
-						6,
-						[
-							7,
-							[
-								6,
-								[
-									7,
-									"color",
-									"add"
-								],
-								[[
-									6,
-									[
-										7,
-										"d",
-										"vec3f"
-									],
-									[[5, "0.055"]]
-								]]
-							],
-							"div"
-						],
-						[[
-							6,
-							[
-								7,
-								"d",
-								"vec3f"
-							],
-							[[5, "1.055"]]
-						]]
-					], [
-						6,
-						[
-							7,
-							"d",
-							"vec3f"
-						],
-						[[5, "2.4"]]
-					]]
-				]
-			],
-			[
-				13,
-				"lo",
-				[
-					6,
-					[
-						7,
-						"color",
-						"div"
-					],
-					[[
-						6,
-						[
-							7,
-							"d",
-							"vec3f"
-						],
-						[[5, "12.92"]]
-					]]
-				]
-			],
-			[
-				13,
-				"isLow",
-				[
-					6,
-					[
-						7,
-						"std",
-						"le"
-					],
-					["color", [
-						6,
-						[
-							7,
-							"d",
-							"vec3f"
-						],
-						[[5, "0.04045"]]
-					]]
-				]
-			],
-			[10, [
-				6,
-				[
-					7,
-					"std",
-					"select"
-				],
-				[
-					"hi",
-					"lo",
-					"isLow"
-				]
-			]]
-		]],
-		"externalNames": ["std", "d"]
-	},
-	externals: () => ({
-		std: std_exports,
-		d: data_exports
-	})
-}) && $.f)({}));
-const videoAlphaCut = src_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: 1,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "color"
-		}, {
-			"type": "i",
-			"name": "uv"
-		}],
-		"body": [0, [
-			[
-				13,
-				"linear",
-				[
-					6,
-					"srgbToLinear",
-					[[
-						6,
-						[
-							7,
-							"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,
-					[
-						7,
-						"std",
-						"select"
-					],
-					[
-						[
-							7,
-							"color",
-							"w"
-						],
-						[5, "0"],
-						"outOfBounds"
-					]
-				]
-			],
-			[10, [
-				6,
-				[
-					7,
-					"d",
-					"vec4f"
-				],
-				[
-					[
-						7,
-						"linear",
-						"x"
-					],
-					[
-						7,
-						"linear",
-						"y"
-					],
-					[
-						7,
-						"linear",
-						"z"
-					],
-					"alpha"
-				]
-			]]
-		]],
-		"externalNames": [
-			"srgbToLinear",
-			"d",
-			"std"
-		]
-	},
-	externals: () => ({
-		srgbToLinear,
-		d: data_exports,
-		std: std_exports
-	})
-}) && $.f)({}));
-var OBJECT_FIT_MODES = {
-	cover: 0,
-	contain: 1,
-	fill: 2,
-	"scale-down": 3,
-	none: 2
-};
-const componentDefinition = {
-	name: "VideoTexture",
-	boundingBoxDeclaration: {
-		aspectRatio: null,
-		supportsResizeFit: true
-	},
-	category: "Textures",
-	description: "Display a video with customizable playback and object-fit modes",
-	acceptsUVContext: true,
-	props: {
-		url: {
-			default: "https://shaders.com/sample.mp4",
-			description: "Upload a video or provide a URL",
-			ui: {
-				type: "video-upload",
-				label: "Video",
-				group: "Media"
-			}
-		},
-		objectFit: {
-			default: "fill",
-			description: "How the video should be sized within the viewport",
-			transform: (value) => {
-				return {
-					"cover": 0,
-					"contain": 1,
-					"fill": 2,
-					"scale-down": 3,
-					"none": 2
-				}[value] ?? 2;
-			},
-			compileTime: true,
-			ui: {
-				type: "select",
-				options: [
-					{
-						label: "Cover",
-						value: "cover"
-					},
-					{
-						label: "Contain",
-						value: "contain"
-					},
-					{
-						label: "Fill",
-						value: "fill"
-					},
-					{
-						label: "Scale Down",
-						value: "scale-down"
-					}
-				],
-				label: "Object Fit",
-				group: "Sizing"
-			}
-		},
-		loop: {
-			default: true,
-			description: "Loop the video playback",
-			ui: {
-				type: "checkbox",
-				label: "Loop",
-				group: "Playback"
-			}
-		}
-	},
-	fragment: ({ ctx, propValues, uvContext, effectiveViewportSize, getCpuValue, onBeforeRender, onCleanup, registerExternalTexture }) => {
-		let videoElement = null;
-		let currentUrl = "";
-		let isLoading = false;
-		let isDisposed = false;
-		const readLoop = () => {
-			const raw = getCpuValue("loop");
-			return raw === true || raw === void 0 || typeof raw === "number" && raw > 0;
-		};
-		const loadVideo = async (url) => {
-			if (!url || url.trim() === "" || isLoading || isDisposed) return;
-			isLoading = true;
-			try {
-				const video = document.createElement("video");
-				video.src = url;
-				video.playsInline = true;
-				video.crossOrigin = "anonymous";
-				video.muted = true;
-				video.loop = readLoop();
-				await new Promise((resolve, reject) => {
-					video.onloadedmetadata = () => resolve();
-					video.onerror = () => reject(/* @__PURE__ */ new Error("Failed to load video"));
-					setTimeout(() => reject(/* @__PURE__ */ new Error("Video load timeout")), 1e4);
-				});
-				if (isDisposed) {
-					video.src = "";
-					return;
-				}
-				if (videoElement) {
-					videoElement.pause();
-					videoElement.src = "";
-					videoElement = null;
-				}
-				videoElement = video;
-				currentUrl = url;
-				registerNaturalSize(url, video.videoWidth, video.videoHeight);
-				try {
-					await video.play();
-				} catch (error) {
-					console.warn("[VideoTexture] Autoplay failed (browser policy):", error);
-				}
-				isLoading = false;
-			} catch (error) {
-				console.error("[VideoTexture] Failed to load video:", error);
-				isLoading = false;
-			}
-		};
-		setTimeout(() => {
-			const initialUrl = getCpuValue("url") ?? "";
-			if (initialUrl && initialUrl.trim() !== "") loadVideo(initialUrl);
-		}, 0);
-		onBeforeRender(() => {
-			const newUrl = getCpuValue("url") ?? "";
-			if (newUrl !== currentUrl && !isLoading) loadVideo(newUrl);
-			if (videoElement) {
-				const loopValue = readLoop();
-				if (videoElement.loop !== loopValue) videoElement.loop = loopValue;
-			}
-		});
-		onCleanup(() => {
-			isDisposed = true;
-			if (videoElement) {
-				videoElement.pause();
-				videoElement.src = "";
-				videoElement = null;
-			}
-			currentUrl = "";
-		});
-		const external = registerExternalTexture(() => {
-			if (!videoElement || isDisposed) return null;
-			if (videoElement.readyState < 2 || videoElement.videoWidth === 0) return null;
-			return videoElement;
-		});
-		const baseUV = uvContext ?? ctx.uv;
-		const vp = effectiveViewportSize ?? ctx.viewportSize;
-		const videoDims = external.dimensions();
-		const rawFit = propValues.objectFit;
-		const mode = typeof rawFit === "number" ? rawFit : OBJECT_FIT_MODES[rawFit] ?? 2;
-		let uvScale;
-		if (mode === 1) uvScale = call(videoScaleContain, "videoScaleContain", [videoDims, vp]);
-		else if (mode === 2) uvScale = call(videoScaleFill, "videoScaleFill", []);
-		else if (mode === 3) uvScale = call(videoScaleScaleDown, "videoScaleScaleDown", [videoDims, vp]);
-		else uvScale = call(videoScaleCover, "videoScaleCover", [videoDims, vp]);
-		const finalUV = call(videoSampleUV, "videoSampleUV", [baseUV, uvScale]);
-		return call(videoAlphaCut, "videoAlphaCut", [external.sample(finalUV), finalUV]);
-	}
-};
-var VideoTexture_default = componentDefinition;
-export { videoSampleUV as a, videoScaleFill as c, videoAlphaCut as i, videoScaleScaleDown as l, componentDefinition as n, videoScaleContain as o, srgbToLinear as r, videoScaleCover as s, VideoTexture_default as t };