shaders 3.1.463 → 3.2.465

package/dist/core/math-DCQU6EQz.js

@@ -0,0 +1,54 @@
+import { at as asLocal, dt as mixExpr, ft as vec4, pt as Expr, ut as floatE } from "./lower-DSk_KxOY.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 step = (edge, x) => callB("step", edge, x);
+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 rotate2 = (p, cosA, sinA) => vec2(sub(mul(member2(p, "x"), cosA), mul(member2(p, "y"), sinA)), add(mul(member2(p, "x"), sinA), mul(member2(p, "y"), cosA)));
+var member2 = (v, m) => typeof v === "number" ? v : v.member(m);
+const reflect = (i, n) => callB("reflect", i, n);
+const refract = (i, n, eta) => callB("refract", i, n, eta);
+const exp2 = (x) => callB("exp2", x);
+const hashPhase = (seed, salt) => mul(fract(mul(sin(mul(seed, salt.k)), salt.big)), 6.283185307179586);
+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 { select as A, vec4$1 as B, mul as C, reflect as D, pow as E, sqrt as F, step as I, sub as L, smoothstep as M, softPlus as N, refract as O, splat3 as P, vec2 as R, mix as S, normalize as T, le as _, cos as a, max as b, exp as c, floor as d, fract as f, hashPhase as g, gt as h, clamp as i, sin as j, rotate2 as k, exp2 as l, ge as m, add as n, div as o, gaussBell as p, atan2 as r, dot as s, abs as t, float as u, length as v, neg as w, min as x, local as y, vec3 as z };

package/dist/core/{media-DtmmUThn.js → media-Bh5c_fVF.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 { Br as f32, Ct as srgbToLinear, Jn as select, Tr as vec4f, cr as max, lr as min, ot as call, wr as vec3f, xr as vec2f, zn as typegpu_default } from "./lower-DSk_KxOY.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);
@@ -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-BTPb5i1-.js}

@@ -1,4 +1,4 @@
-import { r as debugWarn } from "./support-DVuLvN48.js";
+import { r as debugWarn } from "./support-GJphyuEe.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() {