shaders 3.0.447 → 3.0.449

package/dist/core/{PerlinNoise-KV2GG0ts.js → PerlinNoise-_whB3Y3m.js}

@@ -1,17 +1,19 @@
-import { Ht as call, J as std, Tn as d, et as toneAndColorExpr, gt as perlin13, n as tgpu, pt as noise_exports } from "./coords-BkIjixe_.js";
-import { t as animatedTime } from "./porters-BmU6G9TR.js";
-import { i as noiseToneProps, r as noiseSpeedProp, t as noiseColorProps } from "./noiseColor-CRpf22bk.js";
-const perlinNoiseField = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, scale, seed, animTime) => {
+import { $t as vec2f, Vt as data_exports, an as f32, et as src_default, nn as vec3f, nt as std_exports, p as call, xt as exp } from "./edges-BXNBKxSN.js";
+import { t as animatedTime } from "./porters-DBK1Aipq.js";
+import { g as perlin13, p as noise_exports } from "./noise-wTSHXgFz.js";
+import { n as toneAndColorExpr } from "./noiseColor-CPakiKNF.js";
+import { i as noiseToneProps, r as noiseSpeedProp, t as noiseColorProps } from "./noiseColor-DscZM9CO.js";
+const perlinNoiseField = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, scale, seed, animTime) => {
 	"use gpu";
 	const aspect = __tsover_div(viewport.x, viewport.y);
-	const pos = d.vec2f(__tsover_mul(uv.x, aspect), uv.y).mul(std.exp(scale)).add(seed);
-	return perlin13(d.vec3f(pos.x, pos.y, __tsover_mul(animTime, .3)));
+	const pos = vec2f(__tsover_mul(uv.x, aspect), uv.y).mul(exp(scale)).add(seed);
+	return perlin13(vec3f(pos.x, pos.y, __tsover_mul(animTime, .3)));
 }), {
 	v: 1,
 	name: void 0,
@@ -154,8 +156,8 @@ const perlinNoiseField = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		d,
-		std,
+		d: data_exports,
+		std: std_exports,
 		noise: noise_exports
 	})
 }) && $.f)({}));

package/dist/core/{Perspective-CJSrtEy5.js → Perspective-BJuQWHOr.js}

@@ -1,37 +1,35 @@
-import { Bt as ZERO, Ht as call, J as std, Lt as sampleRemappedExpr, Tn as d, cn as unpremultiplyAlpha, jt as composeEdgeRemapExpr, n as tgpu } from "./coords-BkIjixe_.js";
-import { c as transformPosition, s as transformEdges } from "./transformations-t0d2-uSX.js";
+import { $t as vec2f, Bt as tan, Et as max, It as sin, N as unpremultiplyAlpha, Vt as data_exports, an as f32, c as sampleRemappedExpr, d as ZERO, et as src_default, n as composeEdgeRemapExpr, nt as std_exports, p as call, vt as cos } from "./edges-BXNBKxSN.js";
+import { c as transformPosition, s as transformEdges } from "./transformations-CsPUHppB.js";
 var DEG_TO_RAD = Math.PI / 180;
-const perspectiveUV = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.vec2f,
-	d.vec2f
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, pan, tilt, fov, zoom, offset, uv) => {
+const perspectiveUV = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	vec2f,
+	vec2f
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, pan, tilt, fov, zoom, offset, uv) => {
 	"use gpu";
-	const centerPos = d.vec2f(center.x, __tsover_sub(1, center.y));
+	const centerPos = vec2f(center.x, __tsover_sub(1, center.y));
 	const x = __tsover_div(__tsover_sub(uv.x, centerPos.x), zoom);
 	const y = __tsover_div(__tsover_sub(uv.y, centerPos.y), zoom);
 	const panRad = __tsover_mul(pan, DEG_TO_RAD);
 	const tiltRad = __tsover_mul(tilt, DEG_TO_RAD);
 	const fovRad = __tsover_mul(fov, DEG_TO_RAD);
-	const cosPan = std.cos(panRad);
-	const sinPan = std.sin(panRad);
-	const cosTilt = std.cos(tiltRad);
-	const sinTilt = std.sin(tiltRad);
-	const perspectiveFactor = __tsover_mul(std.tan(__tsover_mul(fovRad, .5)), 2);
-	const panDivisor = __tsover_add(cosPan, __tsover_mul(__tsover_mul(sinPan, x), perspectiveFactor));
-	const safePanDivisor = std.max(panDivisor, .001);
+	const cosPan = cos(panRad);
+	const sinPan = sin(panRad);
+	const cosTilt = cos(tiltRad);
+	const sinTilt = sin(tiltRad);
+	const perspectiveFactor = __tsover_mul(tan(__tsover_mul(fovRad, .5)), 2);
+	const safePanDivisor = max(__tsover_add(cosPan, __tsover_mul(__tsover_mul(sinPan, x), perspectiveFactor)), .001);
 	const afterPanX = __tsover_div(x, safePanDivisor);
 	const afterPanY = __tsover_div(__tsover_mul(y, cosPan), safePanDivisor);
-	const tiltDivisor = __tsover_add(cosTilt, __tsover_mul(__tsover_mul(sinTilt, afterPanY), perspectiveFactor));
-	const safeTiltDivisor = std.max(tiltDivisor, .001);
+	const safeTiltDivisor = max(__tsover_add(cosTilt, __tsover_mul(__tsover_mul(sinTilt, afterPanY), perspectiveFactor)), .001);
 	const finalX = __tsover_div(__tsover_mul(afterPanX, cosTilt), safeTiltDivisor);
 	const finalY = __tsover_div(afterPanY, safeTiltDivisor);
-	const offsetPos = d.vec2f(offset.x, __tsover_sub(1, offset.y));
-	return d.vec2f(finalX, finalY).add(centerPos).sub(offsetPos).add(d.vec2f(.5, .5));
+	const offsetPos = vec2f(offset.x, __tsover_sub(1, offset.y));
+	return vec2f(finalX, finalY).add(centerPos).sub(offsetPos).add(vec2f(.5, .5));
 }), {
 	v: 1,
 	name: void 0,
@@ -435,9 +433,9 @@ const perspectiveUV = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		DEG_TO_RAD,
-		std
+		std: std_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {

package/dist/core/{PixelSort-WD-Y6ZFu.js → PixelSort-CJfXD6g0.js}

@@ -1,26 +1,27 @@
-import { Bt as ZERO, Ht as call, J as std, Tn as d, X as createGuardedCompute, Z as createStateBuffer, cn as unpremultiplyAlpha, n as tgpu, sn as blend_exports } from "./coords-BkIjixe_.js";
+import { $t as vec2f, Ct as floor, Dt as min, Gt as textureStorage2d, It as sin, Lt as smoothstep, M as blend_exports, N as unpremultiplyAlpha, Ot as mix, Pt as round, Rt as sqrt, Ut as arrayOf, Vt as data_exports, Wt as texture2d, Xt as struct, _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, nn as vec3f, nt as std_exports, on as i32, p as call, pt as select, sn as u32, tn as vec2u, wt as fract } from "./edges-BXNBKxSN.js";
+import { n as createGuardedCompute, r as createStateBuffer } from "./compute-BjeJ0sIA.js";
 var WORK = 512;
 var CELL_COUNT = WORK * WORK;
 var WORK_F = WORK;
 var MAX_COL = WORK - 1;
 var STATE_FORMAT = "rgba16float";
-const brushWeight = tgpu.fn([
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cxf, cyf, mouseX, mouseY, radius, falloff, aspect) => {
+const brushWeight = src_default.fn([
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cxf, cyf, mouseX, mouseY, radius, falloff, aspect) => {
 	"use gpu";
 	const dx = __tsover_sub(__tsover_div(cxf, WORK_F), mouseX);
 	const dy = __tsover_sub(__tsover_div(cyf, WORK_F), mouseY);
-	const ddx = std.select(dx, __tsover_mul(dx, aspect), aspect >= 1);
-	const ddy = std.select(__tsover_div(dy, aspect), dy, aspect >= 1);
-	const dist = std.sqrt(__tsover_add(__tsover_mul(ddx, ddx), __tsover_mul(ddy, ddy)));
+	const ddx = select(dx, __tsover_mul(dx, aspect), aspect >= 1);
+	const ddy = select(__tsover_div(dy, aspect), dy, aspect >= 1);
+	const dist = sqrt(__tsover_add(__tsover_mul(ddx, ddx), __tsover_mul(ddy, ddy)));
 	const inner = __tsover_mul(radius, __tsover_sub(1, falloff));
-	return __tsover_sub(1, std.smoothstep(inner, radius, dist));
+	return __tsover_sub(1, smoothstep(inner, radius, dist));
 }), {
 	v: 1,
 	name: void 0,
@@ -206,16 +207,16 @@ const brushWeight = tgpu.fn([
 	},
 	externals: () => ({
 		WORK_F,
-		std
+		std: std_exports
 	})
 }) && $.f)({}));
-const cellRand = tgpu.fn([
-	d.f32,
-	d.f32,
-	d.f32
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((xf, yf, seed) => {
+const cellRand = src_default.fn([
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((xf, yf, seed) => {
 	"use gpu";
-	return std.fract(__tsover_mul(std.sin(__tsover_add(__tsover_add(__tsover_mul(xf, 12.9898), __tsover_mul(yf, 78.233)), __tsover_mul(seed, .137))), 43758.5453));
+	return fract(__tsover_mul(sin(__tsover_add(__tsover_add(__tsover_mul(xf, 12.9898), __tsover_mul(yf, 78.233)), __tsover_mul(seed, .137))), 43758.5453));
 }), {
 	v: 1,
 	name: void 0,
@@ -283,59 +284,59 @@ const cellRand = tgpu.fn([
 		]]]],
 		"externalNames": ["std"]
 	},
-	externals: () => ({ std })
+	externals: () => ({ std: std_exports })
 }) && $.f)({}));
-var lumaLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
-	input: { texture: d.texture2d(d.f32) },
+var lumaLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
+	input: { texture: texture2d(f32) },
 	lumaBuf: {
-		storage: d.arrayOf(d.f32, CELL_COUNT),
+		storage: arrayOf(f32, CELL_COUNT),
 		access: "mutable"
 	},
-	params: { uniform: /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(d.struct({
-		inputWidth: d.f32,
-		inputHeight: d.f32
+	params: { uniform: /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+		inputWidth: f32,
+		inputHeight: f32
 	}), "uniform") }
 }), "lumaLayout");
-var swapLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+var swapLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
 	readBuf: {
-		storage: d.arrayOf(d.f32, CELL_COUNT),
+		storage: arrayOf(f32, CELL_COUNT),
 		access: "readonly"
 	},
 	writeBuf: {
-		storage: d.arrayOf(d.f32, CELL_COUNT),
+		storage: arrayOf(f32, CELL_COUNT),
 		access: "mutable"
 	},
 	lumaBuf: {
-		storage: d.arrayOf(d.f32, CELL_COUNT),
+		storage: arrayOf(f32, CELL_COUNT),
 		access: "readonly"
 	},
-	params: { uniform: /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(d.struct({
-		mouseX: d.f32,
-		mouseY: d.f32,
-		radius: d.f32,
-		falloff: d.f32,
-		decay: d.f32,
-		aspect: d.f32,
-		seed: d.f32
+	params: { uniform: /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+		mouseX: f32,
+		mouseY: f32,
+		radius: f32,
+		falloff: f32,
+		decay: f32,
+		aspect: f32,
+		seed: f32
 	}), "uniform") }
 }), "swapLayout");
-var outputLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+var outputLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
 	srcBuf: {
-		storage: d.arrayOf(d.f32, CELL_COUNT),
+		storage: arrayOf(f32, CELL_COUNT),
 		access: "readonly"
 	},
-	stateTex: { storageTexture: d.textureStorage2d(STATE_FORMAT, "write-only") }
+	stateTex: { storageTexture: textureStorage2d(STATE_FORMAT, "write-only") }
 }), "outputLayout");
-const lumaKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+const lumaKernel = src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
 	"use gpu";
 	const p = lumaLayout.$.params;
-	const idx = __tsover_add(__tsover_mul(cy, d.u32(WORK)), cx);
-	const u = __tsover_div(__tsover_add(d.f32(cx), .5), WORK_F);
-	const v = __tsover_div(__tsover_add(d.f32(cy), .5), WORK_F);
-	const ix = std.clamp(d.i32(std.round(__tsover_mul(u, p.inputWidth))), 0, d.i32(__tsover_sub(p.inputWidth, 1)));
-	const iy = std.clamp(d.i32(std.round(__tsover_mul(v, p.inputHeight))), 0, d.i32(__tsover_sub(p.inputHeight, 1)));
-	const rgb = unpremultiplyAlpha(std.textureLoad(lumaLayout.$.input, d.vec2u(d.u32(ix), d.u32(iy)), 0)).xyz;
-	lumaLayout.$.lumaBuf[idx] = std.dot(rgb, d.vec3f(.299, .587, .114));
+	const idx = __tsover_add(__tsover_mul(cy, u32(WORK)), cx);
+	const u = __tsover_div(__tsover_add(f32(cx), .5), WORK_F);
+	const v = __tsover_div(__tsover_add(f32(cy), .5), WORK_F);
+	const ix = clamp(i32(round(__tsover_mul(u, p.inputWidth))), 0, i32(__tsover_sub(p.inputWidth, 1)));
+	const iy = clamp(i32(round(__tsover_mul(v, p.inputHeight))), 0, i32(__tsover_sub(p.inputHeight, 1)));
+	const rgb = unpremultiplyAlpha(textureLoad(lumaLayout.$.input, vec2u(u32(ix), u32(iy)), 0)).xyz;
+	lumaLayout.$.lumaBuf[idx] = dot(rgb, vec3f(.299, .587, .114));
 }), {
 	v: 1,
 	name: void 0,
@@ -664,54 +665,53 @@ const lumaKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis._
 	},
 	externals: () => ({
 		lumaLayout,
-		d,
+		d: data_exports,
 		WORK,
 		WORK_F,
-		std,
+		std: std_exports,
 		blend: blend_exports
 	})
 }) && $.f)({})).$name("pixelSortLuma");
 function makeSwapKernel(vertical, dir, parity) {
-	return tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+	return src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
 		"use gpu";
 		const p = swapLayout.$.params;
-		const idx = __tsover_add(__tsover_mul(cy, d.u32(WORK)), cx);
-		const xf = d.f32(cx);
-		const yf = d.f32(cy);
+		const idx = __tsover_add(__tsover_mul(cy, u32(WORK)), cx);
+		const xf = f32(cx);
+		const yf = f32(cy);
 		const lineC = vertical ? cy : cx;
 		const fixedC = vertical ? cx : cy;
-		const lineCf = d.f32(lineC);
-		const lineCi = d.i32(lineC);
+		const lineCf = f32(lineC);
+		const lineCi = i32(lineC);
 		const myOff = swapLayout.$.readBuf[idx];
-		const myCol = std.clamp(__tsover_add(lineCf, myOff), 0, MAX_COL);
-		const isLeft = __tsover_mod(__tsover_add(lineC, d.u32(parity)), d.u32(2)) === d.u32(0);
-		const partnerLineI = std.select(__tsover_sub(lineCi, 1), __tsover_add(lineCi, 1), isLeft);
+		const myCol = clamp(__tsover_add(lineCf, myOff), 0, MAX_COL);
+		const isLeft = __tsover_mod(__tsover_add(lineC, u32(parity)), u32(2)) === u32(0);
+		const partnerLineI = select(__tsover_sub(lineCi, 1), __tsover_add(lineCi, 1), isLeft);
 		const valid = partnerLineI >= 0 && partnerLineI < WORK;
-		const pClamped = std.clamp(partnerLineI, 0, __tsover_sub(WORK, 1));
-		const pClampedU = d.u32(pClamped);
+		const pClamped = clamp(partnerLineI, 0, __tsover_sub(WORK, 1));
+		const pClampedU = u32(pClamped);
 		const partnerX = vertical ? fixedC : pClampedU;
 		const partnerY = vertical ? pClampedU : fixedC;
-		const partnerIdx = __tsover_add(__tsover_mul(partnerY, d.u32(WORK)), partnerX);
+		const partnerIdx = __tsover_add(__tsover_mul(partnerY, u32(WORK)), partnerX);
 		const partnerOff = swapLayout.$.readBuf[partnerIdx];
-		const partnerCol = std.clamp(__tsover_add(d.f32(pClamped), partnerOff), 0, MAX_COL);
-		const myC0 = std.clamp(std.floor(myCol), 0, MAX_COL);
-		const myC1 = std.min(__tsover_add(myC0, 1), MAX_COL);
-		const myIdx0 = vertical ? __tsover_add(__tsover_mul(d.u32(myC0), d.u32(WORK)), fixedC) : __tsover_add(__tsover_mul(fixedC, d.u32(WORK)), d.u32(myC0));
-		const myIdx1 = vertical ? __tsover_add(__tsover_mul(d.u32(myC1), d.u32(WORK)), fixedC) : __tsover_add(__tsover_mul(fixedC, d.u32(WORK)), d.u32(myC1));
-		const myKey = std.mix(swapLayout.$.lumaBuf[myIdx0], swapLayout.$.lumaBuf[myIdx1], __tsover_sub(myCol, myC0));
-		const pC0 = std.clamp(std.floor(partnerCol), 0, MAX_COL);
-		const pC1 = std.min(__tsover_add(pC0, 1), MAX_COL);
-		const pIdx0 = vertical ? __tsover_add(__tsover_mul(d.u32(pC0), d.u32(WORK)), fixedC) : __tsover_add(__tsover_mul(fixedC, d.u32(WORK)), d.u32(pC0));
-		const pIdx1 = vertical ? __tsover_add(__tsover_mul(d.u32(pC1), d.u32(WORK)), fixedC) : __tsover_add(__tsover_mul(fixedC, d.u32(WORK)), d.u32(pC1));
-		const partnerKey = std.mix(swapLayout.$.lumaBuf[pIdx0], swapLayout.$.lumaBuf[pIdx1], __tsover_sub(partnerCol, pC0));
+		const partnerCol = clamp(__tsover_add(f32(pClamped), partnerOff), 0, MAX_COL);
+		const myC0 = clamp(floor(myCol), 0, MAX_COL);
+		const myC1 = min(__tsover_add(myC0, 1), MAX_COL);
+		const myIdx0 = vertical ? __tsover_add(__tsover_mul(u32(myC0), u32(WORK)), fixedC) : __tsover_add(__tsover_mul(fixedC, u32(WORK)), u32(myC0));
+		const myIdx1 = vertical ? __tsover_add(__tsover_mul(u32(myC1), u32(WORK)), fixedC) : __tsover_add(__tsover_mul(fixedC, u32(WORK)), u32(myC1));
+		const myKey = mix(swapLayout.$.lumaBuf[myIdx0], swapLayout.$.lumaBuf[myIdx1], __tsover_sub(myCol, myC0));
+		const pC0 = clamp(floor(partnerCol), 0, MAX_COL);
+		const pC1 = min(__tsover_add(pC0, 1), MAX_COL);
+		const pIdx0 = vertical ? __tsover_add(__tsover_mul(u32(pC0), u32(WORK)), fixedC) : __tsover_add(__tsover_mul(fixedC, u32(WORK)), u32(pC0));
+		const pIdx1 = vertical ? __tsover_add(__tsover_mul(u32(pC1), u32(WORK)), fixedC) : __tsover_add(__tsover_mul(fixedC, u32(WORK)), u32(pC1));
+		const partnerKey = mix(swapLayout.$.lumaBuf[pIdx0], swapLayout.$.lumaBuf[pIdx1], __tsover_sub(partnerCol, pC0));
 		const wMy = brushWeight(xf, yf, p.mouseX, p.mouseY, p.radius, p.falloff, p.aspect);
-		const wP = brushWeight(d.f32(partnerX), d.f32(partnerY), p.mouseX, p.mouseY, p.radius, p.falloff, p.aspect);
+		const wP = brushWeight(f32(partnerX), f32(partnerY), p.mouseX, p.mouseY, p.radius, p.falloff, p.aspect);
 		const rnd = cellRand(xf, yf, p.seed);
-		const gate = valid && std.min(wMy, wP) > rnd;
+		const gate = valid && min(wMy, wP) > rnd;
 		const keyDiff = __tsover_mul(__tsover_sub(myKey, partnerKey), dir);
-		const takePartner = std.select(keyDiff < 0, keyDiff > 0, isLeft);
-		const newCol = std.select(myCol, partnerCol, gate && takePartner);
-		const decayed = std.mix(newCol, lineCf, p.decay);
+		const takePartner = select(keyDiff < 0, keyDiff > 0, isLeft);
+		const decayed = mix(select(myCol, partnerCol, gate && takePartner), lineCf, p.decay);
 		swapLayout.$.writeBuf[idx] = __tsover_sub(decayed, lineCf);
 	}), {
 		v: 1,
@@ -1768,10 +1768,10 @@ function makeSwapKernel(vertical, dir, parity) {
 		},
 		externals: () => ({
 			swapLayout,
-			d,
+			d: data_exports,
 			WORK,
 			vertical,
-			std,
+			std: std_exports,
 			MAX_COL,
 			parity,
 			brushWeight,
@@ -1781,13 +1781,13 @@ function makeSwapKernel(vertical, dir, parity) {
 	}) && $.f)({})).$name("pixelSortSwap");
 }
 function makeOutputKernel(vertical) {
-	return tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+	return src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
 		"use gpu";
-		const idx = __tsover_add(__tsover_mul(cy, d.u32(WORK)), cx);
+		const idx = __tsover_add(__tsover_mul(cy, u32(WORK)), cx);
 		const lineC = vertical ? cy : cx;
-		const col = std.clamp(__tsover_add(d.f32(lineC), outputLayout.$.srcBuf[idx]), 0, MAX_COL);
+		const col = clamp(__tsover_add(f32(lineC), outputLayout.$.srcBuf[idx]), 0, MAX_COL);
 		const u = __tsover_div(__tsover_add(col, .5), WORK_F);
-		std.textureStore(outputLayout.$.stateTex, d.vec2u(cx, cy), d.vec4f(u, 0, 0, 1));
+		textureStore(outputLayout.$.stateTex, vec2u(cx, cy), vec4f(u, 0, 0, 1));
 	}), {
 		v: 1,
 		name: void 0,
@@ -1944,19 +1944,19 @@ function makeOutputKernel(vertical) {
 			]
 		},
 		externals: () => ({
-			d,
+			d: data_exports,
 			WORK,
 			vertical,
-			std,
+			std: std_exports,
 			outputLayout,
 			MAX_COL,
 			WORK_F
 		})
 	}) && $.f)({})).$name("pixelSortOutput");
 }
-const pixelSortUVVertical = tgpu.fn([d.vec2f, d.f32], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, srcCoord) => {
+const pixelSortUVVertical = src_default.fn([vec2f, f32], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, srcCoord) => {
 	"use gpu";
-	return d.vec2f(uv.x, srcCoord);
+	return vec2f(uv.x, srcCoord);
 }), {
 	v: 1,
 	name: void 0,
@@ -1983,11 +1983,11 @@ const pixelSortUVVertical = tgpu.fn([d.vec2f, d.f32], d.vec2f)(/* @__PURE__ */ (
 		]]]],
 		"externalNames": ["d"]
 	},
-	externals: () => ({ d })
+	externals: () => ({ d: data_exports })
 }) && $.f)({}));
-const pixelSortUVHorizontal = tgpu.fn([d.vec2f, d.f32], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, srcCoord) => {
+const pixelSortUVHorizontal = src_default.fn([vec2f, f32], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, srcCoord) => {
 	"use gpu";
-	return d.vec2f(srcCoord, uv.y);
+	return vec2f(srcCoord, uv.y);
 }), {
 	v: 1,
 	name: void 0,
@@ -2014,7 +2014,7 @@ const pixelSortUVHorizontal = tgpu.fn([d.vec2f, d.f32], d.vec2f)(/* @__PURE__ */
 		]]]],
 		"externalNames": ["d"]
 	},
-	externals: () => ({ d })
+	externals: () => ({ d: data_exports })
 }) && $.f)({}));
 const componentDefinition = {
 	name: "PixelSort",
@@ -2116,27 +2116,27 @@ const componentDefinition = {
 		const vertical = propValues.axis === "vertical";
 		const dir = propValues.direction === "descending" ? -1 : 1;
 		const childTexture = convertToTexture(childNode);
-		const bufferA = createStateBuffer(root, d.f32, CELL_COUNT);
-		const bufferB = createStateBuffer(root, d.f32, CELL_COUNT);
-		const lumaBuf = createStateBuffer(root, d.f32, CELL_COUNT);
+		const bufferA = createStateBuffer(root, f32, CELL_COUNT);
+		const bufferB = createStateBuffer(root, f32, CELL_COUNT);
+		const lumaBuf = createStateBuffer(root, f32, CELL_COUNT);
 		const stateTex = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
 			size: [WORK, WORK],
 			format: STATE_FORMAT
 		}).$usage("storage", "sampled"), "stateTex");
 		onCleanup(() => stateTex.destroy());
 		const state = registerComputeTexture(stateTex);
-		const lumaParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(d.struct({
-			inputWidth: d.f32,
-			inputHeight: d.f32
+		const lumaParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(struct({
+			inputWidth: f32,
+			inputHeight: f32
 		})), "lumaParams");
-		const swapParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(d.struct({
-			mouseX: d.f32,
-			mouseY: d.f32,
-			radius: d.f32,
-			falloff: d.f32,
-			decay: d.f32,
-			aspect: d.f32,
-			seed: d.f32
+		const swapParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(struct({
+			mouseX: f32,
+			mouseY: f32,
+			radius: f32,
+			falloff: f32,
+			decay: f32,
+			aspect: f32,
+			seed: f32
 		})), "swapParams");
 		let curW = Math.max(1, Math.round(dimensions.width));
 		let curH = Math.max(1, Math.round(dimensions.height));

package/dist/core/{PixelThrow-CnOXm7Hv.js → PixelThrow-BaTI5PzH.js}

@@ -1,5 +1,6 @@
-import { At as applyEdgeHandlingExpr, Bt as ZERO, H as toHalfFloat, Ht as call, J as std, Kt as floatE, Tn as d, cn as unpremultiplyAlpha, n as tgpu } from "./coords-BkIjixe_.js";
-import { s as transformEdges } from "./transformations-t0d2-uSX.js";
+import { $t as vec2f, Ct as floor, N as unpremultiplyAlpha, Ot as mix, Vt as data_exports, Xt as struct, _ as floatE, _t as clamp, 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, t as applyEdgeHandlingExpr } from "./edges-BXNBKxSN.js";
+import { t as toHalfFloat } from "./dataEncoding-CEmpiitu.js";
+import { s as transformEdges } from "./transformations-CsPUHppB.js";
 var transformThrowKey = (value) => {
 	return {
 		luminance: 0,
@@ -11,13 +12,13 @@ var transformThrowKey = (value) => {
 };
 var GRID = 128;
 var num = (v, f) => typeof v === "number" ? v : f;
-const pixelThrowOffsetUV = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, flowVec, scale) => {
+const pixelThrowOffsetUV = src_default.fn([
+	vec2f,
+	vec2f,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, flowVec, scale) => {
 	"use gpu";
-	return d.vec2f(__tsover_sub(uv.x, __tsover_mul(flowVec.x, scale)), __tsover_sub(uv.y, __tsover_mul(flowVec.y, scale)));
+	return vec2f(__tsover_sub(uv.x, __tsover_mul(flowVec.x, scale)), __tsover_sub(uv.y, __tsover_mul(flowVec.y, scale)));
 }), {
 	v: 1,
 	name: void 0,
@@ -83,22 +84,22 @@ const pixelThrowOffsetUV = tgpu.fn([
 		]]]],
 		"externalNames": ["d"]
 	},
-	externals: () => ({ d })
+	externals: () => ({ d: data_exports })
 }) && $.f)({})).$name("pixelThrowOffsetUV");
-const PixelThrowBicubicTaps = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(d.struct({
-	uvA: d.vec2f,
-	uvB: d.vec2f,
-	uvC: d.vec2f,
-	uvD: d.vec2f,
-	w: d.vec4f
+const PixelThrowBicubicTaps = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+	uvA: vec2f,
+	uvB: vec2f,
+	uvC: vec2f,
+	uvD: vec2f,
+	w: vec4f
 }), "PixelThrowBicubicTaps");
-const pixelThrowBicubicSetup = tgpu.fn([d.vec2f], PixelThrowBicubicTaps)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv) => {
+const pixelThrowBicubicSetup = src_default.fn([vec2f], PixelThrowBicubicTaps)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv) => {
 	"use gpu";
-	const gf = d.f32(GRID);
+	const gf = f32(GRID);
 	const tx = __tsover_sub(__tsover_mul(uv.x, gf), .5);
 	const ty = __tsover_sub(__tsover_mul(uv.y, gf), .5);
-	const pxf = std.floor(tx);
-	const pyf = std.floor(ty);
+	const pxf = floor(tx);
+	const pyf = floor(ty);
 	const fx = __tsover_sub(tx, pxf);
 	const fy = __tsover_sub(ty, pyf);
 	const ofx = __tsover_sub(1, fx);
@@ -120,11 +121,11 @@ const pixelThrowBicubicSetup = tgpu.fn([d.vec2f], PixelThrowBicubicTaps)(/* @__P
 	const h0y = __tsover_add(__tsover_sub(pyf, 1), __tsover_div(wy1, g0y));
 	const h1y = __tsover_add(__tsover_add(pyf, 1), __tsover_div(wy3, g1y));
 	return PixelThrowBicubicTaps({
-		uvA: d.vec2f(__tsover_div(__tsover_add(h0x, .5), gf), __tsover_div(__tsover_add(h0y, .5), gf)),
-		uvB: d.vec2f(__tsover_div(__tsover_add(h1x, .5), gf), __tsover_div(__tsover_add(h0y, .5), gf)),
-		uvC: d.vec2f(__tsover_div(__tsover_add(h0x, .5), gf), __tsover_div(__tsover_add(h1y, .5), gf)),
-		uvD: d.vec2f(__tsover_div(__tsover_add(h1x, .5), gf), __tsover_div(__tsover_add(h1y, .5), gf)),
-		w: d.vec4f(__tsover_mul(g0x, g0y), __tsover_mul(g1x, g0y), __tsover_mul(g0x, g1y), __tsover_mul(g1x, g1y))
+		uvA: vec2f(__tsover_div(__tsover_add(h0x, .5), gf), __tsover_div(__tsover_add(h0y, .5), gf)),
+		uvB: vec2f(__tsover_div(__tsover_add(h1x, .5), gf), __tsover_div(__tsover_add(h0y, .5), gf)),
+		uvC: vec2f(__tsover_div(__tsover_add(h0x, .5), gf), __tsover_div(__tsover_add(h1y, .5), gf)),
+		uvD: vec2f(__tsover_div(__tsover_add(h1x, .5), gf), __tsover_div(__tsover_add(h1y, .5), gf)),
+		w: vec4f(__tsover_mul(g0x, g0y), __tsover_mul(g1x, g0y), __tsover_mul(g0x, g1y), __tsover_mul(g1x, g1y))
 	});
 }), {
 	v: 1,
@@ -727,24 +728,23 @@ const pixelThrowBicubicSetup = tgpu.fn([d.vec2f], PixelThrowBicubicTaps)(/* @__P
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		GRID,
-		std,
+		std: std_exports,
 		PixelThrowBicubicTaps
 	})
 }) && $.f)({})).$name("pixelThrowBicubicSetup");
 function buildKeyScale(keyMode) {
-	return tgpu.fn([d.vec3f, d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((rgb, keyInfluence) => {
+	return src_default.fn([vec3f, f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((rgb, keyInfluence) => {
 		"use gpu";
-		const lum = d.vec3f(.299, .587, .114);
-		let key = d.f32(0);
-		if (keyMode === 1) key = __tsover_sub(1, std.dot(rgb, lum));
+		const lum = vec3f(.299, .587, .114);
+		let key = f32(0);
+		if (keyMode === 1) key = __tsover_sub(1, dot(rgb, lum));
 		else if (keyMode === 2) key = rgb.x;
 		else if (keyMode === 3) key = rgb.y;
 		else if (keyMode === 4) key = rgb.z;
-		else key = std.dot(rgb, lum);
-		const keyClamped = std.clamp(key, 0, 1);
-		return std.mix(1, keyClamped, keyInfluence);
+		else key = dot(rgb, lum);
+		return mix(1, clamp(key, 0, 1), keyInfluence);
 	}), {
 		v: 1,
 		name: void 0,
@@ -924,9 +924,9 @@ function buildKeyScale(keyMode) {
 			]
 		},
 		externals: () => ({
-			d,
+			d: data_exports,
 			keyMode,
-			std
+			std: std_exports
 		})
 	}) && $.f)({})).$name(`pixelThrowKeyScale_${keyMode}`);
 }