shaders 3.1.462 → 3.2.464

package/dist/core/math-BF-GBlb4.js

@@ -0,0 +1,47 @@
+import { dt as vec4, ft as Expr, it as asLocal, lt as floatE, ut as mixExpr } from "./lower-z2vuXP8M.js";
+var toE = (v) => typeof v === "number" ? floatE(v) : v;
+var emit = (v, ctx) => typeof v === "number" ? floatE(v)._emit(ctx) : v._emit(ctx);
+function callB(name, ...args) {
+	return new Expr((ctx) => `${name}(${args.map((a) => emit(a, ctx)).join(", ")})`);
+}
+function binary(op, a, b) {
+	return new Expr((ctx) => `(${emit(a, ctx)} ${op} ${emit(b, ctx)})`);
+}
+const add = (a, b) => binary("+", a, b);
+const sub = (a, b) => binary("-", a, b);
+const mul = (a, b) => binary("*", a, b);
+const div = (a, b) => binary("/", a, b);
+const neg = (a) => new Expr((ctx) => `(-(${emit(a, ctx)}))`);
+const abs = (x) => callB("abs", x);
+const floor = (x) => callB("floor", x);
+const fract = (x) => callB("fract", x);
+const sqrt = (x) => callB("sqrt", x);
+const pow = (x, y) => callB("pow", x, y);
+const exp = (x) => callB("exp", x);
+const sin = (x) => callB("sin", x);
+const cos = (x) => callB("cos", x);
+const atan2 = (y, x) => callB("atan2", y, x);
+const min = (a, b) => callB("min", a, b);
+const max = (a, b) => callB("max", a, b);
+const clamp = (x, lo, hi) => callB("clamp", x, lo, hi);
+const mix = (a, b, t) => mixExpr(toE(a), toE(b), typeof t === "number" ? t : t);
+const smoothstep = (e0, e1, x) => callB("smoothstep", e0, e1, x);
+const length = (v) => callB("length", v);
+const dot = (a, b) => callB("dot", a, b);
+const normalize = (v) => callB("normalize", v);
+const le = (a, b) => binary("<=", a, b);
+const gt = (a, b) => binary(">", a, b);
+const ge = (a, b) => binary(">=", a, b);
+const select = (cond, ifTrue, ifFalse) => new Expr((ctx) => `select(${emit(ifFalse, ctx)}, ${emit(ifTrue, ctx)}, ${emit(cond, ctx)})`);
+const float = (n) => floatE(n);
+const vec2 = (x, y) => callB("vec2f", x, y);
+const vec3 = (x, y, z) => callB("vec3f", x, y, z);
+const vec4$1 = (...parts) => vec4(...parts.map(toE));
+const splat3 = (x) => callB("vec3f", x);
+const local = (e, hint) => asLocal(e, hint);
+const softPlus = (x, k) => {
+	const xe = local(x, "sp");
+	return mul(add(xe, sqrt(add(mul(xe, xe), mul(k, k)))), .5);
+};
+const gaussBell = (x, k) => exp(neg(mul(mul(x, x), k)));
+export { sqrt as A, normalize as C, smoothstep as D, sin as E, vec2 as M, vec3 as N, softPlus as O, vec4$1 as P, neg as S, select as T, local as _, cos as a, mix as b, exp as c, fract as d, gaussBell as f, length as g, le as h, clamp as i, sub as j, splat3 as k, float as l, gt as m, add as n, div as o, ge as p, atan2 as r, dot as s, abs as t, floor as u, max as v, pow as w, mul as x, min as y };

package/dist/core/{media-DtmmUThn.js → media-By6o6a83.js}

@@ -1,4 +1,5 @@
-import { Ft as vec3f, Lt as vec4f, Mt as vec2f, _t as max, et as typegpu_default, j as srgbToLinear, m as call, rt as select, vt as min } from "./edges-CV-BHMpI.js";
+import { $n as vec4f, Fn as min, Jn as vec2f, Pn as max, St as srgbToLinear, Zn as vec3f, at as call, bn as select, hr as f32, mn as typegpu_default } from "./lower-z2vuXP8M.js";
+import { i as decodeImageSource, n as createUrlSourceLoader, r as createVideoElementSource, s as registerNaturalSize, t as createSwappableMediaTexture } from "./mediaLifecycle-DQg13y-f.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);
@@ -525,6 +526,65 @@ const sampleUV = typegpu_default.fn([vec2f, vec2f], vec2f)(/* @__PURE__ */ (($)
 	},
 	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));
@@ -705,4 +765,68 @@ function mediaSurface(opts) {
 	const finalUV = opts.uvPostProcess ? opts.uvPostProcess(fitUV) : fitUV;
 	return call(alphaCutLinear, "mediaAlphaCut", [opts.texture.sample(finalUV), finalUV]);
 }
-export { mediaSurface as t };
+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 };

package/dist/core/{mediaLifecycle-DHrjB2zB.js → mediaLifecycle-DQg13y-f.js}

@@ -1,4 +1,4 @@
-import { r as debugWarn } from "./support-DVuLvN48.js";
+import { r as debugWarn } from "./support-ULZQgbko.js";
 var registry = /* @__PURE__ */ new Map();
 var listeners = /* @__PURE__ */ new Set();
 function registerNaturalSize(key, width, height) {
@@ -22,12 +22,17 @@ function onNaturalSizeChange(fn) {
 		listeners.delete(fn);
 	};
 }
+function mipLevelCountFor(width, height) {
+	return Math.floor(Math.log2(Math.max(width, height))) + 1;
+}
 function createSwappableMediaTexture(params, opts) {
 	const { createMediaTexture, registerMediaTexture, onCleanup } = params;
+	const wantsMipmaps = opts.mipmaps ?? true;
 	const make = (width, height) => createMediaTexture({
 		width,
 		height,
 		label: opts.label,
+		...wantsMipmaps ? { mipLevelCount: mipLevelCountFor(width, height) } : {},
 		...opts.format ? { format: opts.format } : {}
 	});
 	let current = make(Math.max(1, opts.initial?.width ?? 1), Math.max(1, opts.initial?.height ?? 1));
@@ -51,6 +56,7 @@ function createSwappableMediaTexture(params, opts) {
 		write(source) {
 			if (isDisposed) return;
 			current.write(source);
+			if (wantsMipmaps) current.generateMipmaps();
 		},
 		unwrap: () => current.unwrap(),
 		get width() {