shaders 3.2.475 → 4.0.0

package/dist/core/fluids-CBhAiGAx.js

@@ -1,226 +0,0 @@
-import { G as pathStampRibbon, H as createIdleGate, Mr as vec4f, U as createPointerVelocityTracker, Y as createStateBuffer, qr as f32 } from "./lower-DtoDQ7hV.js";
-import { F as createFluidKernelPass, I as createStableFluidsPasses } from "./porters-CQwDd2t4.js";
-const ambientForce = (kernel) => ({
-	stage: "pre",
-	kernel
-});
-const restoreToward = (kernel) => ({
-	stage: "post",
-	kernel
-});
-var STATE_FORMAT = "rgba16float";
-function fluidSim(build) {
-	return { compute: (params) => {
-		const { gpu, getCpuValue, registerComputeTexture, onCleanup } = params;
-		const root = gpu?.root;
-		if (!root) return null;
-		const cfg = build(params, root);
-		const n = cfg.resolution;
-		const count = n * n;
-		const velA = createStateBuffer(root, vec4f, count);
-		const velB = createStateBuffer(root, vec4f, count);
-		const dyeA = createStateBuffer(root, vec4f, count);
-		const dyeB = createStateBuffer(root, vec4f, count);
-		const pressure = createStateBuffer(root, f32, count);
-		const divergence = createStateBuffer(root, f32, count);
-		const maskBuf = cfg.container ? createStateBuffer(root, vec4f, count) : void 0;
-		const outTex = root.createTexture({
-			size: [n, n],
-			format: STATE_FORMAT
-		}).$usage("storage", "sampled");
-		onCleanup(() => outTex.destroy());
-		const outputTexture = registerComputeTexture(outTex);
-		const paramsU = root.createUniform(cfg.paramsSchema);
-		const entries = {
-			velA,
-			velB,
-			dyeA,
-			dyeB,
-			pressure,
-			divergence,
-			params: paramsU.buffer
-		};
-		if (maskBuf) entries.maskBuf = maskBuf;
-		const fluidBg = root.createBindGroup(cfg.layout, entries);
-		const outputBg = root.createBindGroup(cfg.outputLayout, {
-			dyeA,
-			outTex
-		});
-		const ctx = {
-			params,
-			root,
-			n,
-			buffers: {
-				velA,
-				velB,
-				dyeA,
-				dyeB,
-				pressure,
-				divergence,
-				maskBuf
-			},
-			paramsBuffer: paramsU.buffer,
-			fluidBindGroup: fluidBg,
-			pass: (kernel, bindGroup = fluidBg) => createFluidKernelPass(root, kernel, {
-				n,
-				bindGroup
-			})
-		};
-		const containerParts = cfg.container?.setup(ctx);
-		cfg.init?.setup?.(ctx);
-		const emitters = cfg.inject ?? [];
-		for (const e of emitters) e.setup?.(ctx);
-		const solvePre = (cfg.solve ?? []).filter((s) => s.stage === "pre").map((s) => ctx.pass(s.kernel));
-		const solvePost = (cfg.solve ?? []).filter((s) => s.stage === "post").map((s) => ctx.pass(s.kernel));
-		const solver = createStableFluidsPasses(root, cfg.solver.kernels, {
-			n,
-			bindGroup: fluidBg
-		});
-		const outputPass = ctx.pass(cfg.output.kernel, outputBg);
-		const solveInto = (nodes, jacobiIters) => {
-			nodes.push(...solvePre, ...solver.solveSteps({ jacobiIters }), ...solvePost);
-		};
-		const tracker = cfg.pointer ? createPointerVelocityTracker(cfg.pointer) : null;
-		const maxDt = cfg.maxDeltaTime ?? .033;
-		let lastTime = Date.now();
-		let elapsed = 0;
-		const num = (key, fallback) => {
-			const v = getCpuValue(key);
-			return typeof v === "number" ? v : fallback;
-		};
-		const writeParams = (v) => paramsU.write(v);
-		return {
-			outputs: {
-				[cfg.output.key]: outputTexture,
-				...containerParts?.outputs ?? {}
-			},
-			getComputeNodes: (frameParams) => {
-				const fp = frameParams;
-				const preNodes = containerParts?.preFrame ? containerParts.preFrame(frameParams) : null;
-				const now = Date.now();
-				const dt = Math.min(fp.deltaTime ?? (now - lastTime) / 1e3, maxDt);
-				lastTime = now;
-				if (dt < .001) return preNodes;
-				elapsed += dt;
-				const f = {
-					dt,
-					now,
-					frameParams: fp,
-					num,
-					getCpuValue,
-					writeParams,
-					ptr: tracker ? tracker.update(fp.pointer, dt) : null,
-					get elapsed() {
-						return elapsed;
-					},
-					setElapsed(t) {
-						elapsed = t;
-					}
-				};
-				const nodes = preNodes ? [...preNodes] : [];
-				let ranInit = false;
-				if (cfg.init?.stale(f)) {
-					ranInit = true;
-					cfg.init.run(f, {
-						nodes,
-						writeParams: (v$1) => () => paramsU.write(v$1),
-						solve: solveInto
-					});
-				}
-				for (const e of emitters) e.tick?.(f);
-				for (const e of emitters) if (e.skip?.(f)) return ranInit ? nodes : null;
-				const v = cfg.values(f);
-				if ((cfg.write ?? "direct") === "thunk") nodes.push(() => paramsU.write(v));
-				else paramsU.write(v);
-				if (containerParts) nodes.push(containerParts.maskPass);
-				for (const e of emitters) e.emit?.(f, nodes, v);
-				solveInto(nodes, cfg.solver.jacobiIters);
-				nodes.push(outputPass);
-				return nodes;
-			}
-		};
-	} };
-}
-function splat(opts) {
-	let pass = null;
-	return {
-		setup(ctx) {
-			pass = "kernel" in opts ? ctx.pass(opts.kernel) : opts.setup(ctx);
-		},
-		emit(_f, nodes) {
-			if (pass) nodes.push(pass);
-		}
-	};
-}
-function cursorRibbon(opts) {
-	const tracker = createPointerVelocityTracker(opts.tracker);
-	const idle = createIdleGate();
-	let pass = null;
-	let ptr = null;
-	let scale = 1;
-	let isActive = false;
-	return {
-		setup(ctx) {
-			scale = ctx.n;
-			pass = "kernel" in opts.pass ? ctx.pass(opts.pass.kernel) : opts.pass.setup(ctx);
-		},
-		tick(f) {
-			ptr = tracker.update(f.frameParams.pointer, f.dt);
-			opts.onFrame?.(f, ptr);
-			isActive = opts.activeWhen(ptr, f);
-			if (isActive) idle.markActive();
-		},
-		skip(f) {
-			const skip = idle.shouldSkip(opts.fadeSeconds(f));
-			if (!skip) idle.tickFrame(f.dt);
-			return skip;
-		},
-		emit(f, nodes, values) {
-			if (!isActive || !ptr || !pass) return;
-			const spec = opts.ribbon(f, ptr, values);
-			pathStampRibbon(nodes, {
-				fromX: ptr.prevX,
-				fromY: ptr.prevY,
-				dx: ptr.dx,
-				dy: ptr.dy,
-				dragDist: ptr.dragDist,
-				stepSize: spec.stepSize,
-				maxSteps: spec.maxSteps,
-				scale,
-				prepare: spec.prepare,
-				write: spec.write,
-				pass
-			});
-		},
-		ptr: () => ptr,
-		active: () => isActive
-	};
-}
-function seededFieldInit(opts) {
-	let pass = null;
-	let initialized = false;
-	let lastSeed = -1;
-	return {
-		setup(ctx) {
-			pass = ctx.pass(opts.kernel);
-		},
-		stale(f) {
-			return !initialized || opts.seed(f) !== lastSeed;
-		},
-		run(f, io) {
-			initialized = true;
-			lastSeed = opts.seed(f);
-			io.nodes.push(io.writeParams(opts.warm.values(0, f)));
-			if (pass) io.nodes.push(pass);
-			let warmTime = opts.warm.startTime();
-			for (let w = 0; w < opts.warm.steps; w++) {
-				const wt = warmTime;
-				warmTime += opts.warm.dt;
-				io.nodes.push(io.writeParams(opts.warm.values(wt, f)));
-				io.solve(io.nodes, opts.warm.jacobiIters);
-			}
-			f.setElapsed(warmTime);
-		}
-	};
-}
-export { seededFieldInit as a, restoreToward as i, cursorRibbon as n, splat as o, fluidSim as r, ambientForce as t };

package/dist/core/fonts-BUXTd9qb.js

@@ -1,59 +0,0 @@
-function googleFontCss2Url(family, weight = 400, italic = false, text) {
-	let url = `https://fonts.googleapis.com/css2?family=${family.trim().replace(/ /g, "+")}:ital,wght@${italic ? 1 : 0},${weight}&display=swap`;
-	if (text) url += `&text=${encodeURIComponent(text)}`;
-	return url;
-}
-var loadedFonts = /* @__PURE__ */ new Set();
-var pendingLoads = /* @__PURE__ */ new Map();
-function loadGoogleFont(family, weight = 400, italic = false) {
-	if (typeof document === "undefined" || !family) return Promise.resolve();
-	const key = `${family}|${weight}|${italic}`;
-	if (loadedFonts.has(key)) return Promise.resolve();
-	const pending = pendingLoads.get(key);
-	if (pending) return pending;
-	const promise = loadFontLink(family, weight, italic).catch(() => {
-		if (weight !== 400 || italic) return loadGoogleFont(family, 400, false);
-	}).then(() => {
-		loadedFonts.add(key);
-		pendingLoads.delete(key);
-	});
-	pendingLoads.set(key, promise);
-	return promise;
-}
-function loadFontLink(family, weight, italic) {
-	const href = googleFontCss2Url(family, weight, italic);
-	return new Promise((resolve, reject) => {
-		if (document.querySelector(`link[href="${href}"]`)) {
-			resolve();
-			return;
-		}
-		const link = document.createElement("link");
-		link.rel = "stylesheet";
-		link.href = href;
-		link.onload = () => resolve();
-		link.onerror = () => {
-			link.remove();
-			reject(/* @__PURE__ */ new Error(`Failed to load font stylesheet: ${family}`));
-		};
-		document.head.appendChild(link);
-	}).then(async () => {
-		if (document.fonts?.load) {
-			const spec = `${italic ? "italic " : ""}${weight} 12px "${family}"`;
-			try {
-				if (!(await document.fonts.load(spec)).length) throw new Error(`No font faces loaded for ${spec}`);
-			} catch (e) {
-				if (!(await document.fonts.load(`12px "${family}"`)).length) throw e;
-			}
-			await new Promise((resolve) => setTimeout(resolve, 300));
-		} else await new Promise((resolve) => setTimeout(resolve, 1e3));
-	});
-}
-function isFontAvailable(family, weight = 400, italic = false) {
-	if (typeof document === "undefined" || !document.fonts?.check) return false;
-	try {
-		return document.fonts.check(`${italic ? "italic " : ""}${weight} 12px "${family}"`);
-	} catch {
-		return false;
-	}
-}
-export { loadGoogleFont as n, isFontAvailable as t };

package/dist/core/frames-Clw8-BpA.js

@@ -1,78 +0,0 @@
-import { Pn as DEG_TO_RAD$1, o as uniformOf } from "./lower-DtoDQ7hV.js";
-import { B as vec2, L as sqrt, N as sin, S as min, T as neg, a as cos, f as fract, n as add, o as div, r as atan2, s as dot, v as length, w as mul, x as max, y as local, z as sub } from "./math-7PlusTFx.js";
-var DEG_TO_RAD = DEG_TO_RAD$1;
-function surfaceOf(params) {
-	const uv = params.uvContext ?? params.ctx.uv;
-	const viewport = params.effectiveViewportSize ?? params.ctx.viewportSize;
-	return {
-		uv,
-		viewport,
-		aspect: local(div(viewport.member("x"), viewport.member("y")), "aspect")
-	};
-}
-function rawSurfaceOf(params) {
-	const uv = params.uvContext ?? params.ctx.uv;
-	const viewport = params.ctx.viewportSize;
-	return {
-		uv,
-		viewport,
-		aspect: local(div(viewport.member("x"), viewport.member("y")), "aspect")
-	};
-}
-function centredFrame(slots) {
-	return (params, surface) => {
-		const center = uniformOf(slots.center, params);
-		const { uv, aspect } = surface;
-		const delta = local(vec2(sub(mul(uv.member("x"), aspect), mul(center.member("x"), aspect)), sub(uv.member("y"), sub(1, center.member("y")))), "centred");
-		return {
-			delta,
-			dist: local(length(delta), "centredDist")
-		};
-	};
-}
-function segmentFrame(slots) {
-	return (params, surface) => {
-		const from = uniformOf(slots.from, params);
-		const to = uniformOf(slots.to, params);
-		const { uv, aspect } = surface;
-		const cx = mul(from.member("x"), aspect);
-		const cy = sub(1, from.member("y"));
-		const rel = local(vec2(sub(mul(uv.member("x"), aspect), cx), sub(uv.member("y"), cy)), "rel");
-		const toRel = local(vec2(sub(mul(to.member("x"), aspect), cx), sub(sub(1, to.member("y")), cy)), "toRel");
-		const len = local(max(length(toRel), 1e-4), "segLen");
-		const dir = local(div(toRel, len), "segDir");
-		return {
-			along: local(dot(rel, dir), "along"),
-			across: local(add(mul(rel.member("x"), neg(dir.member("y"))), mul(rel.member("y"), dir.member("x"))), "across"),
-			length: len
-		};
-	};
-}
-function direction(angleDeg, hint = "dir") {
-	const rad = mul(angleDeg, DEG_TO_RAD);
-	return local(vec2(cos(rad), sin(rad)), hint);
-}
-function directionFrame(angleDeg, hint = "grain") {
-	const tangent = direction(angleDeg, `${hint}T`);
-	const perp = local(vec2(neg(tangent.member("y")), tangent.member("x")), `${hint}P`);
-	return {
-		tangent,
-		perp,
-		coordsOf(p) {
-			return {
-				along: local(dot(p, tangent), "along"),
-				across: local(dot(p, perp), "across")
-			};
-		}
-	};
-}
-function sectorFold(x, y, sectorAngle, center = .5) {
-	const PI = 3.141592653589793;
-	const dx = local(sub(x, center), "kfDx");
-	const dy = local(sub(y, center), "kfDy");
-	const r = local(sqrt(add(mul(dx, dx), mul(dy, dy))), "kfR");
-	const inSector = local(mul(fract(div(add(atan2(dy, dx), PI), sectorAngle)), sectorAngle), "kfInSector");
-	const folded = local(min(inSector, sub(sectorAngle, inSector)), "kfFolded");
-	return vec2(mul(r, cos(folded)), mul(r, sin(folded)));
-}
-export { sectorFold as a, rawSurfaceOf as i, direction as n, segmentFrame as o, directionFrame as r, surfaceOf as s, centredFrame as t };