shaders 3.0.448 → 3.0.449

package/dist/core/{TimeTrail-CE2XumxR.js → TimeTrail-CuFGvzFi.js}

@@ -1,50 +1,51 @@
-import { Bt as ZERO, Ht as call, J as std, Kt as floatE, Tn as d, X as createGuardedCompute, cn as unpremultiplyAlpha, dn as hslToRgb, ln as colorMixing_exports, n as tgpu, on as blendModes, xn as rgbToHsl } from "./coords-BkIjixe_.js";
-import { a as transformColor } from "./transformations-t0d2-uSX.js";
+import { Ct as floor, Et as max, F as colorMixing_exports, Gt as textureStorage2d, Lt as smoothstep, N as unpremultiplyAlpha, Ot as mix, R as hslToRgb, Vt as data_exports, Wt as texture2d, Xt as struct, Y as rgbToHsl, _ as floatE, _t as clamp, an as f32, at as textureStore, bt as dot, d as ZERO, et as src_default, in as vec4f, it as textureLoad, j as blendModes, mt as abs, nn as vec3f, nt as std_exports, p as call, pt as select, rt as textureDimensions, sn as u32, tn as vec2u, wt as fract } from "./edges-BXNBKxSN.js";
+import { n as createGuardedCompute } from "./compute-BjeJ0sIA.js";
+import { a as transformColor } from "./transformations-CsPUHppB.js";
 var STATE_RES = 768;
 var STATE_FORMAT = "rgba16float";
 var DIFFUSE_TEXELS = 2.5;
 var DRIFT_SCALE = .5;
 var RAINBOW_RATE = .35;
-var TrailParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(d.struct({
-	persistence: d.f32,
-	diffusion: d.f32,
-	driftX: d.f32,
-	driftY: d.f32,
-	dt: d.f32,
-	zoom: d.f32,
-	hueRate: d.f32,
-	blendMode: d.f32,
-	motionMode: d.f32,
-	motionThreshold: d.f32
+var TrailParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+	persistence: f32,
+	diffusion: f32,
+	driftX: f32,
+	driftY: f32,
+	dt: f32,
+	zoom: f32,
+	hueRate: f32,
+	blendMode: f32,
+	motionMode: f32,
+	motionThreshold: f32
 }), "TrailParams");
-var trailLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
-	src: { texture: d.texture2d(d.f32) },
-	prev: { texture: d.texture2d(d.f32) },
-	next: { storageTexture: d.textureStorage2d(STATE_FORMAT, "write-only") },
-	display: { storageTexture: d.textureStorage2d(STATE_FORMAT, "write-only") },
-	prevLive: { texture: d.texture2d(d.f32) },
-	prevLiveOut: { storageTexture: d.textureStorage2d(STATE_FORMAT, "write-only") },
+var trailLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
+	src: { texture: texture2d(f32) },
+	prev: { texture: texture2d(f32) },
+	next: { storageTexture: textureStorage2d(STATE_FORMAT, "write-only") },
+	display: { storageTexture: textureStorage2d(STATE_FORMAT, "write-only") },
+	prevLive: { texture: texture2d(f32) },
+	prevLiveOut: { storageTexture: textureStorage2d(STATE_FORMAT, "write-only") },
 	params: { uniform: TrailParams }
 }), "trailLayout");
-const timeTrailSampleHistory = tgpu.fn([d.f32, d.f32], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uvx, uvy) => {
+const timeTrailSampleHistory = src_default.fn([f32, f32], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uvx, uvy) => {
 	"use gpu";
-	const res = d.f32(STATE_RES);
+	const res = f32(STATE_RES);
 	const maxT = __tsover_sub(res, 1);
-	const su = __tsover_sub(__tsover_mul(std.clamp(uvx, d.f32(0), d.f32(1)), res), .5);
-	const sv = __tsover_sub(__tsover_mul(std.clamp(uvy, d.f32(0), d.f32(1)), res), .5);
-	const x0 = std.floor(su);
-	const y0 = std.floor(sv);
+	const su = __tsover_sub(__tsover_mul(clamp(uvx, f32(0), f32(1)), res), .5);
+	const sv = __tsover_sub(__tsover_mul(clamp(uvy, f32(0), f32(1)), res), .5);
+	const x0 = floor(su);
+	const y0 = floor(sv);
 	const fx = __tsover_sub(su, x0);
 	const fy = __tsover_sub(sv, y0);
-	const ix0 = d.u32(std.clamp(x0, d.f32(0), maxT));
-	const ix1 = d.u32(std.clamp(__tsover_add(x0, 1), d.f32(0), maxT));
-	const iy0 = d.u32(std.clamp(y0, d.f32(0), maxT));
-	const iy1 = d.u32(std.clamp(__tsover_add(y0, 1), d.f32(0), maxT));
-	const p00 = std.textureLoad(trailLayout.$.prev, d.vec2u(ix0, iy0), 0);
-	const p10 = std.textureLoad(trailLayout.$.prev, d.vec2u(ix1, iy0), 0);
-	const p01 = std.textureLoad(trailLayout.$.prev, d.vec2u(ix0, iy1), 0);
-	const p11 = std.textureLoad(trailLayout.$.prev, d.vec2u(ix1, iy1), 0);
-	return std.mix(std.mix(p00, p10, fx), std.mix(p01, p11, fx), fy);
+	const ix0 = u32(clamp(x0, f32(0), maxT));
+	const ix1 = u32(clamp(__tsover_add(x0, 1), f32(0), maxT));
+	const iy0 = u32(clamp(y0, f32(0), maxT));
+	const iy1 = u32(clamp(__tsover_add(y0, 1), f32(0), maxT));
+	const p00 = textureLoad(trailLayout.$.prev, vec2u(ix0, iy0), 0);
+	const p10 = textureLoad(trailLayout.$.prev, vec2u(ix1, iy0), 0);
+	const p01 = textureLoad(trailLayout.$.prev, vec2u(ix0, iy1), 0);
+	const p11 = textureLoad(trailLayout.$.prev, vec2u(ix1, iy1), 0);
+	return mix(mix(p00, p10, fx), mix(p01, p11, fx), fy);
 }), {
 	v: 1,
 	name: void 0,
@@ -532,22 +533,22 @@ const timeTrailSampleHistory = tgpu.fn([d.f32, d.f32], d.vec4f)(/* @__PURE__ */
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		STATE_RES,
-		std,
+		std: std_exports,
 		trailLayout
 	})
 }) && $.f)({}));
-const timeTrailMotionMask = tgpu.fn([
-	d.vec4f,
-	d.vec4f,
-	d.f32
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((live, prev, threshold) => {
+const timeTrailMotionMask = src_default.fn([
+	vec4f,
+	vec4f,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((live, prev, threshold) => {
 	"use gpu";
-	const dRgb = std.abs(live.xyz.sub(prev.xyz));
-	const dA = std.abs(__tsover_sub(live.w, prev.w));
-	const diff = __tsover_add(std.dot(dRgb, d.vec3f(.299, .587, .114)), dA);
-	return std.smoothstep(threshold, __tsover_add(__tsover_mul(threshold, 2), .001), diff);
+	const dRgb = abs(live.xyz.sub(prev.xyz));
+	const dA = abs(__tsover_sub(live.w, prev.w));
+	const diff = __tsover_add(dot(dRgb, vec3f(.299, .587, .114)), dA);
+	return smoothstep(threshold, __tsover_add(__tsover_mul(threshold, 2), .001), diff);
 }), {
 	v: 1,
 	name: void 0,
@@ -679,14 +680,14 @@ const timeTrailMotionMask = tgpu.fn([
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
-const timeTrailRotateHue = tgpu.fn([d.vec3f, d.f32], d.vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((rgb, amount) => {
+const timeTrailRotateHue = src_default.fn([vec3f, f32], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((rgb, amount) => {
 	"use gpu";
 	const hsl = rgbToHsl(rgb);
-	return hslToRgb(d.vec3f(std.fract(__tsover_add(hsl.x, amount)), hsl.y, hsl.z));
+	return hslToRgb(vec3f(fract(__tsover_add(hsl.x, amount)), hsl.y, hsl.z));
 }), {
 	v: 1,
 	name: void 0,
@@ -772,17 +773,17 @@ const timeTrailRotateHue = tgpu.fn([d.vec3f, d.f32], d.vec3f)(/* @__PURE__ */ ((
 	},
 	externals: () => ({
 		colorMixing: colorMixing_exports,
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
-const timeTrailKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+const timeTrailKernel = src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
 	"use gpu";
 	const P = trailLayout.$.params;
-	const res = d.f32(STATE_RES);
-	const fx = __tsover_div(__tsover_add(d.f32(cx), .5), res);
-	const fy = __tsover_div(__tsover_add(d.f32(cy), .5), res);
-	const zoom = std.max(P.zoom, .01);
+	const res = f32(STATE_RES);
+	const fx = __tsover_div(__tsover_add(f32(cx), .5), res);
+	const fy = __tsover_div(__tsover_add(f32(cy), .5), res);
+	const zoom = max(P.zoom, .01);
 	const bx = __tsover_sub(__tsover_add(__tsover_div(__tsover_sub(fx, .5), zoom), .5), __tsover_mul(__tsover_mul(P.driftX, P.dt), DRIFT_SCALE));
 	const by = __tsover_sub(__tsover_add(__tsover_div(__tsover_sub(fy, .5), zoom), .5), __tsover_mul(__tsover_mul(P.driftY, P.dt), DRIFT_SCALE));
 	const o = __tsover_mul(P.diffusion, __tsover_div(DIFFUSE_TEXELS, res));
@@ -790,41 +791,39 @@ const timeTrailKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalT
 	const edgesSum = timeTrailSampleHistory(__tsover_sub(bx, o), by).add(timeTrailSampleHistory(__tsover_add(bx, o), by)).add(timeTrailSampleHistory(bx, __tsover_sub(by, o))).add(timeTrailSampleHistory(bx, __tsover_add(by, o))).mul(2);
 	const cornersSum = timeTrailSampleHistory(__tsover_sub(bx, o), __tsover_sub(by, o)).add(timeTrailSampleHistory(__tsover_add(bx, o), __tsover_sub(by, o))).add(timeTrailSampleHistory(__tsover_sub(bx, o), __tsover_add(by, o))).add(timeTrailSampleHistory(__tsover_add(bx, o), __tsover_add(by, o)));
 	const decayed = c.add(edgesSum).add(cornersSum).div(16).mul(P.persistence);
-	const a = std.max(decayed.w, 1e-4);
+	const a = max(decayed.w, 1e-4);
 	const rotated = timeTrailRotateHue(decayed.xyz.div(a), P.hueRate).mul(decayed.w);
-	const trail = d.vec4f(std.select(decayed.xyz, rotated, std.abs(P.hueRate) > 1e-4), decayed.w);
-	const srcDims = std.textureDimensions(trailLayout.$.src);
-	const srcW = d.f32(srcDims.x);
-	const srcH = d.f32(srcDims.y);
+	const trail = vec4f(select(decayed.xyz, rotated, abs(P.hueRate) > 1e-4), decayed.w);
+	const srcDims = textureDimensions(trailLayout.$.src);
+	const srcW = f32(srcDims.x);
+	const srcH = f32(srcDims.y);
 	const cu = __tsover_sub(__tsover_mul(fx, srcW), .5);
 	const cv = __tsover_sub(__tsover_mul(fy, srcH), .5);
-	const cx0 = std.floor(cu);
-	const cy0 = std.floor(cv);
+	const cx0 = floor(cu);
+	const cy0 = floor(cv);
 	const cfx = __tsover_sub(cu, cx0);
 	const cfy = __tsover_sub(cv, cy0);
-	const jx0 = d.u32(std.clamp(cx0, d.f32(0), __tsover_sub(srcW, 1)));
-	const jx1 = d.u32(std.clamp(__tsover_add(cx0, 1), d.f32(0), __tsover_sub(srcW, 1)));
-	const jy0 = d.u32(std.clamp(cy0, d.f32(0), __tsover_sub(srcH, 1)));
-	const jy1 = d.u32(std.clamp(__tsover_add(cy0, 1), d.f32(0), __tsover_sub(srcH, 1)));
-	const s00 = std.textureLoad(trailLayout.$.src, d.vec2u(jx0, jy0), 0);
-	const s10 = std.textureLoad(trailLayout.$.src, d.vec2u(jx1, jy0), 0);
-	const s01 = std.textureLoad(trailLayout.$.src, d.vec2u(jx0, jy1), 0);
-	const s11 = std.textureLoad(trailLayout.$.src, d.vec2u(jx1, jy1), 0);
-	const live = std.mix(std.mix(s00, s10, cfx), std.mix(s01, s11, cfx), cfy);
-	const mMotion = timeTrailMotionMask(live, std.textureLoad(trailLayout.$.prevLive, d.vec2u(cx, cy), 0), P.motionThreshold);
-	const m = std.select(d.f32(1), mMotion, P.motionMode > .5);
-	const stamp = d.vec4f(live.xyz.mul(m), __tsover_mul(live.w, m));
+	const jx0 = u32(clamp(cx0, f32(0), __tsover_sub(srcW, 1)));
+	const jx1 = u32(clamp(__tsover_add(cx0, 1), f32(0), __tsover_sub(srcW, 1)));
+	const jy0 = u32(clamp(cy0, f32(0), __tsover_sub(srcH, 1)));
+	const jy1 = u32(clamp(__tsover_add(cy0, 1), f32(0), __tsover_sub(srcH, 1)));
+	const s00 = textureLoad(trailLayout.$.src, vec2u(jx0, jy0), 0);
+	const s10 = textureLoad(trailLayout.$.src, vec2u(jx1, jy0), 0);
+	const s01 = textureLoad(trailLayout.$.src, vec2u(jx0, jy1), 0);
+	const s11 = textureLoad(trailLayout.$.src, vec2u(jx1, jy1), 0);
+	const live = mix(mix(s00, s10, cfx), mix(s01, s11, cfx), cfy);
+	const mMotion = timeTrailMotionMask(live, textureLoad(trailLayout.$.prevLive, vec2u(cx, cy), 0), P.motionThreshold);
+	const m = select(f32(1), mMotion, P.motionMode > .5);
+	const stamp = vec4f(live.xyz.mul(m), __tsover_mul(live.w, m));
 	const outA = __tsover_add(stamp.w, __tsover_mul(trail.w, __tsover_sub(1, stamp.w)));
 	const rgbNormal = stamp.xyz.add(trail.xyz.mul(__tsover_sub(1, stamp.w)));
 	const rgbScreen = stamp.xyz.add(trail.xyz).sub(stamp.xyz.mul(trail.xyz));
 	const rgbAdd = stamp.xyz.add(trail.xyz);
-	const rgbSN = std.select(rgbNormal, rgbScreen, P.blendMode > .5);
-	const rgb = std.select(rgbSN, rgbAdd, P.blendMode > 1.5);
-	const outC = d.vec4f(rgb, outA);
-	const disp = std.select(outC, trail, P.motionMode > .5);
-	std.textureStore(trailLayout.$.next, d.vec2u(cx, cy), outC);
-	std.textureStore(trailLayout.$.display, d.vec2u(cx, cy), disp);
-	std.textureStore(trailLayout.$.prevLiveOut, d.vec2u(cx, cy), live);
+	const outC = vec4f(select(select(rgbNormal, rgbScreen, P.blendMode > .5), rgbAdd, P.blendMode > 1.5), outA);
+	const disp = select(outC, trail, P.motionMode > .5);
+	textureStore(trailLayout.$.next, vec2u(cx, cy), outC);
+	textureStore(trailLayout.$.display, vec2u(cx, cy), disp);
+	textureStore(trailLayout.$.prevLiveOut, vec2u(cx, cy), live);
 }), {
 	v: 1,
 	name: void 0,
@@ -2274,9 +2273,9 @@ const timeTrailKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalT
 	},
 	externals: () => ({
 		trailLayout,
-		d,
+		d: data_exports,
 		STATE_RES,
-		std,
+		std: std_exports,
 		DRIFT_SCALE,
 		DIFFUSE_TEXELS,
 		timeTrailSampleHistory,
@@ -2284,13 +2283,11 @@ const timeTrailKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalT
 		timeTrailMotionMask
 	})
 }) && $.f)({})).$name("timeTrailStep");
-const timeTrailColorize = tgpu.fn([d.vec4f, d.vec4f], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((trail, tint) => {
+const timeTrailColorize = src_default.fn([vec4f, vec4f], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((trail, tint) => {
 	"use gpu";
-	const a = std.max(trail.w, 1e-4);
-	const straight = trail.xyz.div(a);
-	const lum = std.dot(straight, d.vec3f(.299, .587, .114));
-	const colored = tint.xyz.mul(__tsover_mul(lum, 1.5));
-	return d.vec4f(colored.mul(trail.w), trail.w);
+	const a = max(trail.w, 1e-4);
+	const lum = dot(trail.xyz.div(a), vec3f(.299, .587, .114));
+	return vec4f(tint.xyz.mul(__tsover_mul(lum, 1.5)).mul(trail.w), trail.w);
 }), {
 	v: 1,
 	name: void 0,
@@ -2413,11 +2410,11 @@ const timeTrailColorize = tgpu.fn([d.vec4f, d.vec4f], d.vec4f)(/* @__PURE__ */ (
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
-const timeTrailScaleTrail = tgpu.fn([d.vec4f, d.f32], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((trail, k) => {
+const timeTrailScaleTrail = src_default.fn([vec4f, f32], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((trail, k) => {
 	"use gpu";
 	return trail.mul(k);
 }), {

package/dist/core/{Tint-BTmcGjEl.js → Tint-C6zMMsYH.js}

@@ -1,14 +1,13 @@
-import { Bt as ZERO, Ht as call, J as std, Tn as d, n as tgpu } from "./coords-BkIjixe_.js";
-import { a as transformColor } from "./transformations-t0d2-uSX.js";
-const tintColorPlain = tgpu.fn([
-	d.vec4f,
-	d.vec4f,
-	d.f32
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, tintColor, amount) => {
+import { Et as max, Ot as mix, Vt as data_exports, an as f32, bt as dot, d as ZERO, et as src_default, in as vec4f, nn as vec3f, nt as std_exports, p as call } from "./edges-BXNBKxSN.js";
+import { a as transformColor } from "./transformations-CsPUHppB.js";
+const tintColorPlain = src_default.fn([
+	vec4f,
+	vec4f,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, tintColor, amount) => {
 	"use gpu";
-	const rgb = d.vec3f(color.x, color.y, color.z);
-	const tinted = std.mix(rgb, d.vec3f(tintColor.x, tintColor.y, tintColor.z), d.vec3f(amount));
-	return d.vec4f(tinted.x, tinted.y, tinted.z, color.w);
+	const tinted = mix(vec3f(color.x, color.y, color.z), vec3f(tintColor.x, tintColor.y, tintColor.z), vec3f(amount));
+	return vec4f(tinted.x, tinted.y, tinted.z, color.w);
 }), {
 	v: 1,
 	name: void 0,
@@ -140,23 +139,23 @@ const tintColorPlain = tgpu.fn([
 		"externalNames": ["d", "std"]
 	},
 	externals: () => ({
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
-const tintColorPreserve = tgpu.fn([
-	d.vec4f,
-	d.vec4f,
-	d.f32
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, tintColor, amount) => {
+const tintColorPreserve = src_default.fn([
+	vec4f,
+	vec4f,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, tintColor, amount) => {
 	"use gpu";
-	const rgb = d.vec3f(color.x, color.y, color.z);
-	const tinted = std.mix(rgb, d.vec3f(tintColor.x, tintColor.y, tintColor.z), d.vec3f(amount));
-	const luminanceWeights = d.vec3f(.299, .587, .114);
-	const originalLum = std.dot(rgb, luminanceWeights);
-	const tintedLum = std.dot(tinted, luminanceWeights);
-	const result = tinted.mul(__tsover_div(originalLum, std.max(tintedLum, 1e-4)));
-	return d.vec4f(result.x, result.y, result.z, color.w);
+	const rgb = vec3f(color.x, color.y, color.z);
+	const tinted = mix(rgb, vec3f(tintColor.x, tintColor.y, tintColor.z), vec3f(amount));
+	const luminanceWeights = vec3f(.299, .587, .114);
+	const originalLum = dot(rgb, luminanceWeights);
+	const tintedLum = dot(tinted, luminanceWeights);
+	const result = tinted.mul(__tsover_div(originalLum, max(tintedLum, 1e-4)));
+	return vec4f(result.x, result.y, result.z, color.w);
 }), {
 	v: 1,
 	name: void 0,
@@ -357,8 +356,8 @@ const tintColorPreserve = tgpu.fn([
 		"externalNames": ["d", "std"]
 	},
 	externals: () => ({
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {

package/dist/core/{Trapezoid-CiZCh8QS.js → Trapezoid-kFuxWONU.js}

@@ -1,16 +1,17 @@
-import { B as trapezoidSdf, C as ShapeMask, F as sdf_exports, Ht as call, I as shapeLocalCoords, Jt as vec4, R as strokeMaskFromSdf, Tn as d, gn as mixColorsVariants, hn as mixColorsLinear, n as tgpu } from "./coords-BkIjixe_.js";
-import { a as transformColor, c as transformPosition, l as transformStrokePosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-t0d2-uSX.js";
-const trapezoidShape = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.vec2f,
-	d.f32
+import { $t as vec2f, H as mixColorsLinear, U as mixColorsVariants, an as f32, et as src_default, p as call, y as vec4 } from "./edges-BXNBKxSN.js";
+import { b as trapezoidSdf, g as shapeLocalCoords, h as sdf_exports, n as ShapeMask, v as strokeMaskFromSdf } from "./sdf-R0EN3EvS.js";
+import { a as transformColor, c as transformPosition, l as transformStrokePosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
+const trapezoidShape = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	vec2f,
+	f32
 ], ShapeMask)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, topWidth, bottomWidth, height, rotation, softness, strokeThickness, strokePosition, uv, aspect) => {
 	"use gpu";
 	const local = shapeLocalCoords(center, rotation, uv, aspect);

package/dist/core/{TriangularGrid-BnQOEljy.js → TriangularGrid-FIrpI_qE.js}

@@ -1,50 +1,48 @@
-import { Ht as call, J as std, Jt as vec4, Tn as d, gn as mixColorsVariants, hn as mixColorsLinear, n as tgpu } from "./coords-BkIjixe_.js";
-import { a as transformColor, o as transformColorSpace, r as transformAngle, t as colorSpaceOptions } from "./transformations-t0d2-uSX.js";
-import { t as animatedTime } from "./porters-BmU6G9TR.js";
+import { $t as vec2f, Ct as floor, Dt as min, Et as max, H as mixColorsLinear, It as sin, Lt as smoothstep, U as mixColorsVariants, Vt as data_exports, an as f32, bt as dot, ct as fwidth, et as src_default, mt as abs, nt as std_exports, p as call, vt as cos, wt as fract, y as vec4, zt as step } from "./edges-BXNBKxSN.js";
+import { t as animatedTime } from "./porters-DBK1Aipq.js";
+import { a as transformColor, o as transformColorSpace, r as transformAngle, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
 var DEG_TO_RAD = Math.PI / 180;
 var SQRT3 = Math.sqrt(3);
 var TWO_OVER_SQRT3 = 2 / Math.sqrt(3);
-const triangularGridField = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, cells, thickness, rotation, softness, variation, speedVariance, animTime) => {
+const triangularGridField = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, cells, thickness, rotation, softness, variation, speedVariance, animTime) => {
 	"use gpu";
 	const aspect = __tsover_div(viewport.x, viewport.y);
-	const correctedUV = d.vec2f(__tsover_mul(uv.x, aspect), __tsover_sub(1, uv.y));
+	const correctedUV = vec2f(__tsover_mul(uv.x, aspect), __tsover_sub(1, uv.y));
 	const ang = __tsover_mul(rotation, DEG_TO_RAD);
-	const cosR = std.cos(ang);
-	const sinR = std.sin(ang);
+	const cosR = cos(ang);
+	const sinR = sin(ang);
 	const centerX = __tsover_mul(aspect, .5);
 	const centerY = .5;
 	const cx = __tsover_sub(correctedUV.x, centerX);
 	const cy = __tsover_sub(correctedUV.y, centerY);
-	const p = d.vec2f(__tsover_add(__tsover_sub(__tsover_mul(cx, cosR), __tsover_mul(cy, sinR)), centerX), __tsover_add(__tsover_add(__tsover_mul(cx, sinR), __tsover_mul(cy, cosR)), centerY)).mul(cells);
-	const ps = d.vec2f(__tsover_sub(p.x, __tsover_div(p.y, SQRT3)), __tsover_mul(p.y, TWO_OVER_SQRT3));
-	const rowIndex = std.floor(ps.y);
-	const rowHash = std.fract(__tsover_mul(std.sin(__tsover_mul(rowIndex, 127.1)), 43758.5453));
+	const p = vec2f(__tsover_add(__tsover_sub(__tsover_mul(cx, cosR), __tsover_mul(cy, sinR)), centerX), __tsover_add(__tsover_add(__tsover_mul(cx, sinR), __tsover_mul(cy, cosR)), centerY)).mul(cells);
+	const ps = vec2f(__tsover_sub(p.x, __tsover_div(p.y, SQRT3)), __tsover_mul(p.y, TWO_OVER_SQRT3));
+	const rowIndex = floor(ps.y);
+	const rowHash = fract(__tsover_mul(sin(__tsover_mul(rowIndex, 127.1)), 43758.5453));
 	const speedMod = __tsover_add(1, __tsover_mul(__tsover_mul(__tsover_sub(rowHash, .5), 4), speedVariance));
 	const drift = __tsover_mul(animTime, speedMod);
-	const psShifted = d.vec2f(__tsover_sub(ps.x, drift), ps.y);
-	const cell = std.floor(psShifted);
-	const f = std.fract(psShifted);
-	const upper = std.step(1, __tsover_add(f.x, f.y));
-	const triId = d.vec2f(__tsover_add(__tsover_mul(cell.x, 2), upper), cell.y);
-	const q0 = std.fract(triId.mul(d.vec2f(123.34, 345.45)));
-	const q1 = q0.add(std.dot(q0, q0.add(34.345)));
-	const rand = std.fract(__tsover_mul(q1.x, q1.y));
-	const variedFactor = std.max(__tsover_add(1, __tsover_mul(__tsover_mul(__tsover_sub(rand, .5), 2), variation)), 0);
-	const dEdge = std.min(std.min(std.min(f.x, __tsover_sub(1, f.x)), std.min(f.y, __tsover_sub(1, f.y))), std.abs(__tsover_sub(__tsover_add(f.x, f.y), 1)));
+	const psShifted = vec2f(__tsover_sub(ps.x, drift), ps.y);
+	const cell = floor(psShifted);
+	const f = fract(psShifted);
+	const upper = step(1, __tsover_add(f.x, f.y));
+	const q0 = fract(vec2f(__tsover_add(__tsover_mul(cell.x, 2), upper), cell.y).mul(vec2f(123.34, 345.45)));
+	const q1 = q0.add(dot(q0, q0.add(34.345)));
+	const rand = fract(__tsover_mul(q1.x, q1.y));
+	const variedFactor = max(__tsover_add(1, __tsover_mul(__tsover_mul(__tsover_sub(rand, .5), 2), variation)), 0);
+	const dEdge = min(min(min(f.x, __tsover_sub(1, f.x)), min(f.y, __tsover_sub(1, f.y))), abs(__tsover_sub(__tsover_add(f.x, f.y), 1)));
 	const lineWidth = __tsover_mul(thickness, .02);
-	const aa = __tsover_add(std.max(std.fwidth(ps.x), std.fwidth(ps.y)), __tsover_mul(softness, .5));
-	const lineMask = __tsover_mul(__tsover_sub(1, std.smoothstep(__tsover_sub(lineWidth, aa), __tsover_add(lineWidth, aa), dEdge)), std.step(1e-4, lineWidth));
-	return d.vec2f(lineMask, variedFactor);
+	const aa = __tsover_add(max(fwidth(ps.x), fwidth(ps.y)), __tsover_mul(softness, .5));
+	return vec2f(__tsover_mul(__tsover_sub(1, smoothstep(__tsover_sub(lineWidth, aa), __tsover_add(lineWidth, aa), dEdge)), step(1e-4, lineWidth)), variedFactor);
 }), {
 	v: 1,
 	name: void 0,
@@ -841,9 +839,9 @@ const triangularGridField = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		DEG_TO_RAD,
-		std,
+		std: std_exports,
 		SQRT3,
 		TWO_OVER_SQRT3
 	})

package/dist/core/{Tritone-Ta084wlF.js → Tritone-DyLGtOug.js}

@@ -1,12 +1,9 @@
-import { Bt as ZERO, Ht as call, J as std, Jt as vec4, Tn as d, gn as mixColorsVariants, hn as mixColorsLinear, n as tgpu } from "./coords-BkIjixe_.js";
-import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-t0d2-uSX.js";
-const tritoneFactors = tgpu.fn([d.vec4f, d.f32], d.vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, blendMid) => {
+import { H as mixColorsLinear, Lt as smoothstep, U as mixColorsVariants, Vt as data_exports, an as f32, bt as dot, d as ZERO, et as src_default, in as vec4f, nn as vec3f, nt as std_exports, p as call, y as vec4 } from "./edges-BXNBKxSN.js";
+import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
+const tritoneFactors = src_default.fn([vec4f, f32], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, blendMid) => {
 	"use gpu";
-	const luminance = std.dot(color.xyz, d.vec3f(.299, .587, .114));
-	const shadowToMid = std.smoothstep(__tsover_sub(blendMid, .25), blendMid, luminance);
-	const midToHighlight = std.smoothstep(blendMid, __tsover_add(blendMid, .25), luminance);
-	const finalT = std.smoothstep(__tsover_sub(blendMid, .1), __tsover_add(blendMid, .1), luminance);
-	return d.vec3f(shadowToMid, midToHighlight, finalT);
+	const luminance = dot(color.xyz, vec3f(.299, .587, .114));
+	return vec3f(smoothstep(__tsover_sub(blendMid, .25), blendMid, luminance), smoothstep(blendMid, __tsover_add(blendMid, .25), luminance), smoothstep(__tsover_sub(blendMid, .1), __tsover_add(blendMid, .1), luminance));
 }), {
 	v: 1,
 	name: void 0,
@@ -136,8 +133,8 @@ const tritoneFactors = tgpu.fn([d.vec4f, d.f32], d.vec3f)(/* @__PURE__ */ (($) =
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {

package/dist/core/{Truchet-BxCh_IIp.js → Truchet-B4NI56Zz.js}

@@ -1,10 +1,10 @@
-import { Ht as call, J as std, Tn as d, gn as mixColorsVariants, hn as mixColorsLinear, n as tgpu } from "./coords-BkIjixe_.js";
-import { a as transformColor, o as transformColorSpace, r as transformAngle, t as colorSpaceOptions } from "./transformations-t0d2-uSX.js";
+import { $t as vec2f, Ct as floor, Dt as min, Et as max, H as mixColorsLinear, It as sin, Lt as smoothstep, Tt as length, U as mixColorsVariants, Vt as data_exports, an as f32, bt as dot, ct as fwidth, et as src_default, mt as abs, nt as std_exports, p as call, pt as select, vt as cos, wt as fract, zt as step } from "./edges-BXNBKxSN.js";
+import { a as transformColor, o as transformColorSpace, r as transformAngle, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
 var DEG_TO_RAD = Math.PI / 180;
-var truchetHash = tgpu.fn([d.vec2f], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p) => {
+var truchetHash = src_default.fn([vec2f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p) => {
 	"use gpu";
-	const h = std.dot(p, d.vec2f(127.1, 311.7));
-	return std.fract(__tsover_mul(std.sin(h), 43758.5453));
+	const h = dot(p, vec2f(127.1, 311.7));
+	return fract(__tsover_mul(sin(h), 43758.5453));
 }), {
 	v: 1,
 	name: void 0,
@@ -58,44 +58,42 @@ var truchetHash = tgpu.fn([d.vec2f], d.f32)(/* @__PURE__ */ (($) => (globalThis.
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
-const truchetField = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, cells, thickness, rotation, softness, seed) => {
+const truchetField = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, cells, thickness, rotation, softness, seed) => {
 	"use gpu";
 	const aspect = __tsover_div(viewport.x, viewport.y);
-	const correctedUV = d.vec2f(__tsover_mul(uv.x, aspect), uv.y);
+	const correctedUV = vec2f(__tsover_mul(uv.x, aspect), uv.y);
 	const ang = -__tsover_mul(rotation, DEG_TO_RAD);
-	const cosR = std.cos(ang);
-	const sinR = std.sin(ang);
+	const cosR = cos(ang);
+	const sinR = sin(ang);
 	const centerX = __tsover_mul(aspect, .5);
 	const centerY = .5;
 	const cx = __tsover_sub(correctedUV.x, centerX);
 	const cy = __tsover_sub(correctedUV.y, centerY);
-	const scaledUV = d.vec2f(__tsover_add(__tsover_sub(__tsover_mul(cx, cosR), __tsover_mul(cy, sinR)), centerX), __tsover_add(__tsover_add(__tsover_mul(cx, sinR), __tsover_mul(cy, cosR)), centerY)).mul(cells);
-	const cell = std.floor(scaledUV);
-	const localUV = std.fract(scaledUV);
-	const flip = truchetHash(d.vec2f(__tsover_add(cell.x, seed), __tsover_add(cell.y, seed))) > .5;
-	const c1x = std.select(d.f32(0), d.f32(1), flip);
-	const c2x = std.select(d.f32(1), d.f32(0), flip);
-	const d1 = std.abs(__tsover_sub(std.length(d.vec2f(__tsover_sub(localUV.x, c1x), localUV.y)), .5));
-	const d2 = std.abs(__tsover_sub(std.length(d.vec2f(__tsover_sub(localUV.x, c2x), __tsover_sub(localUV.y, 1))), .5));
-	const arcDist = std.min(d1, d2);
+	const scaledUV = vec2f(__tsover_add(__tsover_sub(__tsover_mul(cx, cosR), __tsover_mul(cy, sinR)), centerX), __tsover_add(__tsover_add(__tsover_mul(cx, sinR), __tsover_mul(cy, cosR)), centerY)).mul(cells);
+	const cell = floor(scaledUV);
+	const localUV = fract(scaledUV);
+	const flip = truchetHash(vec2f(__tsover_add(cell.x, seed), __tsover_add(cell.y, seed))) > .5;
+	const c1x = select(f32(0), f32(1), flip);
+	const c2x = select(f32(1), f32(0), flip);
+	const arcDist = min(abs(__tsover_sub(length(vec2f(__tsover_sub(localUV.x, c1x), localUV.y)), .5)), abs(__tsover_sub(length(vec2f(__tsover_sub(localUV.x, c2x), __tsover_sub(localUV.y, 1))), .5)));
 	const lineWidth = __tsover_mul(thickness, .005);
-	const pixel = __tsover_mul(std.fwidth(scaledUV.x), .5);
+	const pixel = __tsover_mul(fwidth(scaledUV.x), .5);
 	const soft = __tsover_mul(softness, .5);
-	const lo = std.max(__tsover_sub(lineWidth, soft), 0);
+	const lo = max(__tsover_sub(lineWidth, soft), 0);
 	const hi = __tsover_add(__tsover_add(lineWidth, pixel), soft);
-	return __tsover_mul(__tsover_sub(1, std.smoothstep(lo, hi, arcDist)), std.step(1e-4, lineWidth));
+	return __tsover_mul(__tsover_sub(1, smoothstep(lo, hi, arcDist)), step(1e-4, lineWidth));
 }), {
 	v: 1,
 	name: void 0,
@@ -688,9 +686,9 @@ const truchetField = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		DEG_TO_RAD,
-		std,
+		std: std_exports,
 		truchetHash
 	})
 }) && $.f)({}));