shaders 3.0.447 → 3.0.449

package/dist/core/{FloatingParticles-DJwNpHtZ.js → FloatingParticles-CoQ01il5.js}

@@ -1,5 +1,8 @@
-import { Bt as ZERO, Ht as call, J as std, Tn as d, X as createGuardedCompute, Z as createStateBuffer, ct as hash22, i as agents_exports, l as pointShapeOptions, lt as hash33, n as tgpu, o as cursorMagnet, ot as hash11, pt as noise_exports, r as AGENT_SHAPES, s as makeAgentWeightFn, u as resolveAgentShape } from "./coords-BkIjixe_.js";
-import { a as transformColor } from "./transformations-t0d2-uSX.js";
+import { $t as vec2f, Ct as floor, Et as max, Gt as textureStorage2d, Ht as atomic, It as sin, Ot as mix, Ut as arrayOf, Vt as data_exports, Xt as struct, _t as clamp, an as f32, at as textureStore, d as ZERO, dt as atomicStore, et as src_default, in as vec4f, lt as atomicAdd, nn as vec3f, nt as std_exports, on as i32, p as call, sn as u32, tn as vec2u, ut as atomicLoad, vt as cos, xt as exp } from "./edges-BXNBKxSN.js";
+import { c as hash22, l as hash33, o as hash11, p as noise_exports } from "./noise-wTSHXgFz.js";
+import { n as createGuardedCompute, r as createStateBuffer } from "./compute-BjeJ0sIA.js";
+import { a as makeAgentWeightFn, c as resolveAgentShape, i as cursorMagnet, n as agents_exports, s as pointShapeOptions, t as AGENT_SHAPES } from "./agents-Bv3--qPL.js";
+import { a as transformColor } from "./transformations-CsPUHppB.js";
 var MAX_MOTES = 8192;
 var RES = 1024;
 var INV_RES = 1 / RES;
@@ -18,46 +21,46 @@ var CURSOR_DRAG = 1.1;
 var ANGLE_FLIP = Math.PI;
 var HARD_GAIN = 637;
 var SOFT_GAIN = 255;
-var SimParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(d.struct({
-	color: d.vec4f,
-	count: d.f32,
-	dt: d.f32,
-	time: d.f32,
-	aspect: d.f32,
-	domainX: d.f32,
-	driftBase: d.f32,
-	angleRad: d.f32,
-	speedVar: d.f32,
-	angleVarRad: d.f32,
-	randomness: d.f32,
-	twinkle: d.f32,
-	softness: d.f32,
-	bodyR: d.f32,
-	cursorX: d.f32,
-	cursorY: d.f32,
-	cursorRadSq: d.f32,
-	cursorForce: d.f32,
-	dragMul: d.f32
+var SimParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+	color: vec4f,
+	count: f32,
+	dt: f32,
+	time: f32,
+	aspect: f32,
+	domainX: f32,
+	driftBase: f32,
+	angleRad: f32,
+	speedVar: f32,
+	angleVarRad: f32,
+	randomness: f32,
+	twinkle: f32,
+	softness: f32,
+	bodyR: f32,
+	cursorX: f32,
+	cursorY: f32,
+	cursorRadSq: f32,
+	cursorForce: f32,
+	dragMul: f32
 }), "SimParams");
-var simLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+var simLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
 	motes: {
-		storage: d.arrayOf(d.vec4f, MAX_MOTES),
+		storage: arrayOf(vec4f, MAX_MOTES),
 		access: "mutable"
 	},
 	accumE: {
-		storage: d.arrayOf(d.atomic(d.u32), RES * RES),
+		storage: arrayOf(atomic(u32), RES * RES),
 		access: "mutable"
 	},
 	params: { uniform: SimParams },
-	outTex: { storageTexture: d.textureStorage2d(STATE_FORMAT, "write-only") }
+	outTex: { storageTexture: textureStorage2d(STATE_FORMAT, "write-only") }
 }), "simLayout");
-var moteDrift = tgpu.fn([d.f32], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((fi) => {
+var moteDrift = src_default.fn([f32], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((fi) => {
 	"use gpu";
 	const prm = simLayout.$.params;
-	const h = hash22(d.vec2f(__tsover_add(__tsover_mul(fi, .7548), .13), __tsover_add(__tsover_mul(fi, 1.3236), 5.71)));
+	const h = hash22(vec2f(__tsover_add(__tsover_mul(fi, .7548), .13), __tsover_add(__tsover_mul(fi, 1.3236), 5.71)));
 	const speedMul = __tsover_add(1, __tsover_mul(__tsover_sub(h.x, .5), prm.speedVar));
 	const ang = __tsover_add(prm.angleRad, __tsover_mul(__tsover_mul(__tsover_sub(h.y, .5), 2), prm.angleVarRad));
-	return d.vec2f(std.cos(ang), std.sin(ang)).mul(__tsover_mul(prm.driftBase, speedMul));
+	return vec2f(cos(ang), sin(ang)).mul(__tsover_mul(prm.driftBase, speedMul));
 }), {
 	v: 1,
 	name: void 0,
@@ -239,11 +242,11 @@ var moteDrift = tgpu.fn([d.f32], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__
 	externals: () => ({
 		simLayout,
 		noise: noise_exports,
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({})).$name("moteDrift");
-var motePresence = tgpu.fn([d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((fi) => {
+var motePresence = src_default.fn([f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((fi) => {
 	"use gpu";
 	return __tsover_add(.55, __tsover_mul(hash11(__tsover_add(__tsover_mul(fi, 1.91), 2.53)), .7));
 }), {
@@ -287,15 +290,15 @@ var motePresence = tgpu.fn([d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis._
 	},
 	externals: () => ({ noise: noise_exports })
 }) && $.f)({})).$name("motePresence");
-var moteOrbit = tgpu.fn([d.f32], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((fi) => {
+var moteOrbit = src_default.fn([f32], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((fi) => {
 	"use gpu";
 	const prm = simLayout.$.params;
-	const h = hash22(d.vec2f(__tsover_add(__tsover_mul(fi, 2.41), .37), __tsover_add(__tsover_mul(fi, .577), 8.19)));
+	const h = hash22(vec2f(__tsover_add(__tsover_mul(fi, 2.41), .37), __tsover_add(__tsover_mul(fi, .577), 8.19)));
 	const rate = __tsover_mul(__tsover_mul(__tsover_add(.5, h.x), ORBIT_RATE), prm.randomness);
 	const ph = __tsover_mul(h.y, TAU);
 	const rad = __tsover_mul(__tsover_mul(ORBIT_RAD, prm.randomness), __tsover_add(.5, __tsover_mul(h.x, .5)));
 	const t = __tsover_add(__tsover_mul(prm.time, rate), ph);
-	return d.vec2f(std.cos(t), std.sin(t)).mul(rad);
+	return vec2f(cos(t), sin(t)).mul(rad);
 }), {
 	v: 1,
 	name: void 0,
@@ -500,19 +503,19 @@ var moteOrbit = tgpu.fn([d.f32], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__
 	externals: () => ({
 		simLayout,
 		noise: noise_exports,
-		d,
+		d: data_exports,
 		ORBIT_RATE,
 		TAU,
 		ORBIT_RAD,
-		std
+		std: std_exports
 	})
 }) && $.f)({})).$name("moteOrbit");
-const floatingParticlesInitKernel = tgpu.fn([d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
+const floatingParticlesInitKernel = src_default.fn([u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
 	"use gpu";
 	const prm = simLayout.$.params;
-	const fi = d.f32(i);
-	const r = hash33(d.vec3f(__tsover_add(__tsover_mul(fi, 1.618), .71), __tsover_add(__tsover_mul(fi, 2.718), 4.17), __tsover_add(__tsover_mul(fi, 3.142), 9.03)));
-	simLayout.$.motes[i] = d.vec4f(__tsover_mul(r.x, prm.domainX), r.y, d.f32(0), d.f32(0));
+	const fi = f32(i);
+	const r = hash33(vec3f(__tsover_add(__tsover_mul(fi, 1.618), .71), __tsover_add(__tsover_mul(fi, 2.718), 4.17), __tsover_add(__tsover_mul(fi, 3.142), 9.03)));
+	simLayout.$.motes[i] = vec4f(__tsover_mul(r.x, prm.domainX), r.y, f32(0), f32(0));
 }), {
 	v: 1,
 	name: void 0,
@@ -676,14 +679,14 @@ const floatingParticlesInitKernel = tgpu.fn([d.u32])(/* @__PURE__ */ (($) => (gl
 	},
 	externals: () => ({
 		simLayout,
-		d,
+		d: data_exports,
 		noise: noise_exports
 	})
 }) && $.f)({})).$name("floatingParticlesInit");
-const floatingParticlesClearAccumKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x, y) => {
+const floatingParticlesClearAccumKernel = src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x, y) => {
 	"use gpu";
-	const idx = __tsover_add(__tsover_mul(y, d.u32(RES)), x);
-	std.atomicStore(simLayout.$.accumE[idx], d.u32(0));
+	const idx = __tsover_add(__tsover_mul(y, u32(RES)), x);
+	atomicStore(simLayout.$.accumE[idx], u32(0));
 }), {
 	v: 1,
 	name: void 0,
@@ -754,29 +757,29 @@ const floatingParticlesClearAccumKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ *
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		RES,
-		std,
+		std: std_exports,
 		simLayout
 	})
 }) && $.f)({})).$name("floatingParticlesClearAccum");
-const floatingParticlesUpdateKernel = tgpu.fn([d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
+const floatingParticlesUpdateKernel = src_default.fn([u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
 	"use gpu";
 	const prm = simLayout.$.params;
 	const s = simLayout.$.motes[i];
-	const fi = d.f32(i);
+	const fi = f32(i);
 	const dt = prm.dt;
-	let pos = d.vec2f(s.x, s.y);
-	let gust = d.vec2f(s.z, s.w);
+	let pos = vec2f(s.x, s.y);
+	let gust = vec2f(s.z, s.w);
 	if (prm.cursorForce > 1e-5) {
-		const delta = pos.sub(d.vec2f(prm.cursorX, prm.cursorY));
+		const delta = pos.sub(vec2f(prm.cursorX, prm.cursorY));
 		gust = gust.add(cursorMagnet(delta, prm.cursorRadSq, prm.cursorForce).mul(dt));
 	}
 	gust = gust.mul(prm.dragMul);
 	pos = pos.add(moteDrift(fi).add(gust).mul(dt));
-	const wx = __tsover_sub(pos.x, __tsover_mul(std.floor(__tsover_div(pos.x, std.max(prm.domainX, 1e-4))), prm.domainX));
-	const wy = __tsover_sub(pos.y, std.floor(pos.y));
-	simLayout.$.motes[i] = d.vec4f(wx, wy, gust.x, gust.y);
+	const wx = __tsover_sub(pos.x, __tsover_mul(floor(__tsover_div(pos.x, max(prm.domainX, 1e-4))), prm.domainX));
+	const wy = __tsover_sub(pos.y, floor(pos.y));
+	simLayout.$.motes[i] = vec4f(wx, wy, gust.x, gust.y);
 }), {
 	v: 1,
 	name: void 0,
@@ -1143,10 +1146,10 @@ const floatingParticlesUpdateKernel = tgpu.fn([d.u32])(/* @__PURE__ */ (($) => (
 	},
 	externals: () => ({
 		simLayout,
-		d,
+		d: data_exports,
 		agents: agents_exports,
 		moteDrift,
-		std
+		std: std_exports
 	})
 }) && $.f)({})).$name("floatingParticlesUpdate");
 function makeFloatingParticlesSplatKernel(shape) {
@@ -1155,37 +1158,37 @@ function makeFloatingParticlesSplatKernel(shape) {
 	const weightFn = makeAgentWeightFn(name);
 	const FORCE_SOFT = s.soft;
 	const EXT = s.ext;
-	return tgpu.fn([d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
+	return src_default.fn([u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
 		"use gpu";
 		const prm = simLayout.$.params;
 		const s4 = simLayout.$.motes[i];
-		const fi = d.f32(i);
-		const pos = d.vec2f(s4.x, s4.y).add(moteOrbit(fi));
+		const fi = f32(i);
+		const pos = vec2f(s4.x, s4.y).add(moteOrbit(fi));
 		const presence = motePresence(fi);
 		const ph = __tsover_mul(hash11(__tsover_add(__tsover_mul(fi, 3.7), .93)), TAU);
-		const twk = __tsover_add(__tsover_mul(std.sin(__tsover_add(__tsover_mul(prm.time, TWINKLE_FREQ), ph)), .5), .5);
-		const bright = __tsover_mul(std.mix(d.f32(1), twk, prm.twinkle), __tsover_add(.4, __tsover_mul(.6, presence)));
-		const softV = std.max(prm.softness, d.f32(FORCE_SOFT));
-		const extK = std.mix(d.f32(EXT), std.max(d.f32(EXT), 2.4), softV);
-		const gain = std.mix(d.f32(HARD_GAIN), d.f32(SOFT_GAIN), softV);
-		const bodyR = std.max(__tsover_mul(prm.bodyR, __tsover_add(.55, __tsover_mul(.45, presence))), 1e-6);
+		const twk = __tsover_add(__tsover_mul(sin(__tsover_add(__tsover_mul(prm.time, TWINKLE_FREQ), ph)), .5), .5);
+		const bright = __tsover_mul(mix(f32(1), twk, prm.twinkle), __tsover_add(.4, __tsover_mul(.6, presence)));
+		const softV = max(prm.softness, f32(FORCE_SOFT));
+		const extK = mix(f32(EXT), max(f32(EXT), 2.4), softV);
+		const gain = mix(f32(HARD_GAIN), f32(SOFT_GAIN), softV);
+		const bodyR = max(__tsover_mul(prm.bodyR, __tsover_add(.55, __tsover_mul(.45, presence))), 1e-6);
 		const extSq = __tsover_mul(__tsover_add(__tsover_mul(bodyR, extK), __tsover_mul(AA_W, 2)), __tsover_add(__tsover_mul(bodyR, extK), __tsover_mul(AA_W, 2)));
-		const txf = __tsover_mul(__tsover_div(pos.x, prm.aspect), d.f32(RES));
-		const tyf = __tsover_mul(pos.y, d.f32(RES));
-		const cxi = d.i32(std.floor(txf));
-		const cyi = d.i32(std.floor(tyf));
+		const txf = __tsover_mul(__tsover_div(pos.x, prm.aspect), f32(RES));
+		const tyf = __tsover_mul(pos.y, f32(RES));
+		const cxi = i32(floor(txf));
+		const cyi = i32(floor(tyf));
 		for (let ky = 0; ky < SPLAT_WIN; ky++) for (let kx = 0; kx < SPLAT_WIN; kx++) {
 			const px = __tsover_sub(__tsover_add(cxi, kx), SPLAT_R);
 			const py = __tsover_sub(__tsover_add(cyi, ky), SPLAT_R);
 			if (px >= 0 && px < RES && py >= 0 && py < RES) {
-				const offX = __tsover_sub(__tsover_mul(__tsover_mul(__tsover_add(d.f32(px), .5), INV_RES), prm.aspect), pos.x);
-				const offY = __tsover_sub(__tsover_mul(__tsover_add(d.f32(py), .5), INV_RES), pos.y);
+				const offX = __tsover_sub(__tsover_mul(__tsover_mul(__tsover_add(f32(px), .5), INV_RES), prm.aspect), pos.x);
+				const offY = __tsover_sub(__tsover_mul(__tsover_add(f32(py), .5), INV_RES), pos.y);
 				if (__tsover_add(__tsover_mul(offX, offX), __tsover_mul(offY, offY)) < extSq) {
 					const w = __tsover_mul(weightFn(offX, offY, bodyR, AA_W, softV), bright);
-					const e = d.u32(__tsover_mul(w, gain));
-					if (e > d.u32(0)) {
-						const idx = d.u32(__tsover_add(__tsover_mul(py, RES), px));
-						std.atomicAdd(simLayout.$.accumE[idx], e);
+					const e = u32(__tsover_mul(w, gain));
+					if (e > u32(0)) {
+						const idx = u32(__tsover_add(__tsover_mul(py, RES), px));
+						atomicAdd(simLayout.$.accumE[idx], e);
 					}
 				}
 			}
@@ -1991,12 +1994,12 @@ function makeFloatingParticlesSplatKernel(shape) {
 		},
 		externals: () => ({
 			simLayout,
-			d,
+			d: data_exports,
 			moteOrbit,
 			motePresence,
 			noise: noise_exports,
 			TAU,
-			std,
+			std: std_exports,
 			TWINKLE_FREQ,
 			FORCE_SOFT,
 			EXT,
@@ -2012,13 +2015,13 @@ function makeFloatingParticlesSplatKernel(shape) {
 	}) && $.f)({})).$name("floatingParticlesSplat");
 }
 const floatingParticlesSplatKernel = makeFloatingParticlesSplatKernel("dot");
-const floatingParticlesResolveKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x, y) => {
+const floatingParticlesResolveKernel = src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x, y) => {
 	"use gpu";
 	const prm = simLayout.$.params;
-	const idx = __tsover_add(__tsover_mul(y, d.u32(RES)), x);
-	const energy = __tsover_mul(d.f32(std.atomicLoad(simLayout.$.accumE[idx])), __tsover_div(1, 255));
-	const a = __tsover_mul(__tsover_sub(1, std.exp(__tsover_mul(energy, -1.6))), prm.color.w);
-	std.textureStore(simLayout.$.outTex, d.vec2u(x, y), d.vec4f(prm.color.x, prm.color.y, prm.color.z, a));
+	const idx = __tsover_add(__tsover_mul(y, u32(RES)), x);
+	const energy = __tsover_mul(f32(atomicLoad(simLayout.$.accumE[idx])), __tsover_div(1, 255));
+	const a = __tsover_mul(__tsover_sub(1, exp(__tsover_mul(energy, -1.6))), prm.color.w);
+	textureStore(simLayout.$.outTex, vec2u(x, y), vec4f(prm.color.x, prm.color.y, prm.color.z, a));
 }), {
 	v: 1,
 	name: void 0,
@@ -2226,17 +2229,17 @@ const floatingParticlesResolveKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (
 	},
 	externals: () => ({
 		simLayout,
-		d,
+		d: data_exports,
 		RES,
-		std
+		std: std_exports
 	})
 }) && $.f)({})).$name("floatingParticlesResolve");
-const particleOverChild = tgpu.fn([d.vec4f, d.vec4f], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p, c) => {
+const particleOverChild = src_default.fn([vec4f, vec4f], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p, c) => {
 	"use gpu";
-	const pa = std.clamp(p.w, 0, 1);
+	const pa = clamp(p.w, 0, 1);
 	const outA = __tsover_add(pa, __tsover_mul(c.w, __tsover_sub(1, pa)));
-	const rgb = p.xyz.mul(pa).add(c.xyz.mul(__tsover_mul(c.w, __tsover_sub(1, pa)))).div(std.max(outA, 1e-4));
-	return d.vec4f(rgb.x, rgb.y, rgb.z, outA);
+	const rgb = p.xyz.mul(pa).add(c.xyz.mul(__tsover_mul(c.w, __tsover_sub(1, pa)))).div(max(outA, 1e-4));
+	return vec4f(rgb.x, rgb.y, rgb.z, outA);
 }), {
 	v: 1,
 	name: void 0,
@@ -2391,8 +2394,8 @@ const particleOverChild = tgpu.fn([d.vec4f, d.vec4f], d.vec4f)(/* @__PURE__ */ (
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({})).$name("floatingParticlesOverChild");
 const componentDefinition = {
@@ -2550,8 +2553,8 @@ const componentDefinition = {
 		const { gpu, getCpuValue, registerComputeTexture, onCleanup } = params;
 		const root = gpu?.root;
 		if (!root) return null;
-		const motes = createStateBuffer(root, d.vec4f, MAX_MOTES);
-		const accumE = createStateBuffer(root, d.atomic(d.u32), RES * RES);
+		const motes = createStateBuffer(root, vec4f, MAX_MOTES);
+		const accumE = createStateBuffer(root, atomic(u32), RES * RES);
 		const outTex = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
 			size: [RES, RES],
 			format: STATE_FORMAT
@@ -2694,7 +2697,7 @@ const componentDefinition = {
 				const col = getCpuValue("particleColor");
 				const bodyR = Math.min(Math.max(g("particleSize", 1.2), .3), 4) * 2 * INV_RES;
 				paramsU.write({
-					color: d.vec4f(col?.x ?? 1, col?.y ?? 1, col?.z ?? 1, col?.w ?? 1),
+					color: vec4f(col?.x ?? 1, col?.y ?? 1, col?.z ?? 1, col?.w ?? 1),
 					count,
 					dt,
 					time: localTime,

package/dist/core/{FlowField-D4iGiDic.js → FlowField-CU6S3Jar.js}

@@ -1,34 +1,35 @@
-import { Bt as ZERO, Ht as call, J as std, Lt as sampleRemappedExpr, Tn as d, cn as unpremultiplyAlpha, dt as mxNoiseFloat3, jt as composeEdgeRemapExpr, n as tgpu, pt as noise_exports } from "./coords-BkIjixe_.js";
-import { s as transformEdges } from "./transformations-t0d2-uSX.js";
-import { t as animatedTime } from "./porters-BmU6G9TR.js";
+import { $t as vec2f, Et as max, It as sin, N as unpremultiplyAlpha, Tt as length, Vt as data_exports, an as f32, c as sampleRemappedExpr, d as ZERO, et as src_default, n as composeEdgeRemapExpr, nn as vec3f, nt as std_exports, p as call, vt as cos } from "./edges-BXNBKxSN.js";
+import { t as animatedTime } from "./porters-DBK1Aipq.js";
+import { d as mxNoiseFloat3, p as noise_exports } from "./noise-wTSHXgFz.js";
+import { s as transformEdges } from "./transformations-CsPUHppB.js";
 var TWO_PI = Math.PI * 2;
-const flowFieldUV = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, scale, strength, time, evolutionTime) => {
+const flowFieldUV = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, scale, strength, time, evolutionTime) => {
 	"use gpu";
-	const aspectCorrectedUV = d.vec2f(__tsover_mul(uv.x, aspect), uv.y);
+	const aspectCorrectedUV = vec2f(__tsover_mul(uv.x, aspect), uv.y);
 	const drift1 = __tsover_mul(time, .7);
 	const evolve1 = __tsover_mul(evolutionTime, .2);
-	const angle1 = __tsover_mul(mxNoiseFloat3(d.vec3f(__tsover_add(__tsover_mul(aspectCorrectedUV.x, scale), __tsover_mul(drift1, .3)), __tsover_add(__tsover_mul(aspectCorrectedUV.y, scale), __tsover_mul(drift1, .5)), evolve1)), TWO_PI);
-	const flow1 = d.vec2f(std.cos(angle1), std.sin(angle1));
+	const angle1 = __tsover_mul(mxNoiseFloat3(vec3f(__tsover_add(__tsover_mul(aspectCorrectedUV.x, scale), __tsover_mul(drift1, .3)), __tsover_add(__tsover_mul(aspectCorrectedUV.y, scale), __tsover_mul(drift1, .5)), evolve1)), TWO_PI);
+	const flow1 = vec2f(cos(angle1), sin(angle1));
 	const drift2 = __tsover_mul(time, .5);
 	const evolve2 = __tsover_mul(evolutionTime, .15);
-	const angle2 = __tsover_mul(mxNoiseFloat3(d.vec3f(__tsover_add(__tsover_add(__tsover_mul(aspectCorrectedUV.x, __tsover_mul(scale, 2.3)), __tsover_mul(drift2, -.4)), 173.5), __tsover_add(__tsover_add(__tsover_mul(aspectCorrectedUV.y, __tsover_mul(scale, 2.3)), __tsover_mul(drift2, .3)), 291.7), __tsover_add(evolve2, 50))), TWO_PI);
-	const flow2 = d.vec2f(std.cos(angle2), std.sin(angle2));
+	const angle2 = __tsover_mul(mxNoiseFloat3(vec3f(__tsover_add(__tsover_add(__tsover_mul(aspectCorrectedUV.x, __tsover_mul(scale, 2.3)), __tsover_mul(drift2, -.4)), 173.5), __tsover_add(__tsover_add(__tsover_mul(aspectCorrectedUV.y, __tsover_mul(scale, 2.3)), __tsover_mul(drift2, .3)), 291.7), __tsover_add(evolve2, 50))), TWO_PI);
+	const flow2 = vec2f(cos(angle2), sin(angle2));
 	const drift3 = __tsover_mul(time, .3);
 	const evolve3 = __tsover_mul(evolutionTime, .1);
-	const angle3 = __tsover_mul(mxNoiseFloat3(d.vec3f(__tsover_add(__tsover_add(__tsover_mul(aspectCorrectedUV.x, __tsover_mul(scale, 4.7)), __tsover_mul(drift3, .2)), 527.3), __tsover_add(__tsover_add(__tsover_mul(aspectCorrectedUV.y, __tsover_mul(scale, 4.7)), __tsover_mul(drift3, -.6)), 839.1), __tsover_add(evolve3, 100))), TWO_PI);
-	const flow3 = d.vec2f(std.cos(angle3), std.sin(angle3));
+	const angle3 = __tsover_mul(mxNoiseFloat3(vec3f(__tsover_add(__tsover_add(__tsover_mul(aspectCorrectedUV.x, __tsover_mul(scale, 4.7)), __tsover_mul(drift3, .2)), 527.3), __tsover_add(__tsover_add(__tsover_mul(aspectCorrectedUV.y, __tsover_mul(scale, 4.7)), __tsover_mul(drift3, -.6)), 839.1), __tsover_add(evolve3, 100))), TWO_PI);
+	const flow3 = vec2f(cos(angle3), sin(angle3));
 	const combinedFlow = flow1.add(flow2.mul(.5)).add(flow3.mul(.25));
-	const flowLength = std.max(std.length(combinedFlow), .001);
+	const flowLength = max(length(combinedFlow), .001);
 	const normalizedFlow = combinedFlow.div(flowLength);
-	const finalFlow = d.vec2f(__tsover_div(__tsover_mul(normalizedFlow.x, strength), aspect), __tsover_mul(normalizedFlow.y, strength));
-	return d.vec2f(__tsover_add(uv.x, finalFlow.x), __tsover_add(uv.y, finalFlow.y));
+	const finalFlow = vec2f(__tsover_div(__tsover_mul(normalizedFlow.x, strength), aspect), __tsover_mul(normalizedFlow.y, strength));
+	return vec2f(__tsover_add(uv.x, finalFlow.x), __tsover_add(uv.y, finalFlow.y));
 }), {
 	v: 1,
 	name: void 0,
@@ -646,10 +647,10 @@ const flowFieldUV = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		noise: noise_exports,
 		TWO_PI,
-		std
+		std: std_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {

package/dist/core/{Flower-D0MqoayS.js → Flower-R7HIopNH.js}

@@ -1,16 +1,17 @@
-import { 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, k as flowerSdf, 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 flowerShape = 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 { g as shapeLocalCoords, h as sdf_exports, l as flowerSdf, 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 flowerShape = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	vec2f,
+	f32
 ], ShapeMask)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, radius, sides, innerRatio, rotation, softness, strokeThickness, strokePosition, uv, aspect) => {
 	"use gpu";
 	const local = shapeLocalCoords(center, rotation, uv, aspect);

package/dist/core/{FlowingGradient-9Zu0Pu4a.js → FlowingGradient-D66Y9Wgq.js}

@@ -1,50 +1,50 @@
-import { Ht as call, J as std, Tn as d, dt as mxNoiseFloat3, gn as mixColorsVariants, hn as mixColorsLinear, n as tgpu, pt as noise_exports } from "./coords-BkIjixe_.js";
-import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-t0d2-uSX.js";
-import { t as animatedTime } from "./porters-BmU6G9TR.js";
+import { $t as vec2f, At as pow, Et as max, H as mixColorsLinear, It as sin, Lt as smoothstep, Ot as mix, U as mixColorsVariants, Vt as data_exports, _t as clamp, an as f32, et as src_default, in as vec4f, mt as abs, nn as vec3f, nt as std_exports, p as call, vt as cos } from "./edges-BXNBKxSN.js";
+import { t as animatedTime } from "./porters-DBK1Aipq.js";
+import { d as mxNoiseFloat3, p as noise_exports } from "./noise-wTSHXgFz.js";
+import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
 var FOUR_PI = 4 * Math.PI;
-const flowingFactors = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((baseUV, viewport, distortion, seed, animTime) => {
+const flowingFactors = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	f32
+], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((baseUV, viewport, distortion, seed, animTime) => {
 	"use gpu";
 	const t = __tsover_mul(animTime, .075);
 	const aspect = __tsover_div(viewport.x, viewport.y);
 	const uv0 = baseUV.sub(.5);
 	const seedOff = __tsover_mul(seed, .17);
-	const noiseVal = mxNoiseFloat3(d.vec3f(__tsover_add(__tsover_mul(uv0.x, .8), __tsover_mul(t, .4)), __tsover_sub(__tsover_mul(uv0.y, .8), __tsover_mul(t, .25)), seedOff));
+	const noiseVal = mxNoiseFloat3(vec3f(__tsover_add(__tsover_mul(uv0.x, .8), __tsover_mul(t, .4)), __tsover_sub(__tsover_mul(uv0.y, .8), __tsover_mul(t, .25)), seedOff));
 	const angle = __tsover_mul(__tsover_mul(noiseVal, FOUR_PI), distortion);
-	const uvCorr = d.vec2f(uv0.x, __tsover_div(uv0.y, aspect));
-	const ca = std.cos(angle);
-	const sa = std.sin(angle);
+	const uvCorr = vec2f(uv0.x, __tsover_div(uv0.y, aspect));
+	const ca = cos(angle);
+	const sa = sin(angle);
 	const rotX = __tsover_sub(__tsover_mul(uvCorr.x, ca), __tsover_mul(uvCorr.y, sa));
 	const rotY = __tsover_mul(__tsover_add(__tsover_mul(uvCorr.x, sa), __tsover_mul(uvCorr.y, ca)), aspect);
 	const ws = __tsover_mul(t, 2);
-	const warpX = __tsover_add(rotX, __tsover_mul(__tsover_div(std.sin(__tsover_add(__tsover_mul(rotY, 5), ws)), 50), distortion));
-	const warpY = __tsover_add(rotY, __tsover_mul(__tsover_div(std.sin(__tsover_add(__tsover_mul(warpX, 7.5), ws)), 25), distortion));
-	const wp1 = d.vec3f(__tsover_mul(warpX, 2), __tsover_mul(warpY, 2), __tsover_add(__tsover_mul(t, .5), seedOff));
-	const wx1 = mxNoiseFloat3(wp1.add(d.vec3f(5.2, 1.3, 0)));
-	const wy1 = mxNoiseFloat3(wp1.add(d.vec3f(1.7, 9.2, 0)));
+	const warpX = __tsover_add(rotX, __tsover_mul(__tsover_div(sin(__tsover_add(__tsover_mul(rotY, 5), ws)), 50), distortion));
+	const warpY = __tsover_add(rotY, __tsover_mul(__tsover_div(sin(__tsover_add(__tsover_mul(warpX, 7.5), ws)), 25), distortion));
+	const wp1 = vec3f(__tsover_mul(warpX, 2), __tsover_mul(warpY, 2), __tsover_add(__tsover_mul(t, .5), seedOff));
+	const wx1 = mxNoiseFloat3(wp1.add(vec3f(5.2, 1.3, 0)));
+	const wy1 = mxNoiseFloat3(wp1.add(vec3f(1.7, 9.2, 0)));
 	const dw1X = __tsover_add(warpX, __tsover_mul(__tsover_mul(wx1, .25), distortion));
 	const dw1Y = __tsover_add(warpY, __tsover_mul(__tsover_mul(wy1, .25), distortion));
-	const wp2 = d.vec3f(__tsover_mul(dw1X, 1.5), __tsover_mul(dw1Y, 1.5), __tsover_add(__tsover_mul(t, .3), seedOff));
-	const wx2 = mxNoiseFloat3(wp2.add(d.vec3f(8.3, 2.8, 0)));
-	const wy2 = mxNoiseFloat3(wp2.add(d.vec3f(3.1, 7.4, 0)));
+	const wp2 = vec3f(__tsover_mul(dw1X, 1.5), __tsover_mul(dw1Y, 1.5), __tsover_add(__tsover_mul(t, .3), seedOff));
+	const wx2 = mxNoiseFloat3(wp2.add(vec3f(8.3, 2.8, 0)));
+	const wy2 = mxNoiseFloat3(wp2.add(vec3f(3.1, 7.4, 0)));
 	const dw2X = __tsover_add(dw1X, __tsover_mul(__tsover_mul(wx2, .2), distortion));
 	const dw2Y = __tsover_add(dw1Y, __tsover_mul(__tsover_mul(wy2, .2), distortion));
-	const zoneNoise = mxNoiseFloat3(d.vec3f(__tsover_mul(dw2X, 1.8), __tsover_mul(dw2Y, 1.8), __tsover_add(__tsover_mul(t, .3), seedOff)));
-	const edgeHardness = std.pow(__tsover_add(__tsover_mul(wx1, .5), .5), 1.5);
-	const edgeWidth = std.mix(.5, .008, edgeHardness);
-	const t1 = std.smoothstep(__tsover_mul(edgeWidth, -1), edgeWidth, zoneNoise);
-	const t2 = std.smoothstep(__tsover_mul(edgeWidth, -1), edgeWidth, wy1);
-	const foldMask1 = __tsover_sub(1, std.abs(__tsover_sub(__tsover_mul(t1, 2), 1)));
-	const foldMask2 = __tsover_sub(1, std.abs(__tsover_sub(__tsover_mul(t2, 2), 1)));
-	const foldHighlight = __tsover_mul(std.max(foldMask1, foldMask2), edgeHardness);
+	const zoneNoise = mxNoiseFloat3(vec3f(__tsover_mul(dw2X, 1.8), __tsover_mul(dw2Y, 1.8), __tsover_add(__tsover_mul(t, .3), seedOff)));
+	const edgeHardness = pow(__tsover_add(__tsover_mul(wx1, .5), .5), 1.5);
+	const edgeWidth = mix(.5, .008, edgeHardness);
+	const t1 = smoothstep(__tsover_mul(edgeWidth, -1), edgeWidth, zoneNoise);
+	const t2 = smoothstep(__tsover_mul(edgeWidth, -1), edgeWidth, wy1);
+	const foldMask1 = __tsover_sub(1, abs(__tsover_sub(__tsover_mul(t1, 2), 1)));
+	const foldMask2 = __tsover_sub(1, abs(__tsover_sub(__tsover_mul(t2, 2), 1)));
+	const foldHighlight = __tsover_mul(max(foldMask1, foldMask2), edgeHardness);
 	const surfaceLight = __tsover_add(__tsover_mul(__tsover_add(__tsover_mul(wx2, .5), .5), .12), .94);
-	const litScale = __tsover_mul(surfaceLight, __tsover_add(1, __tsover_mul(foldHighlight, .35)));
-	return d.vec3f(t1, t2, litScale);
+	return vec3f(t1, t2, __tsover_mul(surfaceLight, __tsover_add(1, __tsover_mul(foldHighlight, .35))));
 }), {
 	v: 1,
 	name: void 0,
@@ -965,15 +965,14 @@ const flowingFactors = tgpu.fn([
 	},
 	externals: () => ({
 		noise: noise_exports,
-		d,
+		d: data_exports,
 		FOUR_PI,
-		std
+		std: std_exports
 	})
 }) && $.f)({}));
-const flowingCompose = tgpu.fn([d.vec4f, d.f32], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((base, litScale) => {
+const flowingCompose = src_default.fn([vec4f, f32], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((base, litScale) => {
 	"use gpu";
-	const lit = std.clamp(base.xyz.mul(litScale), d.vec3f(0), d.vec3f(1));
-	return d.vec4f(lit, base.w);
+	return vec4f(clamp(base.xyz.mul(litScale), vec3f(0), vec3f(1)), base.w);
 }), {
 	v: 1,
 	name: void 0,
@@ -1045,8 +1044,8 @@ const flowingCompose = tgpu.fn([d.vec4f, d.f32], d.vec4f)(/* @__PURE__ */ (($) =
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {