shaders 3.0.447 → 3.0.449

package/dist/core/{BarnDoors-B_kxVuec.js → BarnDoors-DWs_0xtH.js}

@@ -1,28 +1,27 @@
-import { Bt as ZERO, Ht as call, J as std, Tn as d, n as tgpu } from "./coords-BkIjixe_.js";
-import { i as transformBoolean } from "./transformations-t0d2-uSX.js";
+import { $t as vec2f, Et as max, It as sin, Lt as smoothstep, Vt as data_exports, an as f32, bt as dot, d as ZERO, et as src_default, in as vec4f, mt as abs, nt as std_exports, p as call, pt as select, vt as cos } from "./edges-BXNBKxSN.js";
+import { i as transformBoolean } from "./transformations-CsPUHppB.js";
 var DEG_TO_RAD = Math.PI / 180;
-const barnDoorsMask = tgpu.fn([
-	d.vec4f,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, uv, aspect, angleDeg, progress, feather, invert) => {
+const barnDoorsMask = src_default.fn([
+	vec4f,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, uv, aspect, angleDeg, progress, feather, invert) => {
 	"use gpu";
 	const a = __tsover_mul(angleDeg, DEG_TO_RAD);
-	const dir = d.vec2f(std.cos(a), std.sin(a));
-	const p = d.vec2f(__tsover_mul(__tsover_sub(uv.x, .5), aspect), __tsover_sub(uv.y, .5));
-	const grad = std.dot(p, dir);
-	const ext = __tsover_mul(.5, __tsover_add(__tsover_mul(aspect, std.abs(dir.x)), std.abs(dir.y)));
+	const dir = vec2f(cos(a), sin(a));
+	const grad = dot(vec2f(__tsover_mul(__tsover_sub(uv.x, .5), aspect), __tsover_sub(uv.y, .5)), dir);
+	const ext = __tsover_mul(.5, __tsover_add(__tsover_mul(aspect, abs(dir.x)), abs(dir.y)));
 	const t = __tsover_add(__tsover_div(grad, __tsover_mul(2, ext)), .5);
-	let coord = __tsover_mul(std.abs(__tsover_sub(t, .5)), 2);
-	coord = std.select(coord, __tsover_sub(1, coord), invert > 0);
-	const f = std.max(feather, 1e-4);
+	let coord = __tsover_mul(abs(__tsover_sub(t, .5)), 2);
+	coord = select(coord, __tsover_sub(1, coord), invert > 0);
+	const f = max(feather, 1e-4);
 	const front = __tsover_sub(__tsover_mul(progress, __tsover_add(1, __tsover_mul(2, f))), f);
-	const reveal = std.smoothstep(__tsover_sub(front, f), __tsover_add(front, f), coord);
-	return d.vec4f(color.x, color.y, color.z, __tsover_mul(color.w, reveal));
+	const reveal = smoothstep(__tsover_sub(front, f), __tsover_add(front, f), coord);
+	return vec4f(color.x, color.y, color.z, __tsover_mul(color.w, reveal));
 }), {
 	v: 1,
 	name: void 0,
@@ -370,8 +369,8 @@ const barnDoorsMask = tgpu.fn([
 	},
 	externals: () => ({
 		DEG_TO_RAD,
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {

package/dist/core/{Beam-C7zPHuIU.js → Beam-Cgc4EYnj.js}

@@ -1,43 +1,36 @@
-import { Ht as call, J as std, Jt as vec4, Tn as d, _n as mixPreconvertedLinear, hn as mixColorsLinear, n as tgpu, un as convertP3ToMixSpaceCPU, vn as mixPreconvertedVariants } from "./coords-BkIjixe_.js";
-import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-t0d2-uSX.js";
-const beamField = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, vp, start, end, startThickness, endThickness, startSoftness, endSoftness) => {
+import { $t as vec2f, At as pow, Et as max, G as mixPreconvertedLinear, H as mixColorsLinear, K as mixPreconvertedVariants, L as convertP3ToMixSpaceCPU, Lt as smoothstep, Ot as mix, Rt as sqrt, Vt as data_exports, _t as clamp, an as f32, et as src_default, nn as vec3f, nt as std_exports, p as call, y as vec4 } from "./edges-BXNBKxSN.js";
+import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
+const beamField = src_default.fn([
+	vec2f,
+	vec2f,
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, vp, start, end, startThickness, endThickness, startSoftness, endSoftness) => {
 	"use gpu";
 	const aspect = __tsover_div(vp.x, vp.y);
-	const startPos = d.vec2f(start.x, __tsover_sub(1, start.y));
-	const endPos = d.vec2f(end.x, __tsover_sub(1, end.y));
-	const acStart = d.vec2f(__tsover_mul(startPos.x, aspect), startPos.y);
-	const acEnd = d.vec2f(__tsover_mul(endPos.x, aspect), endPos.y);
-	const acUV = d.vec2f(__tsover_mul(uv.x, aspect), uv.y);
-	const lineVec = d.vec2f(__tsover_sub(acEnd.x, acStart.x), __tsover_sub(acEnd.y, acStart.y));
-	const toPoint = d.vec2f(__tsover_sub(acUV.x, acStart.x), __tsover_sub(acUV.y, acStart.y));
+	const startPos = vec2f(start.x, __tsover_sub(1, start.y));
+	const endPos = vec2f(end.x, __tsover_sub(1, end.y));
+	const acStart = vec2f(__tsover_mul(startPos.x, aspect), startPos.y);
+	const acEnd = vec2f(__tsover_mul(endPos.x, aspect), endPos.y);
+	const acUV = vec2f(__tsover_mul(uv.x, aspect), uv.y);
+	const lineVec = vec2f(__tsover_sub(acEnd.x, acStart.x), __tsover_sub(acEnd.y, acStart.y));
+	const toPoint = vec2f(__tsover_sub(acUV.x, acStart.x), __tsover_sub(acUV.y, acStart.y));
 	const dotProduct = __tsover_add(__tsover_mul(toPoint.x, lineVec.x), __tsover_mul(toPoint.y, lineVec.y));
 	const lineLengthSq = __tsover_add(__tsover_mul(lineVec.x, lineVec.x), __tsover_mul(lineVec.y, lineVec.y));
-	const t = std.clamp(__tsover_div(dotProduct, std.max(lineLengthSq, 1e-4)), 0, 1);
-	const closestPoint = d.vec2f(__tsover_add(acStart.x, __tsover_mul(lineVec.x, t)), __tsover_add(acStart.y, __tsover_mul(lineVec.y, t)));
-	const distVec = d.vec2f(__tsover_sub(acUV.x, closestPoint.x), __tsover_sub(acUV.y, closestPoint.y));
-	const distance = std.sqrt(__tsover_add(__tsover_mul(distVec.x, distVec.x), __tsover_mul(distVec.y, distVec.y)));
-	const startThick = __tsover_mul(startThickness, .25);
-	const endThick = __tsover_mul(endThickness, .25);
-	const thickness = std.mix(startThick, endThick, t);
-	const softness = std.mix(startSoftness, endSoftness, t);
-	const normalizedDist = __tsover_div(distance, std.max(thickness, 1e-4));
+	const t = clamp(__tsover_div(dotProduct, max(lineLengthSq, 1e-4)), 0, 1);
+	const closestPoint = vec2f(__tsover_add(acStart.x, __tsover_mul(lineVec.x, t)), __tsover_add(acStart.y, __tsover_mul(lineVec.y, t)));
+	const distVec = vec2f(__tsover_sub(acUV.x, closestPoint.x), __tsover_sub(acUV.y, closestPoint.y));
+	const distance = sqrt(__tsover_add(__tsover_mul(distVec.x, distVec.x), __tsover_mul(distVec.y, distVec.y)));
+	const thickness = mix(__tsover_mul(startThickness, .25), __tsover_mul(endThickness, .25), t);
+	const softness = mix(startSoftness, endSoftness, t);
+	const normalizedDist = __tsover_div(distance, max(thickness, 1e-4));
 	const edgeEnd = __tsover_add(1, softness);
-	const alphaBase = __tsover_sub(1, std.smoothstep(1, edgeEnd, normalizedDist));
-	const softnessFactor = __tsover_add(1, __tsover_mul(softness, 1.5));
-	const alpha = std.pow(alphaBase, softnessFactor);
-	const colorGradientStart = __tsover_sub(1, softness);
-	const colorGradientEnd = __tsover_add(1, softness);
-	const colorT = std.smoothstep(colorGradientStart, colorGradientEnd, normalizedDist);
-	return d.vec2f(colorT, alpha);
+	const alpha = pow(__tsover_sub(1, smoothstep(1, edgeEnd, normalizedDist)), __tsover_add(1, __tsover_mul(softness, 1.5)));
+	return vec2f(smoothstep(__tsover_sub(1, softness), __tsover_add(1, softness), normalizedDist), alpha);
 }), {
 	v: 1,
 	name: void 0,
@@ -719,8 +712,8 @@ const beamField = tgpu.fn([
 		"externalNames": ["d", "std"]
 	},
 	externals: () => ({
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {
@@ -734,7 +727,7 @@ const componentDefinition = {
 	acceptsUVContext: true,
 	extraFields: {
 		convA: {
-			schema: d.vec3f,
+			schema: vec3f,
 			initial: [
 				0,
 				0,
@@ -742,7 +735,7 @@ const componentDefinition = {
 			]
 		},
 		convB: {
-			schema: d.vec3f,
+			schema: vec3f,
 			initial: [
 				0,
 				0,

package/dist/core/{Bend-CFcEjifF.js → Bend-oof5pE1H.js}

@@ -1,43 +1,42 @@
-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 { s as transformEdges } from "./transformations-t0d2-uSX.js";
+import { $t as vec2f, Et as max, It as sin, N as unpremultiplyAlpha, Rt as sqrt, Vt as data_exports, _t as clamp, an as f32, bt as dot, c as sampleRemappedExpr, d as ZERO, et as src_default, mt as abs, n as composeEdgeRemapExpr, nt as std_exports, p as call, pt as select, vt as cos } from "./edges-BXNBKxSN.js";
+import { s as transformEdges } from "./transformations-CsPUHppB.js";
 var DEG_TO_RAD = Math.PI / 180;
 var CAMERA_D = 2;
 var B_MAX = 1.2;
-const bendRemap = tgpu.fn([
-	d.f32,
-	d.f32,
-	d.f32,
-	d.vec2f,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((strength, falloff, angle, uv, aspect) => {
+const bendRemap = src_default.fn([
+	f32,
+	f32,
+	f32,
+	vec2f,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((strength, falloff, angle, uv, aspect) => {
 	"use gpu";
 	const angleRad = __tsover_mul(angle, DEG_TO_RAD);
-	const dir = d.vec2f(std.cos(angleRad), std.sin(angleRad));
-	const perp = d.vec2f(__tsover_mul(dir.y, -1), dir.x);
-	const p = d.vec2f(__tsover_mul(__tsover_sub(uv.x, .5), aspect), __tsover_sub(uv.y, .5));
-	const sScreen = std.dot(p, dir);
-	const tScreen = std.dot(p, perp);
-	const sHalf = std.max(__tsover_mul(__tsover_add(__tsover_mul(std.abs(dir.x), aspect), std.abs(dir.y)), .5), .001);
+	const dir = vec2f(cos(angleRad), sin(angleRad));
+	const perp = vec2f(__tsover_mul(dir.y, -1), dir.x);
+	const p = vec2f(__tsover_mul(__tsover_sub(uv.x, .5), aspect), __tsover_sub(uv.y, .5));
+	const sScreen = dot(p, dir);
+	const tScreen = dot(p, perp);
+	const sHalf = max(__tsover_mul(__tsover_add(__tsover_mul(abs(dir.x), aspect), abs(dir.y)), .5), .001);
 	const snScreen = __tsover_div(sScreen, sHalf);
 	const b = __tsover_mul(strength, B_MAX);
-	const f = __tsover_mul(std.clamp(falloff, 0, 1), .9);
+	const f = __tsover_mul(clamp(falloff, 0, 1), .9);
 	const fSpan = __tsover_sub(1, f);
-	const m = std.abs(snScreen);
-	const sig = std.select(d.f32(-1), d.f32(1), snScreen >= 0);
+	const m = abs(snScreen);
+	const sig = select(f32(-1), f32(1), snScreen >= 0);
 	const a2 = __tsover_mul(b, m);
 	const disc = __tsover_add(__tsover_mul(__tsover_mul(__tsover_mul(CAMERA_D, CAMERA_D), fSpan), fSpan), __tsover_mul(__tsover_mul(__tsover_mul(4, a2), CAMERA_D), __tsover_sub(m, f)));
-	const nearZero = std.abs(a2) < 1e-5;
-	const denom = std.select(__tsover_mul(a2, 2), d.f32(1), nearZero);
-	const uQuad = __tsover_div(__tsover_sub(std.sqrt(std.max(disc, 0)), __tsover_mul(CAMERA_D, fSpan)), denom);
-	const uOn = std.select(uQuad, __tsover_div(__tsover_sub(m, f), fSpan), nearZero);
-	const u = std.select(d.f32(6), std.max(uOn, 0), disc >= 0);
+	const nearZero = abs(a2) < 1e-5;
+	const denom = select(__tsover_mul(a2, 2), f32(1), nearZero);
+	const uOn = select(__tsover_div(__tsover_sub(sqrt(max(disc, 0)), __tsover_mul(CAMERA_D, fSpan)), denom), __tsover_div(__tsover_sub(m, f), fSpan), nearZero);
+	const u = select(f32(6), max(uOn, 0), disc >= 0);
 	const snBend = __tsover_mul(sig, __tsover_add(f, __tsover_mul(u, fSpan)));
 	const inFlat = m <= f;
-	const sn = std.select(snBend, snScreen, inFlat);
-	const z = std.select(__tsover_mul(__tsover_mul(b, u), u), d.f32(0), inFlat);
+	const sn = select(snBend, snScreen, inFlat);
+	const z = select(__tsover_mul(__tsover_mul(b, u), u), f32(0), inFlat);
 	const tSrc = __tsover_div(__tsover_mul(tScreen, __tsover_sub(CAMERA_D, z)), CAMERA_D);
 	const srcP = dir.mul(__tsover_mul(sn, sHalf)).add(perp.mul(tSrc));
-	return d.vec2f(__tsover_add(__tsover_div(srcP.x, aspect), .5), __tsover_add(srcP.y, .5));
+	return vec2f(__tsover_add(__tsover_div(srcP.x, aspect), .5), __tsover_add(srcP.y, .5));
 }), {
 	v: 1,
 	name: void 0,
@@ -738,8 +737,8 @@ const bendRemap = tgpu.fn([
 	},
 	externals: () => ({
 		DEG_TO_RAD,
-		d,
-		std,
+		d: data_exports,
+		std: std_exports,
 		B_MAX,
 		CAMERA_D
 	})

package/dist/core/{Blob-CgUolAhz.js → Blob-cfvDCv0i.js}

@@ -1,19 +1,19 @@
-import { Et as mixColorStopsRuntime, 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, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-t0d2-uSX.js";
-import { h as colorStopsPropConfig, t as animatedTime } from "./porters-BmU6G9TR.js";
-const blobOrganicRadius = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, size, deformation, animTime) => {
+import { $t as vec2f, At as pow, Et as max, H as mixColorsLinear, It as sin, Lt as smoothstep, Mt as reflect, Tt as length, U as mixColorsVariants, Vt as data_exports, an as f32, bt as dot, et as src_default, in as vec4f, kt as normalize, nn as vec3f, nt as std_exports, p as call } from "./edges-BXNBKxSN.js";
+import { S as mixColorStopsRuntime, h as colorStopsPropConfig, t as animatedTime } from "./porters-DBK1Aipq.js";
+import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
+const blobOrganicRadius = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, size, deformation, animTime) => {
 	"use gpu";
-	const ns = d.f32(4);
+	const ns = f32(4);
 	const at = animTime;
-	const noise1 = __tsover_mul(__tsover_mul(__tsover_add(__tsover_mul(std.sin(__tsover_add(__tsover_mul(uv.x, __tsover_mul(ns, .8)), __tsover_mul(at, .8))), std.sin(__tsover_add(__tsover_mul(uv.y, __tsover_mul(ns, .7)), __tsover_mul(at, .6)))), std.sin(__tsover_sub(__tsover_mul(uv.x, __tsover_mul(ns, 1.2)), __tsover_add(__tsover_mul(uv.y, __tsover_mul(ns, .9)), __tsover_mul(at, .4))))), .15), deformation);
-	const noise2 = __tsover_mul(__tsover_mul(__tsover_mul(std.sin(__tsover_sub(__tsover_mul(uv.x, __tsover_mul(ns, 1.4)), __tsover_mul(at, .5))), std.sin(__tsover_add(__tsover_mul(uv.y, __tsover_mul(ns, 1.1)), __tsover_mul(at, .7)))), .12), deformation);
-	const noise3 = __tsover_mul(__tsover_mul(__tsover_add(std.sin(__tsover_add(__tsover_mul(uv.x, __tsover_mul(ns, 1.8)), __tsover_add(__tsover_mul(uv.y, __tsover_mul(ns, 1.6)), __tsover_mul(at, .3)))), std.sin(__tsover_sub(__tsover_mul(uv.x, __tsover_mul(ns, .6)), __tsover_mul(at, .9)))), .1), deformation);
-	const noise4 = __tsover_mul(__tsover_mul(__tsover_mul(std.sin(__tsover_add(__tsover_mul(uv.x, __tsover_mul(ns, 2.2)), __tsover_mul(at, .2))), std.sin(__tsover_sub(__tsover_mul(uv.y, __tsover_mul(ns, 1.9)), __tsover_mul(at, .8)))), .04), deformation);
+	const noise1 = __tsover_mul(__tsover_mul(__tsover_add(__tsover_mul(sin(__tsover_add(__tsover_mul(uv.x, __tsover_mul(ns, .8)), __tsover_mul(at, .8))), sin(__tsover_add(__tsover_mul(uv.y, __tsover_mul(ns, .7)), __tsover_mul(at, .6)))), sin(__tsover_sub(__tsover_mul(uv.x, __tsover_mul(ns, 1.2)), __tsover_add(__tsover_mul(uv.y, __tsover_mul(ns, .9)), __tsover_mul(at, .4))))), .15), deformation);
+	const noise2 = __tsover_mul(__tsover_mul(__tsover_mul(sin(__tsover_sub(__tsover_mul(uv.x, __tsover_mul(ns, 1.4)), __tsover_mul(at, .5))), sin(__tsover_add(__tsover_mul(uv.y, __tsover_mul(ns, 1.1)), __tsover_mul(at, .7)))), .12), deformation);
+	const noise3 = __tsover_mul(__tsover_mul(__tsover_add(sin(__tsover_add(__tsover_mul(uv.x, __tsover_mul(ns, 1.8)), __tsover_add(__tsover_mul(uv.y, __tsover_mul(ns, 1.6)), __tsover_mul(at, .3)))), sin(__tsover_sub(__tsover_mul(uv.x, __tsover_mul(ns, .6)), __tsover_mul(at, .9)))), .1), deformation);
+	const noise4 = __tsover_mul(__tsover_mul(__tsover_mul(sin(__tsover_add(__tsover_mul(uv.x, __tsover_mul(ns, 2.2)), __tsover_mul(at, .2))), sin(__tsover_sub(__tsover_mul(uv.y, __tsover_mul(ns, 1.9)), __tsover_mul(at, .8)))), .04), deformation);
 	return __tsover_add(size, __tsover_add(__tsover_add(__tsover_add(noise1, noise2), noise3), noise4));
 }), {
 	v: 1,
@@ -492,50 +492,45 @@ const blobOrganicRadius = tgpu.fn([
 		"externalNames": ["d", "std"]
 	},
 	externals: () => ({
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
-const blobField = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((baseUV, viewport, center, size, deformation, softness, highlightIntensity, normLx, normLy, normLz, animTime) => {
+const blobField = src_default.fn([
+	vec2f,
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((baseUV, viewport, center, size, deformation, softness, highlightIntensity, normLx, normLy, normLz, animTime) => {
 	"use gpu";
 	const edgeWidth = __tsover_mul(softness, .3);
 	const edgeCurve = __tsover_add(__tsover_mul(softness, 2), .5);
 	const aspect = __tsover_div(viewport.x, viewport.y);
-	const uv = d.vec2f(__tsover_sub(__tsover_mul(baseUV.x, aspect), __tsover_mul(center.x, aspect)), __tsover_sub(baseUV.y, __tsover_sub(1, center.y)));
-	const dist = std.length(uv);
+	const uv = vec2f(__tsover_sub(__tsover_mul(baseUV.x, aspect), __tsover_mul(center.x, aspect)), __tsover_sub(baseUV.y, __tsover_sub(1, center.y)));
+	const dist = length(uv);
 	const organicRadius = blobOrganicRadius(uv, size, deformation, animTime);
-	const linearMask = __tsover_sub(1, std.smoothstep(__tsover_sub(organicRadius, edgeWidth), __tsover_add(organicRadius, edgeWidth), dist));
-	const blobMask = std.pow(linearMask, edgeCurve);
-	const normalTilt = std.smoothstep(0, organicRadius, dist);
+	const blobMask = pow(__tsover_sub(1, smoothstep(__tsover_sub(organicRadius, edgeWidth), __tsover_add(organicRadius, edgeWidth), dist)), edgeCurve);
+	const normalTilt = smoothstep(0, organicRadius, dist);
 	const fakeZ = __tsover_sub(1, __tsover_mul(normalTilt, .1));
 	const tilted = __tsover_add(normalTilt, .2);
-	const surfaceNormal = std.normalize(d.vec3f(__tsover_mul(uv.x, tilted), __tsover_mul(uv.y, tilted), fakeZ));
-	const lightDir = d.vec3f(normLx, normLy, normLz);
-	const viewDir = d.vec3f(0, 0, 1);
-	const reflectDir = std.reflect(lightDir.mul(-1), surfaceNormal);
-	const specDot = std.max(0, std.dot(reflectDir, viewDir));
-	const specular = std.pow(specDot, 32);
+	const surfaceNormal = normalize(vec3f(__tsover_mul(uv.x, tilted), __tsover_mul(uv.y, tilted), fakeZ));
+	const lightDir = vec3f(normLx, normLy, normLz);
+	const viewDir = vec3f(0, 0, 1);
+	const specular = pow(max(0, dot(reflect(lightDir.mul(-1), surfaceNormal), viewDir)), 32);
 	const curvatureBoost = __tsover_add(__tsover_mul(normalTilt, .5), .5);
 	const finalHighlight = __tsover_mul(__tsover_mul(__tsover_mul(specular, curvatureBoost), highlightIntensity), blobMask);
 	const posX = __tsover_mul(uv.x, 3);
 	const posY = __tsover_mul(uv.y, 3);
-	const colorNoise1 = __tsover_add(__tsover_mul(__tsover_add(__tsover_mul(std.sin(__tsover_add(posX, __tsover_mul(animTime, .4))), std.sin(__tsover_add(posY, __tsover_mul(animTime, .3)))), std.sin(__tsover_add(__tsover_add(__tsover_mul(posX, .7), __tsover_mul(posY, .8)), __tsover_mul(animTime, .2)))), .5), .5);
-	const colorNoise2 = __tsover_add(__tsover_mul(__tsover_add(__tsover_mul(std.sin(__tsover_sub(__tsover_mul(posX, 1.3), __tsover_mul(animTime, .5))), std.sin(__tsover_add(__tsover_mul(posY, 1.1), __tsover_mul(animTime, .6)))), std.sin(__tsover_sub(__tsover_mul(posX, .5), __tsover_sub(__tsover_mul(posY, .6), __tsover_mul(animTime, .3))))), .5), .5);
-	const combinedNoise = __tsover_add(__tsover_mul(colorNoise1, .6), __tsover_mul(colorNoise2, .4));
-	const mixFactor = std.smoothstep(.1, .9, combinedNoise);
-	return d.vec3f(mixFactor, finalHighlight, blobMask);
+	const colorNoise1 = __tsover_add(__tsover_mul(__tsover_add(__tsover_mul(sin(__tsover_add(posX, __tsover_mul(animTime, .4))), sin(__tsover_add(posY, __tsover_mul(animTime, .3)))), sin(__tsover_add(__tsover_add(__tsover_mul(posX, .7), __tsover_mul(posY, .8)), __tsover_mul(animTime, .2)))), .5), .5);
+	const colorNoise2 = __tsover_add(__tsover_mul(__tsover_add(__tsover_mul(sin(__tsover_sub(__tsover_mul(posX, 1.3), __tsover_mul(animTime, .5))), sin(__tsover_add(__tsover_mul(posY, 1.1), __tsover_mul(animTime, .6)))), sin(__tsover_sub(__tsover_mul(posX, .5), __tsover_sub(__tsover_mul(posY, .6), __tsover_mul(animTime, .3))))), .5), .5);
+	return vec3f(smoothstep(.1, .9, __tsover_add(__tsover_mul(colorNoise1, .6), __tsover_mul(colorNoise2, .4))), finalHighlight, blobMask);
 }), {
 	v: 1,
 	name: void 0,
@@ -1253,22 +1248,21 @@ const blobField = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		d,
-		std,
+		d: data_exports,
+		std: std_exports,
 		blobOrganicRadius
 	})
 }) && $.f)({}));
-const blobCompose = tgpu.fn([
-	d.vec4f,
-	d.vec4f,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((colorMix, highlightColor, finalHighlight, avgAlpha, blobMask) => {
+const blobCompose = src_default.fn([
+	vec4f,
+	vec4f,
+	f32,
+	f32,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((colorMix, highlightColor, finalHighlight, avgAlpha, blobMask) => {
 	"use gpu";
 	const highlightContribution = highlightColor.xyz.mul(finalHighlight);
-	const rgb = colorMix.xyz.add(highlightContribution);
-	return d.vec4f(rgb, __tsover_mul(avgAlpha, blobMask));
+	return vec4f(colorMix.xyz.add(highlightContribution), __tsover_mul(avgAlpha, blobMask));
 }), {
 	v: 1,
 	name: void 0,
@@ -1347,7 +1341,7 @@ const blobCompose = tgpu.fn([
 		]],
 		"externalNames": ["d"]
 	},
-	externals: () => ({ d })
+	externals: () => ({ d: data_exports })
 }) && $.f)({}));
 const componentDefinition = {
 	name: "Blob",
@@ -1357,15 +1351,15 @@ const componentDefinition = {
 	animatedTime: { speed: "speed" },
 	extraFields: {
 		normLx: {
-			schema: d.f32,
+			schema: f32,
 			initial: 0
 		},
 		normLy: {
-			schema: d.f32,
+			schema: f32,
 			initial: 0
 		},
 		normLz: {
-			schema: d.f32,
+			schema: f32,
 			initial: 1
 		}
 	},

package/dist/core/{BlockDissolve-CLSxXB4e.js → BlockDissolve-C7yJzYGZ.js}

@@ -1,23 +1,24 @@
-import { Bt as ZERO, Ht as call, J as std, Tn as d, n as tgpu, pt as noise_exports, st as hash12 } from "./coords-BkIjixe_.js";
-import { i as transformBoolean } from "./transformations-t0d2-uSX.js";
-const blockDissolveMask = tgpu.fn([
-	d.vec4f,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, uv, aspect, blockSize, softness, progress, invert) => {
+import { $t as vec2f, Ct as floor, Et as max, Lt as smoothstep, Vt as data_exports, an as f32, d as ZERO, et as src_default, in as vec4f, nt as std_exports, p as call, pt as select } from "./edges-BXNBKxSN.js";
+import { p as noise_exports, s as hash12 } from "./noise-wTSHXgFz.js";
+import { i as transformBoolean } from "./transformations-CsPUHppB.js";
+const blockDissolveMask = src_default.fn([
+	vec4f,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, uv, aspect, blockSize, softness, progress, invert) => {
 	"use gpu";
-	const gridX = __tsover_div(1, std.max(blockSize, .001));
-	const gridY = std.max(__tsover_div(gridX, aspect), 1);
-	let r = hash12(d.vec2f(std.floor(__tsover_mul(uv.x, gridX)), std.floor(__tsover_mul(uv.y, gridY))));
-	r = std.select(r, __tsover_sub(1, r), invert > 0);
-	const f = std.max(softness, 1e-4);
+	const gridX = __tsover_div(1, max(blockSize, .001));
+	const gridY = max(__tsover_div(gridX, aspect), 1);
+	let r = hash12(vec2f(floor(__tsover_mul(uv.x, gridX)), floor(__tsover_mul(uv.y, gridY))));
+	r = select(r, __tsover_sub(1, r), invert > 0);
+	const f = max(softness, 1e-4);
 	const front = __tsover_sub(__tsover_mul(progress, __tsover_add(1, __tsover_mul(2, f))), f);
-	const reveal = std.smoothstep(__tsover_sub(front, f), __tsover_add(front, f), r);
-	return d.vec4f(color.x, color.y, color.z, __tsover_mul(color.w, reveal));
+	const reveal = smoothstep(__tsover_sub(front, f), __tsover_add(front, f), r);
+	return vec4f(color.x, color.y, color.z, __tsover_mul(color.w, reveal));
 }), {
 	v: 1,
 	name: void 0,
@@ -285,8 +286,8 @@ const blockDissolveMask = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		std,
-		d,
+		std: std_exports,
+		d: data_exports,
 		noise: noise_exports
 	})
 }) && $.f)({}));

package/dist/core/{BlockNoise-BgEJOicU.js → BlockNoise-DaM9YDAH.js}

@@ -1,17 +1,19 @@
-import { Ht as call, J as std, Tn as d, bt as value13, et as toneAndColorExpr, 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 blockNoiseField = 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 { b as value13, 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 blockNoiseField = 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 value13(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 value13(vec3f(pos.x, pos.y, __tsover_mul(animTime, .3)));
 }), {
 	v: 1,
 	name: void 0,
@@ -154,8 +156,8 @@ const blockNoiseField = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		d,
-		std,
+		d: data_exports,
+		std: std_exports,
 		noise: noise_exports
 	})
 }) && $.f)({}));

package/dist/core/{BlueNoise-BqMtBLxM.js → BlueNoise-BMMRTsMw.js}

@@ -1,13 +1,15 @@
-import { Ht as call, J as std, Tn as d, et as toneAndColorExpr, n as tgpu, pt as noise_exports, tt as blue12 } from "./coords-BkIjixe_.js";
-import { i as noiseToneProps, t as noiseColorProps } from "./noiseColor-CRpf22bk.js";
-const blueNoiseField = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.f32
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, grain, seed) => {
+import { $t as vec2f, Ct as floor, an as f32, et as src_default, nt as std_exports, p as call } from "./edges-BXNBKxSN.js";
+import { p as noise_exports, t as blue12 } from "./noise-wTSHXgFz.js";
+import { n as toneAndColorExpr } from "./noiseColor-CPakiKNF.js";
+import { i as noiseToneProps, t as noiseColorProps } from "./noiseColor-DscZM9CO.js";
+const blueNoiseField = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, grain, seed) => {
 	"use gpu";
-	return blue12(std.floor(uv.mul(viewport).div(grain)).add(seed));
+	return blue12(floor(uv.mul(viewport).div(grain)).add(seed));
 }), {
 	v: 1,
 	name: void 0,
@@ -78,7 +80,7 @@ const blueNoiseField = tgpu.fn([
 		"externalNames": ["std", "noise"]
 	},
 	externals: () => ({
-		std,
+		std: std_exports,
 		noise: noise_exports
 	})
 }) && $.f)({}));

package/dist/core/{Blur-Xaa6jVPT.js → Blur-Be7sX4v9.js}

@@ -1,42 +1,42 @@
-import { Bt as ZERO, Ht as call, J as std, Jt as vec4, K as createGaussianBlurCompute, Tn as d, U as BLUR_MAP_FORMAT, X as createGuardedCompute, cn as unpremultiplyAlpha, n as tgpu, q as createVariableGaussianBlurCompute } from "./coords-BkIjixe_.js";
+import { At as pow, Et as max, Gt as textureStorage2d, N as unpremultiplyAlpha, Ot as mix, Pt as round, 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, sn as u32, tn as vec2u, y as vec4 } from "./edges-BXNBKxSN.js";
+import { n as createGuardedCompute } from "./compute-BjeJ0sIA.js";
+import { a as createVariableGaussianBlurCompute, i as createGaussianBlurCompute, t as BLUR_MAP_FORMAT } from "./blur-tvWOoxKt.js";
 const INTENSITY_TO_RADIUS = .36;
 const intensityToRadius = (intensity) => intensity * INTENSITY_TO_RADIUS;
 function fillMapParams() {
-	return d.struct({
-		inputWidth: d.f32,
-		inputHeight: d.f32,
-		inputMin: d.f32,
-		inputMax: d.f32,
-		outputMin: d.f32,
-		outputMax: d.f32,
-		curve: d.f32
+	return struct({
+		inputWidth: f32,
+		inputHeight: f32,
+		inputMin: f32,
+		inputMax: f32,
+		outputMin: f32,
+		outputMax: f32,
+		curve: f32
 	});
 }
 function buildFillBlurMapGraph(computeWidth, computeHeight, channel) {
 	const Params = fillMapParams();
-	const layout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
-		source: { texture: d.texture2d(d.f32) },
-		blurMap: { storageTexture: d.textureStorage2d(BLUR_MAP_FORMAT, "write-only") },
+	const layout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
+		source: { texture: texture2d(f32) },
+		blurMap: { storageTexture: textureStorage2d(BLUR_MAP_FORMAT, "write-only") },
 		params: { uniform: Params }
 	}), "layout");
 	return {
 		layout,
-		kernel: tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+		kernel: src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
 			"use gpu";
 			const p = layout.$.params;
-			const u = __tsover_div(__tsover_add(d.f32(cx), .5), computeWidth);
-			const v = __tsover_div(__tsover_add(d.f32(cy), .5), computeHeight);
-			const srcX = std.clamp(d.i32(std.round(__tsover_mul(u, p.inputWidth))), 0, d.i32(__tsover_sub(p.inputWidth, 1)));
-			const srcY = std.clamp(d.i32(std.round(__tsover_mul(v, p.inputHeight))), 0, d.i32(__tsover_sub(p.inputHeight, 1)));
-			const sample = std.textureLoad(layout.$.source, d.vec2u(d.u32(srcX), d.u32(srcY)), 0);
-			const raw = channel === "alpha" ? sample.w : channel === "alphaInverted" ? __tsover_sub(1, sample.w) : channel === "luminanceInverted" ? __tsover_sub(1, std.dot(sample.xyz, d.vec3f(.2126, .7152, .0722))) : std.dot(sample.xyz, d.vec3f(.2126, .7152, .0722));
-			const inputRange = std.max(__tsover_sub(p.inputMax, p.inputMin), 1e-4);
-			const normalised = std.clamp(__tsover_div(__tsover_sub(raw, p.inputMin), inputRange), 0, 1);
-			const exponent = std.pow(2, __tsover_mul(-p.curve, 2));
-			const eased = std.pow(normalised, exponent);
-			const remapped = std.mix(p.outputMin, p.outputMax, eased);
+			const u = __tsover_div(__tsover_add(f32(cx), .5), computeWidth);
+			const v = __tsover_div(__tsover_add(f32(cy), .5), computeHeight);
+			const srcX = clamp(i32(round(__tsover_mul(u, p.inputWidth))), 0, i32(__tsover_sub(p.inputWidth, 1)));
+			const srcY = clamp(i32(round(__tsover_mul(v, p.inputHeight))), 0, i32(__tsover_sub(p.inputHeight, 1)));
+			const sample = textureLoad(layout.$.source, vec2u(u32(srcX), u32(srcY)), 0);
+			const raw = channel === "alpha" ? sample.w : channel === "alphaInverted" ? __tsover_sub(1, sample.w) : channel === "luminanceInverted" ? __tsover_sub(1, dot(sample.xyz, vec3f(.2126, .7152, .0722))) : dot(sample.xyz, vec3f(.2126, .7152, .0722));
+			const inputRange = max(__tsover_sub(p.inputMax, p.inputMin), 1e-4);
+			const eased = pow(clamp(__tsover_div(__tsover_sub(raw, p.inputMin), inputRange), 0, 1), pow(2, __tsover_mul(-p.curve, 2)));
+			const remapped = mix(p.outputMin, p.outputMax, eased);
 			const radius = __tsover_mul(remapped, .36);
-			std.textureStore(layout.$.blurMap, d.vec2u(cx, cy), d.vec4f(radius, 0, 0, 1));
+			textureStore(layout.$.blurMap, vec2u(cx, cy), vec4f(radius, 0, 0, 1));
 		}), {
 			v: 1,
 			name: void 0,
@@ -561,10 +561,10 @@ function buildFillBlurMapGraph(computeWidth, computeHeight, channel) {
 			},
 			externals: () => ({
 				layout,
-				d,
+				d: data_exports,
 				computeWidth,
 				computeHeight,
-				std,
+				std: std_exports,
 				channel
 			})
 		}) && $.f)({})).$name("fillBlurMap"),