shaders 3.2.464 → 3.2.465

package/dist/core/mask-AFtVwMNo.js

@@ -0,0 +1,28 @@
+import { s as Scalar } from "./lower-DSk_KxOY.js";
+import { C as mul, E as pow, L as sub, M as smoothstep, n as add, t as abs, w as neg } from "./math-DCQU6EQz.js";
+function softBand(opts) {
+	return mul(smoothstep(opts.below.from, opts.below.to, opts.distance), sub(1, smoothstep(opts.above.from ?? 0, opts.above.to, opts.distance)));
+}
+function softDisc(opts) {
+	const { width, curve } = opts.softness;
+	return pow(sub(1, smoothstep(sub(opts.radius, width), add(opts.radius, width), opts.dist)), curve);
+}
+function crispFill(opts) {
+	const half = mul(opts.footprint, .5);
+	return sub(1, smoothstep(neg(half), half, opts.distance));
+}
+function crispStroke(opts) {
+	return crispFill({
+		distance: sub(abs(opts.distance), mul(opts.width, .5)),
+		footprint: opts.footprint
+	});
+}
+function radialMask(slots) {
+	return new Scalar({
+		kind: "radialMask",
+		center: slots.center,
+		radius: slots.radius,
+		falloff: slots.falloff
+	});
+}
+export { softDisc as a, softBand as i, crispStroke as n, radialMask as r, crispFill as t };

package/dist/core/{materials-D7QX3H4h.js → materials-Dhq8lDKb.js}

@@ -1,8 +1,7 @@
-import { $n as vec4f, Cr as __export, En as cos, Fn as min, Gn as sqrt, In as mix$1, Jn as vec2f, Ln as normalize$1, N as sdf_exports, Nn as length, On as dot$1, Pn as max$1, Rn as pow$1, Tn as clamp$1, Un as sin$1, Wn as smoothstep$1, Zn as vec3f, at as call, bn as select, ft as Expr, hr as f32, kn as exp, lt as floatE, mn as typegpu_default, mr as bool, nt as ZERO, sr as struct, un as TWO_PI, xn as abs, xt as neutral } from "./lower-z2vuXP8M.js";
-import { d as mxNoiseFloat2, f as mxNoiseFloat3, h as perlin12d, p as mxWorleyNoiseFloat2Pub, s as hash12, y as value12 } from "./noise-B3Oq1k3_.js";
-import { p as sdf3d_exports } from "./sdf3d-BD5m6HR6.js";
-import { n as glass_exports } from "./glass-DxE2Cy6_.js";
-import { C as normalize, D as smoothstep, E as sin, M as vec2, N as vec3, S as neg, _ as local, b as mix, i as clamp, j as sub, k as splat3, l as float, n as add, o as div, s as dot, v as max, w as pow, x as mul } from "./math-BF-GBlb4.js";
+import { $n as clamp$1, Br as f32, En as value12, Fn as TWO_PI, Jn as select, Jr as __export, Nr as struct, P as sdf_exports, Sn as perlin12d, St as neutral, Tr as vec4f, Yn as abs, _r as smoothstep$1, bn as mxWorleyNoiseFloat2Pub, cr as max$1, dr as normalize$1, er as cos, fr as pow$1, gr as sin$1, lr as min, mn as hash12, nr as dot$1, ot as call, pt as Expr, rr as exp$1, rt as ZERO, sr as length$1, ur as mix$1, ut as floatE, vn as mxNoiseFloat2, vr as sqrt, wr as vec3f, xr as vec2f, yn as mxNoiseFloat3, zn as typegpu_default, zr as bool } from "./lower-DSk_KxOY.js";
+import { m as sdf3d_exports } from "./sdf3d-DQ55w9nI.js";
+import { n as glass_exports } from "./glass-CtWl8jzT.js";
+import { C as mul, E as pow, L as sub, M as smoothstep, P as splat3, R as vec2, S as mix, T as normalize, b as max, c as exp, i as clamp, j as sin, l as exp2, n as add, o as div, s as dot, u as float, v as length, w as neg, y as local, z as vec3 } from "./math-DCQU6EQz.js";
 var lighting_exports = /* @__PURE__ */ __export({
 	TangentFrame: () => TangentFrame,
 	WardSpecularInput: () => WardSpecularInput,
@@ -234,7 +233,7 @@ const volumetricNormal = typegpu_default.fn([
 }) && $.f)({}));
 const bevelledFlatNormal = typegpu_default.fn([vec2f, f32], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((grad, sinTilt) => {
 	"use gpu";
-	const glen = max$1(length(grad), 1e-4);
+	const glen = max$1(length$1(grad), 1e-4);
 	const sB = min(sinTilt, .9995);
 	return vec3f(__tsover_mul(__tsover_div(grad.x, glen), sB), __tsover_mul(__tsover_div(grad.y, glen), sB), __tsover_mul(sqrt(__tsover_sub(1, __tsover_mul(sB, sB))), -1));
 }), {
@@ -335,7 +334,7 @@ const bevelledFlatNormal = typegpu_default.fn([vec2f, f32], vec3f)(/* @__PURE__
 	},
 	externals: {
 		"std.max": () => max$1,
-		"std.length": () => length,
+		"std.length": () => length$1,
 		"std.min": () => min,
 		"d.vec3f": () => vec3f,
 		"std.sqrt": () => sqrt
@@ -805,7 +804,7 @@ const wardAnisotropicSpecular = typegpu_default.fn([WardSpecularInput], f32)(/*
 	const aT = max$1(p.alphaAlong, 1e-4);
 	const aB = max$1(p.alphaAcross, 1e-4);
 	const expo = __tsover_div(__tsover_add(__tsover_mul(__tsover_div(hT, aT), __tsover_div(hT, aT)), __tsover_mul(__tsover_div(hB, aB), __tsover_div(hB, aB))), __tsover_mul(__tsover_add(hN, 1), .5));
-	return exp(__tsover_mul(expo, -1));
+	return exp$1(__tsover_mul(expo, -1));
 }), {
 	v: 2,
 	name: void 0,
@@ -1012,7 +1011,7 @@ const wardAnisotropicSpecular = typegpu_default.fn([WardSpecularInput], f32)(/*
 		"std.clamp": () => clamp$1,
 		"std.abs": () => abs,
 		"std.max": () => max$1,
-		"std.exp": () => exp
+		"std.exp": () => exp$1
 	}
 }) && $.f)({}));
 const cosinePalette = typegpu_default.fn([
@@ -1666,7 +1665,7 @@ const opticalThickness$1 = typegpu_default.fn([f32, f32], f32)(/* @__PURE__ */ (
 }) && $.f)({}));
 const beerLambert$1 = typegpu_default.fn([f32, vec3f], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((thickness, absorb) => {
 	"use gpu";
-	return vec3f(exp(__tsover_mul(__tsover_mul(thickness, absorb.x), -1)), exp(__tsover_mul(__tsover_mul(thickness, absorb.y), -1)), exp(__tsover_mul(__tsover_mul(thickness, absorb.z), -1)));
+	return vec3f(exp$1(__tsover_mul(__tsover_mul(thickness, absorb.x), -1)), exp$1(__tsover_mul(__tsover_mul(thickness, absorb.y), -1)), exp$1(__tsover_mul(__tsover_mul(thickness, absorb.z), -1)));
 }), {
 	v: 2,
 	name: void 0,
@@ -1756,7 +1755,7 @@ const beerLambert$1 = typegpu_default.fn([f32, vec3f], vec3f)(/* @__PURE__ */ ((
 	},
 	externals: {
 		"d.vec3f": () => vec3f,
-		"std.exp": () => exp
+		"std.exp": () => exp$1
 	}
 }) && $.f)({}));
 const flowWarpOffset = typegpu_default.fn([vec2f, f32], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((warpInput, flowT) => {
@@ -1936,15 +1935,15 @@ const studio5Softbox = typegpu_default.fn([
 	const sky = smoothstep$1(-.7, .85, ey);
 	let lum = __tsover_mul(__tsover_mul(sky, sky), skyGain);
 	const r0 = __tsover_mul(keyRad, 1);
-	lum = __tsover_add(lum, __tsover_mul(__tsover_mul(smoothstep$1(r0, __tsover_mul(r0, .2), length(p.sub(vec2f(__tsover_add(0, drift), .55)))), 1.7), envStr));
+	lum = __tsover_add(lum, __tsover_mul(__tsover_mul(smoothstep$1(r0, __tsover_mul(r0, .2), length$1(p.sub(vec2f(__tsover_add(0, drift), .55)))), 1.7), envStr));
 	const r1 = __tsover_mul(keyRad, 1.15);
-	lum = __tsover_add(lum, __tsover_mul(__tsover_mul(smoothstep$1(r1, __tsover_mul(r1, .2), length(p.sub(vec2f(__tsover_add(-.55, drift), .18)))), 1.05), envStr));
+	lum = __tsover_add(lum, __tsover_mul(__tsover_mul(smoothstep$1(r1, __tsover_mul(r1, .2), length$1(p.sub(vec2f(__tsover_add(-.55, drift), .18)))), 1.05), envStr));
 	const r2 = __tsover_mul(keyRad, 1);
-	lum = __tsover_add(lum, __tsover_mul(__tsover_mul(smoothstep$1(r2, __tsover_mul(r2, .2), length(p.sub(vec2f(__tsover_add(.55, drift), .1)))), 1), envStr));
+	lum = __tsover_add(lum, __tsover_mul(__tsover_mul(smoothstep$1(r2, __tsover_mul(r2, .2), length$1(p.sub(vec2f(__tsover_add(.55, drift), .1)))), 1), envStr));
 	const r3 = __tsover_mul(keyRad, 1.3);
-	lum = __tsover_add(lum, __tsover_mul(__tsover_mul(smoothstep$1(r3, __tsover_mul(r3, .2), length(p.sub(vec2f(__tsover_add(.2, drift), -.5)))), .7), envStr));
+	lum = __tsover_add(lum, __tsover_mul(__tsover_mul(smoothstep$1(r3, __tsover_mul(r3, .2), length$1(p.sub(vec2f(__tsover_add(.2, drift), -.5)))), .7), envStr));
 	const r4 = __tsover_mul(keyRad, 1.1);
-	lum = __tsover_add(lum, __tsover_mul(__tsover_mul(smoothstep$1(r4, __tsover_mul(r4, .2), length(p.sub(vec2f(__tsover_add(-.35, drift), -.25)))), .85), envStr));
+	lum = __tsover_add(lum, __tsover_mul(__tsover_mul(smoothstep$1(r4, __tsover_mul(r4, .2), length$1(p.sub(vec2f(__tsover_add(-.35, drift), -.25)))), .85), envStr));
 	return lum;
 }), {
 	v: 2,
@@ -2413,7 +2412,7 @@ const studio5Softbox = typegpu_default.fn([
 	externals: {
 		"d.vec2f": () => vec2f,
 		"std.smoothstep": () => smoothstep$1,
-		"std.length": () => length
+		"std.length": () => length$1
 	}
 }) && $.f)({}));
 var bevel_exports = /* @__PURE__ */ __export({ bevelSin: () => bevelSin });
@@ -2538,15 +2537,6 @@ function guarded(cond, inner, fallback, hint = "guarded", deps = []) {
 		return name;
 	}));
 }
-function reflect(i, n) {
-	return new Expr((ctx) => `reflect(${i._emit(ctx)}, ${n._emit(ctx)})`);
-}
-function refract(i, n, eta) {
-	return new Expr((ctx) => `refract(${i._emit(ctx)}, ${n._emit(ctx)}, ${eta._emit(ctx)})`);
-}
-function exp2(x) {
-	return new Expr((ctx) => `exp2(${x._emit(ctx)})`);
-}
 function insideShape(sdf, pxH) {
 	const outside = call(outsideShape, "outsideShape", [sdf, pxH]);
 	return new Expr((ctx) => `(!(${outside._emit(ctx)}))`);
@@ -2588,7 +2578,7 @@ function shapedSurface(spec) {
 				screenUV,
 				ctx.aspect
 			]), "sdfUV");
-			frame.surf0 = sampler(frame.sdfUV);
+			frame.surf0 = (spec.centreTap === "fast" ? gradSampler : sampler)(frame.sdfUV);
 			if (stencil !== "centre") {
 				const { kind, eps } = stencil;
 				frame.surfX = gradSampler(call(offsetUV, "offsetUV", [
@@ -2886,9 +2876,68 @@ function pointStars(p, opts) {
 		rgb: opts.tint ? mul(mix(vec3(...opts.tint.from), vec3(...opts.tint.to), splat3(variation)), splat3(mul(glint, opts.tint.gain))) : void 0
 	};
 }
+function placementPoint(params, position, hint = "placed") {
+	const { uniforms, ctx } = params;
+	const screenUV = vec2(position.member("x"), sub(1, position.member("y")));
+	return local(call(sdfSpaceUV, "sdfSpaceUV", [
+		uniforms.center,
+		uniforms.scale,
+		uniforms.rotation,
+		screenUV,
+		ctx.aspect
+	]), hint);
+}
+function continuedField(frame, field, params) {
+	if (!(!frame.volumetric && Boolean(params.propValues.shapeSdfUrl))) return {
+		sdf: field.sdf,
+		outward: vec2(0, 0),
+		at: (uv$1) => frame.gradSampler(uv$1).member("x")
+	};
+	const uv = frame.sdfUV;
+	const beyond = (p) => sub(p, clamp(p, vec2(0, 0), vec2(1, 1)));
+	const outward = local(beyond(uv), "outward");
+	const continued = (border, dist) => max(border, max(dist, sub(border, dist)));
+	return {
+		sdf: local(continued(field.sdf, length(outward)), "sdfFar"),
+		outward,
+		at: (p) => {
+			const dist = length(beyond(p));
+			return continued(frame.gradSampler(p).member("x"), dist);
+		}
+	};
+}
+function nearestEdge(sdfUV, sdf, slope, hint = "edge") {
+	const normal = local(div(slope, max(length(slope), 1e-4)), `${hint}N`);
+	return {
+		point: local(sub(sdfUV, mul(normal, max(sdf, 0))), `${hint}P`),
+		normal
+	};
+}
+function pointLightFrom(light, at, hint = "pl") {
+	const delta = local(sub(light.position, at), `${hint}D`);
+	const distance = local(length(delta), `${hint}Dist`);
+	const toLight = local(div(delta, max(distance, 1e-4)), `${hint}Dir`);
+	return {
+		L: local(normalize(vec3(delta.member("x"), delta.member("y"), neg(light.height))), `${hint}L`),
+		toLight,
+		distance
+	};
+}
+function lambert(normal, light, opts = {}) {
+	const ndl = dot(normal, light);
+	if (opts.wrap === void 0) return max(ndl, 0);
+	return clamp(div(add(ndl, opts.wrap), add(1, opts.wrap)), 0, 1);
+}
+function inverseSquare(distance, range) {
+	const r = div(distance, range);
+	return div(1, add(1, mul(r, r)));
+}
+function exposureTone(rgb) {
+	return sub(1, exp(neg(rgb)));
+}
 function dualLobeGlint(ndh, opts) {
 	const widen = opts.softness ? local(exp2(mix(2, -2, opts.softness)), "lobeWiden") : void 0;
 	const exponent = (e) => widen ? mul(e, widen) : float(e);
 	return mul(add(mul(pow(ndh, exponent(opts.core[0])), opts.core[1]), mul(pow(ndh, exponent(opts.halo[0])), opts.halo[1])), opts.gain);
 }
-export { schlickFresnel as A, surfacePattern as B, nudgeNormal as C, reflect as D, pointStars as E, smearAlong as F, valueNoise as G, tiltNormal as H, studioSoftboxes as I, wardAlphas as J, viewRay as K, surfaceField as L, sharpGlint as M, shellRefract as N, refract as O, silhouette as P, surfaceNoise as R, neutralTone as S, perlinSlope as T, tintRamp as U, tiltAlong as V, twinkle as W, cosinePalette as X, bevel_exports as Y, lighting_exports as Z, insideShape as _, dualLobeGlint as a, lightVec3 as b, fieldSlope as c, geometricNormal as d, grainNoise as f, hashNoise as g, guarded as h, cosineRainbow as i, shapedSurface as j, rotationSensor as k, flowWarp as l, grazingOf as m, beerLambert as n, exp2 as o, grazingFlat as p, volumeNoiseAt as q, cellNoiseAt as r, fdSlope as s, anisoSpecular as t, fresnelBoost as u, keyLightAt as v, opticalThickness as w, marchedNormal as x, keyLightXY as y, surfaceNoiseAt as z };
+export { bevel_exports as $, placementPoint as A, studioSoftboxes as B, lightVec3 as C, nudgeNormal as D, neutralTone as E, shapedSurface as F, tiltAlong as G, surfaceNoise as H, sharpGlint as I, twinkle as J, tiltNormal as K, shellRefract as L, pointStars as M, rotationSensor as N, opticalThickness as O, schlickFresnel as P, wardAlphas as Q, silhouette as R, lambert as S, nearestEdge as T, surfaceNoiseAt as U, surfaceField as V, surfacePattern as W, viewRay as X, valueNoise as Y, volumeNoiseAt as Z, hashNoise as _, cosineRainbow as a, keyLightAt as b, fdSlope as c, fresnelBoost as d, cosinePalette as et, geometricNormal as f, guarded as g, grazingOf as h, continuedField as i, pointLightFrom as j, perlinSlope as k, fieldSlope as l, grazingFlat as m, beerLambert as n, dualLobeGlint as o, grainNoise as p, tintRamp as q, cellNoiseAt as r, exposureTone as s, anisoSpecular as t, lighting_exports as tt, flowWarp as u, insideShape as v, marchedNormal as w, keyLightXY as x, inverseSquare as y, smearAlong as z };

package/dist/core/{math-BF-GBlb4.js → math-DCQU6EQz.js}

@@ -1,4 +1,4 @@
-import { dt as vec4, ft as Expr, it as asLocal, lt as floatE, ut as mixExpr } from "./lower-z2vuXP8M.js";
+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) {
@@ -25,10 +25,17 @@ 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);
@@ -44,4 +51,4 @@ const softPlus = (x, k) => {
 	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 };
+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-By6o6a83.js → media-Bh5c_fVF.js}

@@ -1,5 +1,5 @@
-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";
+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);

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

@@ -1,4 +1,4 @@
-import { r as debugWarn } from "./support-ULZQgbko.js";
+import { r as debugWarn } from "./support-GJphyuEe.js";
 var registry = /* @__PURE__ */ new Map();
 var listeners = /* @__PURE__ */ new Set();
 function registerNaturalSize(key, width, height) {

package/dist/core/{motionBlur-BnthNfqm.js → motionBlur-CiNghKu6.js}

@@ -1,6 +1,5 @@
-import { $n as vec4f, En as cos, In as mix, J as edgeClampUV, Jn as vec2f, Kn as step, Mn as fract, Nn as length, On as dot, Pn as max, Tn as clamp, Tt as unpremultiplyAlpha, Un as sin, Wn as smoothstep, Zn as vec3f, at as call, bn as select, dt as vec4, et as sampleCatmullRomExpr, hr as f32, in as DEG_TO_RAD$1, jn as floor, lr as mod, lt as floatE, mn as typegpu_default, q as applyEdgeHandlingExpr, sr as struct, xn as abs } from "./lower-z2vuXP8M.js";
-import { l as hash22, o as hash11$1, s as hash12 } from "./noise-B3Oq1k3_.js";
-import { E as unrolledTapGather, b as gaussianTapWeights } from "./blur-CpGmUq81.js";
+import { $n as clamp, An as DEG_TO_RAD$1, Br as f32, Et as unpremultiplyAlpha, J as applyEdgeHandlingExpr, Jn as select, Nr as struct, Pr as mod, Tr as vec4f, Y as edgeClampUV, Yn as abs, _r as smoothstep, ar as floor, cr as max, er as cos, ft as vec4, gn as hash22, gr as sin, mn as hash12, nr as dot, or as fract, ot as call, pn as hash11$1, sr as length, tt as sampleCatmullRomExpr, ur as mix, ut as floatE, wr as vec3f, xr as vec2f, yr as step, zn as typegpu_default } from "./lower-DSk_KxOY.js";
+import { E as unrolledTapGather, b as gaussianTapWeights } from "./blur-BwjlF0Uk.js";
 var DEG_TO_RAD = DEG_TO_RAD$1;
 const MOTION_BLUR_WEIGHTS = gaussianTapWeights(32, .8);
 const linearBlurTapCoord = typegpu_default.fn([

package/dist/core/{noise-DQWgxDEf.js → noise-DrbAbu3H.js}

@@ -1,10 +1,9 @@
-import { At as hsvToRgb, Gt as pixelGridDomain, Ht as aspectScaledDomain, Jn as vec2f, Kt as timeAxisDomain, Mt as lchToLab, Nt as mixColorsLinear, Pt as mixColorsVariants, Rt as oklabToRgb, Tn as clamp, Tt as unpremultiplyAlpha, Vt as sRGBToP3, a as uniformOf, at as call, dt as vec4, hr as f32, it as asLocal, jt as labToRgb, kt as hslToRgb, lt as floatE, mn as typegpu_default, nt as ZERO, ut as mixExpr, zt as oklchToOklab } from "./lower-z2vuXP8M.js";
-import { S as wool12, _ as scratches12, a as gabor12, h as perlin12d, i as erosion12, t as blue12, v as stone12, x as wavelet12 } from "./noise-B3Oq1k3_.js";
-import { a as toneSignedInverted, r as signedToUnit } from "./tone-BA0D_veZ.js";
-import { C as worleyModeScale, S as worleyModeNum, T as worleyTone, _ as veinWave$1, a as fbmNormalize, b as worleyDistNum, d as strandsField, f as strandsTonePow, g as veinLadder$1, h as veinDepth, i as curlMagnitude, l as rawAspectScaledDomain, m as transformWorleyMode$1, n as cellBorders$1, o as fractalSum, p as transformWorleyDistance$1, r as cellFill$1, s as marbleTurbulence$1, t as aspectPlane, u as rotatedCenteredDomain, v as voronoiCells, w as worleyNormalize, x as worleyHash$1, y as worleyCells } from "./noisePaints-Cs2Q1Xk9.js";
-import { t as animatedTime } from "./porters-B1UjrM1y.js";
-import { n as noiseToneKColor } from "./noiseColor-CMKVWP1J.js";
-import { c as rampOver, p as stops, t as colorSpaceModeOf } from "./fields-Cg5kOBDV.js";
+import { $n as clamp, Br as f32, Et as unpremultiplyAlpha, On as wavelet12, Pt as mixColorsLinear, Sn as perlin12d, Tn as stone12, Ut as aspectScaledDomain, Yt as timeAxisDomain, at as asLocal, cn as blue12, dn as erosion12, dt as mixExpr, fn as gabor12, ft as vec4, kn as wool12, n as paintFrame, o as uniformOf, ot as call, qt as pixelGridDomain, rt as ZERO, ut as floatE, wn as scratches12, xr as vec2f, zn as typegpu_default } from "./lower-DSk_KxOY.js";
+import { i as signedToUnit, o as toneSignedInverted } from "./tone-Ax72n2WU.js";
+import { _ as worleyHash$1, a as fbmNormalize, b as worleyNormalize, c as rawAspectScaledDomain, d as toneLift, f as transformWorleyDistance$1, g as worleyDistNum, h as worleyCells, i as curlMagnitude, l as ribbonsField, m as voronoiCells, n as cellBorders$1, o as fractalSum, p as transformWorleyMode$1, r as cellFill$1, t as aspectPlane, u as rotatedCenteredDomain, v as worleyModeNum, x as worleyTone, y as worleyModeScale } from "./noisePaints-DV5jKo1A.js";
+import { Tt as backConvertToP3, t as animatedTime } from "./porters-j4QbEOqj.js";
+import { D as noiseToneKColor, f as rampOver, n as colorSpaceModeOf, y as stops } from "./fields-Cv-wBDLP.js";
+import { C as mul, j as sin, n as add } from "./math-DCQU6EQz.js";
 const reliefPos = typegpu_default.fn([
 	vec2f,
 	f32,
@@ -282,15 +281,46 @@ function applyNoiseReliefExpr(params, heightFn, heightHint) {
 	]);
 	return vec4(straight.member("rgb").mul(brightness), straight.member("a"));
 }
-function frame(params) {
-	return {
-		uv: params.uvContext ?? params.ctx.uv,
-		viewport: params.effectiveViewportSize ?? params.ctx.viewportSize
+function waves(axes, schedule) {
+	const axisTerm = (axis, k, name) => {
+		if (k === void 0) return void 0;
+		if (axis === void 0) throw new Error(`std: waves() schedule uses axis '${name}' but the axes object doesn't provide it`);
+		return k === 1 ? axis : mul(axis, k);
 	};
+	const waveExpr = (w) => {
+		const parts = [
+			axisTerm(axes.x, w.x, "x"),
+			axisTerm(axes.y, w.y, "y"),
+			axisTerm(axes.t, w.t, "t"),
+			w.phase
+		].filter((part) => part !== void 0);
+		if (parts.length === 0) throw new Error("std: a wave needs at least one axis coefficient or phase");
+		return sin(parts.reduce((a, b) => add(a, b)));
+	};
+	const terms = schedule.map((term) => {
+		if (term.waves.length === 0) throw new Error("std: a waves() term needs at least one wave");
+		const product = term.waves.map(waveExpr).reduce((a, b) => mul(a, b));
+		return term.weight === void 0 || term.weight === 1 ? product : mul(product, term.weight);
+	});
+	if (terms.length === 0) throw new Error("std: waves() needs at least one term");
+	return terms.reduce((a, b) => add(a, b));
+}
+function wavyLine(opts) {
+	return waves({
+		x: opts.along,
+		t: opts.time
+	}, opts.waves.map((w) => ({
+		waves: [{
+			x: w.freq,
+			t: w.speed,
+			phase: w.phase
+		}],
+		weight: w.amount
+	})));
 }
 function seededPlane(field, slots) {
 	return (params, uv) => {
-		const { viewport } = frame(params);
+		const { viewport } = paintFrame(params);
 		return field(params, call(aspectScaledDomain, "aspectScaledDomain", [
 			uv,
 			viewport,
@@ -301,7 +331,7 @@ function seededPlane(field, slots) {
 }
 function rawPlane(field, slots) {
 	return (params, uv) => {
-		const { viewport } = frame(params);
+		const { viewport } = paintFrame(params);
 		return field(params, call(rawAspectScaledDomain, "rawAspectScaledDomain", [
 			uv,
 			viewport,
@@ -312,7 +342,7 @@ function rawPlane(field, slots) {
 }
 function pixelGrid(field, slots) {
 	return (params, uv) => {
-		const { viewport } = frame(params);
+		const { viewport } = paintFrame(params);
 		return field(params, call(pixelGridDomain, "pixelGridDomain", [
 			uv,
 			viewport,
@@ -321,12 +351,6 @@ function pixelGrid(field, slots) {
 		]));
 	};
 }
-function scaledPlane(field, slots) {
-	return (params, uv) => {
-		const { viewport } = frame(params);
-		return field(params, asLocal(call(aspectPlane, "aspectPlane", [uv, viewport]).mul(uniformOf(slots.scale, params)), "plane"));
-	};
-}
 function evolving(field, opts) {
 	return (params, coord) => field(params, call(timeAxisDomain, "timeAxisDomain", [
 		coord,
@@ -395,12 +419,9 @@ function linearPair(a, b) {
 		t
 	]);
 }
-function mixColorsIn(space, params) {
-	return mixColorsVariants[space ? colorSpaceModeOf(params.propValues[space.name]) : 0] ?? mixColorsLinear;
-}
 function fractalNoise(slots) {
 	const ridges = (params, uv) => {
-		const { viewport } = frame(params);
+		const { viewport } = paintFrame(params);
 		return call(fbmNormalize, "fbmNormalize", [call(fractalSum, "fractalSum", [
 			call(rotatedCenteredDomain, "rotatedCenteredDomain", [
 				uv,
@@ -418,7 +439,7 @@ function fractalNoise(slots) {
 }
 function worleyNoise(slots) {
 	const cells = (params, uv) => {
-		const { viewport } = frame(params);
+		const { viewport } = paintFrame(params);
 		const modeNum = worleyModeNum(params.propValues[slots.mode.name]);
 		const distNum = worleyDistNum(params.propValues[slots.distance.name]);
 		const octavesNum = Math.max(1, Math.min(4, Math.round(params.propValues[slots.octaves.name] ?? 1)));
@@ -440,42 +461,9 @@ function worleyNoise(slots) {
 		balance: slots.balance
 	}), stops(slots.space));
 }
-function marbleTurbulence(slots) {
-	return (params, pos) => call(marbleTurbulence$1, "marbleTurbulence", [
-		pos,
-		uniformOf(slots.seed, params),
-		animatedTime(params)
-	]);
-}
-function veinWave(turbulence, slots) {
-	return (params, pos) => call(veinWave$1, "veinWave", [
-		pos.member("x"),
-		turbulence(params, pos),
-		uniformOf(slots.turbulence, params)
-	]);
-}
-function veinLadder(vein, slots) {
-	return (params, pos) => call(veinLadder$1, "veinLadder", [vein(params, pos), call(veinDepth, "veinDepth", [pos, uniformOf(slots.seed, params)])]);
-}
-function colorLadder(field, slots) {
-	return (params) => {
-		const { uv } = frame(params);
-		const bands = asLocal(field(params, uv), "bands");
-		const variant = mixColorsIn(slots.space, params);
-		return call(variant, "mixColors", [
-			call(variant, "mixColors", [
-				uniformOf(slots.colors[0], params),
-				uniformOf(slots.colors[1], params),
-				bands.member("x")
-			]),
-			uniformOf(slots.colors[2], params),
-			bands.member("y")
-		]);
-	};
-}
 function cellDistances(slots) {
 	return (params, uv) => {
-		const { viewport } = frame(params);
+		const { viewport } = paintFrame(params);
 		return call(voronoiCells, "voronoiNearest2", [
 			call(aspectPlane, "aspectPlane", [uv, viewport]).mul(uniformOf(slots.scale, params)),
 			animatedTime(params),
@@ -495,21 +483,11 @@ function cellBorders(cells, slots) {
 }
 function borderOverlay(paint, mask, slots) {
 	return (params) => {
-		const { uv } = frame(params);
+		const { uv } = paintFrame(params);
 		const base = asLocal(paint(params), "base");
 		return vec4(mixExpr(uniformOf(slots.color, params).member("rgb"), base.member("rgb"), mask(params, uv)), base.member("a"));
 	};
 }
-function backConvert(conv, mode) {
-	switch (mode) {
-		case 1: return call(sRGBToP3, "sRGBToP3", [call(oklabToRgb, "oklabToRgb", [call(oklchToOklab, "oklchToOklab", [conv])])]);
-		case 2: return call(sRGBToP3, "sRGBToP3", [call(oklabToRgb, "oklabToRgb", [conv])]);
-		case 3: return call(sRGBToP3, "sRGBToP3", [call(hslToRgb, "hslToRgb", [conv])]);
-		case 4: return call(sRGBToP3, "sRGBToP3", [call(hsvToRgb, "hsvToRgb", [conv])]);
-		case 5: return call(sRGBToP3, "sRGBToP3", [call(labToRgb, "labToRgb", [call(lchToLab, "lchToLab", [conv])])]);
-		default: return conv;
-	}
-}
 function overRgb(paint, ...stages) {
 	return (params) => {
 		const base = paint(params);
@@ -520,22 +498,22 @@ function overRgb(paint, ...stages) {
 }
 function backToP3(slots) {
 	return (rgb, params) => {
-		return backConvert(rgb, slots.space ? colorSpaceModeOf(params.propValues[slots.space.name]) : 0);
+		return backConvertToP3(rgb, slots.space ? colorSpaceModeOf(params.propValues[slots.space.name]) : 0);
 	};
 }
 function tonePow() {
-	return (rgb) => call(strandsTonePow, "strandsTonePow", [rgb]);
+	return (rgb) => call(toneLift, "toneLift", [rgb]);
 }
-function strandsRibbons(slots) {
+function ribbons(slots) {
 	return (params) => {
 		const { uniforms } = params;
-		const { uv, viewport } = frame(params);
+		const { uv, viewport } = paintFrame(params);
 		const waveT = animatedTime(params);
 		const colorT = animatedTime(params, void 0, "_animTime_color");
 		const packed1 = vec4(uniformOf(slots.amplitude, params), uniformOf(slots.frequency, params), uniformOf(slots.count, params), uniformOf(slots.width, params));
 		const packed2 = vec4(uniformOf(slots.softness, params), uniformOf(slots.spread, params), uniformOf(slots.colorScale, params), uniformOf(slots.colorVariance, params));
 		const packed3 = vec4(uniformOf(slots.pinEdges, params), waveT, colorT, uniforms.stopCount);
-		return call(strandsField, "strandsField", [
+		return call(ribbonsField, "ribbonsField", [
 			uv,
 			viewport,
 			uniformOf(slots.from, params),
@@ -565,4 +543,4 @@ function noiseRelief(basis) {
 const transformWorleyMode = transformWorleyMode$1;
 const transformWorleyDistance = transformWorleyDistance$1;
 const worleyHash = worleyHash$1;
-export { veinLadder as A, seededPlane as C, transformWorleyDistance as D, tonePow as E, waveletBands as M, worleyHash as N, transformWorleyMode as O, worleyNoise as P, scratchStreaks as S, strandsRibbons as T, overRgb as _, cellDistances as a, reliefBases as b, curlSpeed as c, fractalNoise as d, gaborGrains as f, noiseTone as g, noiseRelief as h, cellBorders as i, veinWave as j, unitized as k, erosionRidges as l, marbleTurbulence as m, blueSpeckle as n, cellFill as o, linearPair as p, borderOverlay as r, colorLadder as s, backToP3 as t, evolving as u, pixelGrid as v, signedTone as w, scaledPlane as x, rawPlane as y };
+export { worleyHash as A, tonePow as C, waveletBands as D, unitized as E, waves as O, signedTone as S, transformWorleyMode as T, rawPlane as _, cellDistances as a, scratchStreaks as b, erosionRidges as c, gaborGrains as d, linearPair as f, pixelGrid as g, overRgb as h, cellBorders as i, worleyNoise as j, wavyLine as k, evolving as l, noiseTone as m, blueSpeckle as n, cellFill as o, noiseRelief as p, borderOverlay as r, curlSpeed as s, backToP3 as t, fractalNoise as u, reliefBases as v, transformWorleyDistance as w, seededPlane as x, ribbons as y };

package/dist/core/{noiseColor-XppoAmXi.js → noiseColor-DKo-P8T0.js}

@@ -1,5 +1,5 @@
-import { ct as colorStopsPropConfig } from "./porters-B1UjrM1y.js";
-import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CoIwF5JU.js";
+import { vt as colorStopsPropConfig } from "./porters-j4QbEOqj.js";
+import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-COlfAEsk.js";
 function noiseColorProps() {
 	return {
 		colorA: {