shaders 3.0.448 → 3.0.450

package/dist/core/{BokehBlur-B5fql96U.js → BokehBlur-Cfaqbh3I.js}

@@ -1,5 +1,7 @@
-import { Bt as ZERO, G as DEFAULT_COMPUTE_WIDTH, Ht as call, J as std, Tn as d, W as DEFAULT_COMPUTE_HEIGHT, X as createGuardedCompute, cn as unpremultiplyAlpha, n as tgpu } from "./coords-BkIjixe_.js";
-import { r as transformAngle } from "./transformations-t0d2-uSX.js";
+import { At as mix, Gt as arrayOf, It as round, Kt as texture2d, Mt as pow, N as unpremultiplyAlpha, Ot as max, Qt as struct, St as dot, Ut as data_exports, cn as i32, d as ZERO, et as src_default, in as vec3f, it as textureLoad, ln as u32, nt as std_exports, on as vec4f, ot as textureStore, p as call, qt as textureStorage2d, rn as vec2u, sn as f32, tn as vec2f, yt as clamp, zt as smoothstep } from "./edges-BZUKQxSE.js";
+import { n as createGuardedCompute } from "./compute-BoeIXi0l.js";
+import { n as DEFAULT_COMPUTE_HEIGHT, r as DEFAULT_COMPUTE_WIDTH } from "./blur-DKmdsW6d.js";
+import { r as transformAngle } from "./transformations-CsPUHppB.js";
 var GOLDEN_ANGLE = Math.PI * (3 - Math.sqrt(5));
 var TWO_PI = Math.PI * 2;
 var DEG_TO_RAD = Math.PI / 180;
@@ -138,7 +140,7 @@ function generateBokehTaps(shape, bladeCount, tapCount) {
 	}
 	if (taps.length === 0) return generateBokehTaps("circle", 0, tapCount);
 	for (let i = 0; taps.length < tapCount; i++) taps.push(taps[i % taps.length]);
-	const maxLen = taps.reduce((max, tap) => Math.max(max, Math.hypot(tap.x, tap.y)), 0);
+	const maxLen = taps.reduce((max$1, tap) => Math.max(max$1, Math.hypot(tap.x, tap.y)), 0);
 	if (maxLen > 1) {
 		const inv = 1 / maxLen;
 		for (const tap of taps) {
@@ -149,97 +151,97 @@ function generateBokehTaps(shape, bladeCount, tapCount) {
 	return taps;
 }
 function bokehParams() {
-	return d.struct({
-		radius: d.f32,
-		highlightGain: d.f32,
-		highlightThreshold: d.f32,
-		rotCos: d.f32,
-		rotSin: d.f32,
-		chromaticFringe: d.f32,
-		inputWidth: d.f32,
-		inputHeight: d.f32
+	return struct({
+		radius: f32,
+		highlightGain: f32,
+		highlightThreshold: f32,
+		rotCos: f32,
+		rotSin: f32,
+		chromaticFringe: f32,
+		inputWidth: f32,
+		inputHeight: f32
 	});
 }
 function bokehMapParams() {
-	return d.struct({
-		highlightGain: d.f32,
-		highlightThreshold: d.f32,
-		rotCos: d.f32,
-		rotSin: d.f32,
-		chromaticFringe: d.f32,
-		inputWidth: d.f32,
-		inputHeight: d.f32,
-		inputMin: d.f32,
-		inputMax: d.f32,
-		outputMin: d.f32,
-		outputMax: d.f32,
-		curve: d.f32
+	return struct({
+		highlightGain: f32,
+		highlightThreshold: f32,
+		rotCos: f32,
+		rotSin: f32,
+		chromaticFringe: f32,
+		inputWidth: f32,
+		inputHeight: f32,
+		inputMin: f32,
+		inputMax: f32,
+		outputMin: f32,
+		outputMax: f32,
+		curve: f32
 	});
 }
 function buildBokehGraph(computeWidth, computeHeight, tapCount) {
 	const TAPS = tapCount;
 	const Params = bokehParams();
-	const TapArray = d.arrayOf(d.vec4f, TAPS);
-	const layout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
-		input: { texture: d.texture2d(d.f32) },
-		output: { storageTexture: d.textureStorage2d(OUTPUT_FORMAT, "write-only") },
+	const TapArray = arrayOf(vec4f, TAPS);
+	const layout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
+		input: { texture: texture2d(f32) },
+		output: { storageTexture: textureStorage2d(OUTPUT_FORMAT, "write-only") },
 		params: { uniform: Params },
 		taps: { uniform: TapArray }
 	}), "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 radius = p.radius;
-			const inputCx = __tsover_sub(__tsover_div(__tsover_mul(__tsover_add(d.f32(cx), .5), p.inputWidth), computeWidth), .5);
-			const inputCy = __tsover_sub(__tsover_div(__tsover_mul(__tsover_add(d.f32(cy), .5), p.inputHeight), computeHeight), .5);
-			const inputWm1 = d.i32(__tsover_sub(p.inputWidth, 1));
-			const inputHm1 = d.i32(__tsover_sub(p.inputHeight, 1));
+			const inputCx = __tsover_sub(__tsover_div(__tsover_mul(__tsover_add(f32(cx), .5), p.inputWidth), computeWidth), .5);
+			const inputCy = __tsover_sub(__tsover_div(__tsover_mul(__tsover_add(f32(cy), .5), p.inputHeight), computeHeight), .5);
+			const inputWm1 = i32(__tsover_sub(p.inputWidth, 1));
+			const inputHm1 = i32(__tsover_sub(p.inputHeight, 1));
 			if (radius < PASSTHROUGH_RADIUS) {
-				const sx = std.clamp(d.i32(std.round(inputCx)), 0, inputWm1);
-				const sy = std.clamp(d.i32(std.round(inputCy)), 0, inputHm1);
-				const texel = std.textureLoad(layout.$.input, d.vec2u(d.u32(sx), d.u32(sy)), 0);
-				std.textureStore(layout.$.output, d.vec2u(cx, cy), texel);
+				const sx = clamp(i32(round(inputCx)), 0, inputWm1);
+				const sy = clamp(i32(round(inputCy)), 0, inputHm1);
+				const texel = textureLoad(layout.$.input, vec2u(u32(sx), u32(sy)), 0);
+				textureStore(layout.$.output, vec2u(cx, cy), texel);
 			} else {
 				const gain = p.highlightGain;
 				const threshold = p.highlightThreshold;
 				const fringe = p.chromaticFringe;
 				const rotC = p.rotCos;
 				const rotS = p.rotSin;
-				let accum = d.vec3f(0, 0, 0);
-				let alphaAccum = d.f32(0);
-				let wSum = d.f32(0);
+				let accum = vec3f(0, 0, 0);
+				let alphaAccum = f32(0);
+				let wSum = f32(0);
 				for (let i = 0; i < TAPS; i++) {
 					const tap = layout.$.taps[i];
 					const ox = __tsover_sub(__tsover_mul(tap.x, rotC), __tsover_mul(tap.y, rotS));
 					const oy = __tsover_add(__tsover_mul(tap.x, rotS), __tsover_mul(tap.y, rotC));
-					const off = d.vec2f(__tsover_mul(ox, radius), __tsover_mul(oy, radius));
-					const sx = std.clamp(d.i32(std.round(__tsover_add(inputCx, off.x))), 0, inputWm1);
-					const sy = std.clamp(d.i32(std.round(__tsover_add(inputCy, off.y))), 0, inputHm1);
-					const base = std.textureLoad(layout.$.input, d.vec2u(d.u32(sx), d.u32(sy)), 0);
+					const off = vec2f(__tsover_mul(ox, radius), __tsover_mul(oy, radius));
+					const sx = clamp(i32(round(__tsover_add(inputCx, off.x))), 0, inputWm1);
+					const sy = clamp(i32(round(__tsover_add(inputCy, off.y))), 0, inputHm1);
+					const base = textureLoad(layout.$.input, vec2u(u32(sx), u32(sy)), 0);
 					let colR = base.x;
 					let colB = base.z;
 					if (fringe > .001) {
 						const offR = off.mul(__tsover_add(1, __tsover_mul(fringe, .5)));
-						const rx = std.clamp(d.i32(std.round(__tsover_add(inputCx, offR.x))), 0, inputWm1);
-						const ry = std.clamp(d.i32(std.round(__tsover_add(inputCy, offR.y))), 0, inputHm1);
-						colR = std.textureLoad(layout.$.input, d.vec2u(d.u32(rx), d.u32(ry)), 0).x;
+						const rx = clamp(i32(round(__tsover_add(inputCx, offR.x))), 0, inputWm1);
+						const ry = clamp(i32(round(__tsover_add(inputCy, offR.y))), 0, inputHm1);
+						colR = textureLoad(layout.$.input, vec2u(u32(rx), u32(ry)), 0).x;
 						const offB = off.mul(__tsover_sub(1, __tsover_mul(fringe, .5)));
-						const bx = std.clamp(d.i32(std.round(__tsover_add(inputCx, offB.x))), 0, inputWm1);
-						const by = std.clamp(d.i32(std.round(__tsover_add(inputCy, offB.y))), 0, inputHm1);
-						colB = std.textureLoad(layout.$.input, d.vec2u(d.u32(bx), d.u32(by)), 0).z;
+						const bx = clamp(i32(round(__tsover_add(inputCx, offB.x))), 0, inputWm1);
+						const by = clamp(i32(round(__tsover_add(inputCy, offB.y))), 0, inputHm1);
+						colB = textureLoad(layout.$.input, vec2u(u32(bx), u32(by)), 0).z;
 					}
-					const col = d.vec3f(colR, base.y, colB);
-					const lum = std.dot(base.xyz, d.vec3f(.2126, .7152, .0722));
-					const hi = std.smoothstep(threshold, __tsover_add(threshold, HIGHLIGHT_KNEE), lum);
+					const col = vec3f(colR, base.y, colB);
+					const lum = dot(base.xyz, vec3f(.2126, .7152, .0722));
+					const hi = smoothstep(threshold, __tsover_add(threshold, HIGHLIGHT_KNEE), lum);
 					const w = __tsover_mul(__tsover_add(1, __tsover_mul(__tsover_mul(gain, hi), hi)), tap.z);
 					accum = accum.add(col.mul(w));
 					alphaAccum = __tsover_add(alphaAccum, __tsover_mul(base.w, w));
 					wSum = __tsover_add(wSum, w);
 				}
-				const invW = __tsover_div(1, std.max(wSum, 1e-4));
-				std.textureStore(layout.$.output, d.vec2u(cx, cy), d.vec4f(accum.mul(invW), __tsover_mul(alphaAccum, invW)));
+				const invW = __tsover_div(1, max(wSum, 1e-4));
+				textureStore(layout.$.output, vec2u(cx, cy), vec4f(accum.mul(invW), __tsover_mul(alphaAccum, invW)));
 			}
 		}), {
 			v: 1,
@@ -1475,11 +1477,11 @@ function buildBokehGraph(computeWidth, computeHeight, tapCount) {
 			},
 			externals: () => ({
 				layout,
-				d,
+				d: data_exports,
 				computeWidth,
 				computeHeight,
 				PASSTHROUGH_RADIUS,
-				std,
+				std: std_exports,
 				TAPS,
 				HIGHLIGHT_KNEE
 			})
@@ -1491,78 +1493,76 @@ function buildBokehGraph(computeWidth, computeHeight, tapCount) {
 function buildBokehMapGraph(computeWidth, computeHeight, tapCount, channel) {
 	const TAPS = tapCount;
 	const Params = bokehMapParams();
-	const TapArray = d.arrayOf(d.vec4f, TAPS);
-	const layout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
-		input: { texture: d.texture2d(d.f32) },
-		source: { texture: d.texture2d(d.f32) },
-		output: { storageTexture: d.textureStorage2d(OUTPUT_FORMAT, "write-only") },
+	const TapArray = arrayOf(vec4f, TAPS);
+	const layout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
+		input: { texture: texture2d(f32) },
+		source: { texture: texture2d(f32) },
+		output: { storageTexture: textureStorage2d(OUTPUT_FORMAT, "write-only") },
 		params: { uniform: Params },
 		taps: { uniform: TapArray }
 	}), "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 inputCx = __tsover_sub(__tsover_div(__tsover_mul(__tsover_add(d.f32(cx), .5), p.inputWidth), computeWidth), .5);
-			const inputCy = __tsover_sub(__tsover_div(__tsover_mul(__tsover_add(d.f32(cy), .5), p.inputHeight), computeHeight), .5);
-			const inputWm1 = d.i32(__tsover_sub(p.inputWidth, 1));
-			const inputHm1 = d.i32(__tsover_sub(p.inputHeight, 1));
-			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, inputWm1);
-			const srcY = std.clamp(d.i32(std.round(__tsover_mul(v, p.inputHeight))), 0, inputHm1);
-			const mapSample = std.textureLoad(layout.$.source, d.vec2u(d.u32(srcX), d.u32(srcY)), 0);
-			const raw = channel === "alpha" ? mapSample.w : channel === "alphaInverted" ? __tsover_sub(1, mapSample.w) : channel === "luminanceInverted" ? __tsover_sub(1, std.dot(mapSample.xyz, d.vec3f(.2126, .7152, .0722))) : std.dot(mapSample.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 radius = __tsover_mul(std.mix(p.outputMin, p.outputMax, eased), .8);
+			const inputCx = __tsover_sub(__tsover_div(__tsover_mul(__tsover_add(f32(cx), .5), p.inputWidth), computeWidth), .5);
+			const inputCy = __tsover_sub(__tsover_div(__tsover_mul(__tsover_add(f32(cy), .5), p.inputHeight), computeHeight), .5);
+			const inputWm1 = i32(__tsover_sub(p.inputWidth, 1));
+			const inputHm1 = i32(__tsover_sub(p.inputHeight, 1));
+			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, inputWm1);
+			const srcY = clamp(i32(round(__tsover_mul(v, p.inputHeight))), 0, inputHm1);
+			const mapSample = textureLoad(layout.$.source, vec2u(u32(srcX), u32(srcY)), 0);
+			const raw = channel === "alpha" ? mapSample.w : channel === "alphaInverted" ? __tsover_sub(1, mapSample.w) : channel === "luminanceInverted" ? __tsover_sub(1, dot(mapSample.xyz, vec3f(.2126, .7152, .0722))) : dot(mapSample.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 radius = __tsover_mul(mix(p.outputMin, p.outputMax, eased), .8);
 			if (radius < PASSTHROUGH_RADIUS) {
-				const sx = std.clamp(d.i32(std.round(inputCx)), 0, inputWm1);
-				const sy = std.clamp(d.i32(std.round(inputCy)), 0, inputHm1);
-				const texel = std.textureLoad(layout.$.input, d.vec2u(d.u32(sx), d.u32(sy)), 0);
-				std.textureStore(layout.$.output, d.vec2u(cx, cy), texel);
+				const sx = clamp(i32(round(inputCx)), 0, inputWm1);
+				const sy = clamp(i32(round(inputCy)), 0, inputHm1);
+				const texel = textureLoad(layout.$.input, vec2u(u32(sx), u32(sy)), 0);
+				textureStore(layout.$.output, vec2u(cx, cy), texel);
 			} else {
 				const gain = p.highlightGain;
 				const threshold = p.highlightThreshold;
 				const fringe = p.chromaticFringe;
 				const rotC = p.rotCos;
 				const rotS = p.rotSin;
-				let accum = d.vec3f(0, 0, 0);
-				let alphaAccum = d.f32(0);
-				let wSum = d.f32(0);
+				let accum = vec3f(0, 0, 0);
+				let alphaAccum = f32(0);
+				let wSum = f32(0);
 				for (let i = 0; i < TAPS; i++) {
 					const tap = layout.$.taps[i];
 					const ox = __tsover_sub(__tsover_mul(tap.x, rotC), __tsover_mul(tap.y, rotS));
 					const oy = __tsover_add(__tsover_mul(tap.x, rotS), __tsover_mul(tap.y, rotC));
-					const off = d.vec2f(__tsover_mul(ox, radius), __tsover_mul(oy, radius));
-					const sx = std.clamp(d.i32(std.round(__tsover_add(inputCx, off.x))), 0, inputWm1);
-					const sy = std.clamp(d.i32(std.round(__tsover_add(inputCy, off.y))), 0, inputHm1);
-					const base = std.textureLoad(layout.$.input, d.vec2u(d.u32(sx), d.u32(sy)), 0);
+					const off = vec2f(__tsover_mul(ox, radius), __tsover_mul(oy, radius));
+					const sx = clamp(i32(round(__tsover_add(inputCx, off.x))), 0, inputWm1);
+					const sy = clamp(i32(round(__tsover_add(inputCy, off.y))), 0, inputHm1);
+					const base = textureLoad(layout.$.input, vec2u(u32(sx), u32(sy)), 0);
 					let colR = base.x;
 					let colB = base.z;
 					if (fringe > .001) {
 						const offR = off.mul(__tsover_add(1, __tsover_mul(fringe, .5)));
-						const rx = std.clamp(d.i32(std.round(__tsover_add(inputCx, offR.x))), 0, inputWm1);
-						const ry = std.clamp(d.i32(std.round(__tsover_add(inputCy, offR.y))), 0, inputHm1);
-						colR = std.textureLoad(layout.$.input, d.vec2u(d.u32(rx), d.u32(ry)), 0).x;
+						const rx = clamp(i32(round(__tsover_add(inputCx, offR.x))), 0, inputWm1);
+						const ry = clamp(i32(round(__tsover_add(inputCy, offR.y))), 0, inputHm1);
+						colR = textureLoad(layout.$.input, vec2u(u32(rx), u32(ry)), 0).x;
 						const offB = off.mul(__tsover_sub(1, __tsover_mul(fringe, .5)));
-						const bx = std.clamp(d.i32(std.round(__tsover_add(inputCx, offB.x))), 0, inputWm1);
-						const by = std.clamp(d.i32(std.round(__tsover_add(inputCy, offB.y))), 0, inputHm1);
-						colB = std.textureLoad(layout.$.input, d.vec2u(d.u32(bx), d.u32(by)), 0).z;
+						const bx = clamp(i32(round(__tsover_add(inputCx, offB.x))), 0, inputWm1);
+						const by = clamp(i32(round(__tsover_add(inputCy, offB.y))), 0, inputHm1);
+						colB = textureLoad(layout.$.input, vec2u(u32(bx), u32(by)), 0).z;
 					}
-					const col = d.vec3f(colR, base.y, colB);
-					const lum = std.dot(base.xyz, d.vec3f(.2126, .7152, .0722));
-					const hi = std.smoothstep(threshold, __tsover_add(threshold, HIGHLIGHT_KNEE), lum);
+					const col = vec3f(colR, base.y, colB);
+					const lum = dot(base.xyz, vec3f(.2126, .7152, .0722));
+					const hi = smoothstep(threshold, __tsover_add(threshold, HIGHLIGHT_KNEE), lum);
 					const w = __tsover_mul(__tsover_add(1, __tsover_mul(__tsover_mul(gain, hi), hi)), tap.z);
 					accum = accum.add(col.mul(w));
 					alphaAccum = __tsover_add(alphaAccum, __tsover_mul(base.w, w));
 					wSum = __tsover_add(wSum, w);
 				}
-				const invW = __tsover_div(1, std.max(wSum, 1e-4));
-				std.textureStore(layout.$.output, d.vec2u(cx, cy), d.vec4f(accum.mul(invW), __tsover_mul(alphaAccum, invW)));
+				const invW = __tsover_div(1, max(wSum, 1e-4));
+				textureStore(layout.$.output, vec2u(cx, cy), vec4f(accum.mul(invW), __tsover_mul(alphaAccum, invW)));
 			}
 		}), {
 			v: 1,
@@ -3197,10 +3197,10 @@ function buildBokehMapGraph(computeWidth, computeHeight, tapCount, channel) {
 			},
 			externals: () => ({
 				layout,
-				d,
+				d: data_exports,
 				computeWidth,
 				computeHeight,
-				std,
+				std: std_exports,
 				channel,
 				RADIUS_SCALE: .8,
 				PASSTHROUGH_RADIUS,
@@ -3373,7 +3373,7 @@ const componentDefinition = {
 				const next = `${shape}|${count}`;
 				if (next === key) return;
 				key = next;
-				tapsUniform$1.write(generateBokehTaps(shape, count, 100).map((tap) => d.vec4f(tap.x, tap.y, tap.rim, 0)));
+				tapsUniform$1.write(generateBokehTaps(shape, count, 100).map((tap) => vec4f(tap.x, tap.y, tap.rim, 0)));
 			};
 		};
 		const mapInfo = getMapInfo("radius");

package/dist/core/{BrickPattern-EAD5HD4e.js → BrickPattern-tASwilX0.js}

@@ -1,21 +1,21 @@
-import { Ht as call, J as std, Jt as vec4, Tn as d, gn as mixColorsVariants, hn as mixColorsLinear, n as tgpu } from "./coords-BkIjixe_.js";
-import { a as transformColor, o as transformColorSpace, r as transformAngle, t as colorSpaceOptions } from "./transformations-t0d2-uSX.js";
-import { t as animatedTime } from "./porters-BmU6G9TR.js";
+import { At as mix, Et as fract, H as mixColorsLinear, Ot as max, Rt as sin, St as dot, Tt as floor, U as mixColorsVariants, Ut as data_exports, bt as cos, et as src_default, lt as fwidth, nt as std_exports, p as call, sn as f32, tn as vec2f, y as vec4, zt as smoothstep } from "./edges-BZUKQxSE.js";
+import { t as animatedTime } from "./porters-DogLzpKT.js";
+import { a as transformColor, o as transformColorSpace, r as transformAngle, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
 var DEG_TO_RAD = .0174533;
-const brickField = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, cellsX, cellsY, mortar, softness, variation, rotation, offset, speedVariance, seed, animTime) => {
+const brickField = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, cellsX, cellsY, mortar, softness, variation, rotation, offset, speedVariance, seed, animTime) => {
 	"use gpu";
 	const aspect = __tsover_div(viewport.x, viewport.y);
 	const au = __tsover_mul(uv.x, aspect);
@@ -23,36 +23,32 @@ const brickField = tgpu.fn([
 	const cu = __tsover_sub(au, __tsover_mul(aspect, .5));
 	const cv = __tsover_sub(av, .5);
 	const rotRad = __tsover_mul(rotation, DEG_TO_RAD);
-	const cosR = std.cos(rotRad);
-	const sinR = std.sin(rotRad);
+	const cosR = cos(rotRad);
+	const sinR = sin(rotRad);
 	const ru = __tsover_add(__tsover_mul(cu, cosR), __tsover_mul(cv, sinR));
 	const rv = __tsover_add(-__tsover_mul(cu, sinR), __tsover_mul(cv, cosR));
 	const u = __tsover_add(__tsover_div(ru, aspect), .5);
 	const v = __tsover_add(rv, .5);
 	const mortarU = __tsover_mul(mortar, .3);
 	const mortarV = __tsover_div(__tsover_mul(__tsover_mul(mortarU, aspect), cellsY), cellsX);
-	const row = std.floor(__tsover_mul(v, cellsY));
-	const rowMod2 = __tsover_sub(row, __tsover_mul(2, std.floor(__tsover_div(row, 2))));
+	const row = floor(__tsover_mul(v, cellsY));
+	const rowMod2 = __tsover_sub(row, __tsover_mul(2, floor(__tsover_div(row, 2))));
 	const rowOffset = __tsover_mul(rowMod2, .5);
-	const rowDir = __tsover_sub(__tsover_mul(rowMod2, 2), 1);
-	const rowHash = __tsover_mul(__tsover_sub(std.fract(__tsover_mul(std.sin(__tsover_add(row, __tsover_mul(seed, .137))), 43758.5453)), .5), 2);
-	const rowSpeedMult = std.mix(rowDir, rowHash, speedVariance);
+	const rowSpeedMult = mix(__tsover_sub(__tsover_mul(rowMod2, 2), 1), __tsover_mul(__tsover_sub(fract(__tsover_mul(sin(__tsover_add(row, __tsover_mul(seed, .137))), 43758.5453)), .5), 2), speedVariance);
 	const brickArg = __tsover_add(__tsover_add(__tsover_add(__tsover_mul(u, cellsX), rowOffset), __tsover_mul(animTime, rowSpeedMult)), offset);
 	const vScaled = __tsover_mul(v, cellsY);
-	const cellU = std.fract(brickArg);
-	const cellV = std.fract(vScaled);
+	const cellU = fract(brickArg);
+	const cellV = fract(vScaled);
 	const soft = __tsover_mul(softness, .5);
-	const aaU = __tsover_add(std.fwidth(brickArg), soft);
-	const aaV = __tsover_add(std.fwidth(vScaled), soft);
-	const brickU = __tsover_mul(std.smoothstep(__tsover_sub(mortarU, aaU), __tsover_add(mortarU, aaU), cellU), std.smoothstep(__tsover_sub(mortarU, aaU), __tsover_add(mortarU, aaU), __tsover_sub(1, cellU)));
-	const brickV = __tsover_mul(std.smoothstep(__tsover_sub(mortarV, aaV), __tsover_add(mortarV, aaV), cellV), std.smoothstep(__tsover_sub(mortarV, aaV), __tsover_add(mortarV, aaV), __tsover_sub(1, cellV)));
+	const aaU = __tsover_add(fwidth(brickArg), soft);
+	const aaV = __tsover_add(fwidth(vScaled), soft);
+	const brickU = __tsover_mul(smoothstep(__tsover_sub(mortarU, aaU), __tsover_add(mortarU, aaU), cellU), smoothstep(__tsover_sub(mortarU, aaU), __tsover_add(mortarU, aaU), __tsover_sub(1, cellU)));
+	const brickV = __tsover_mul(smoothstep(__tsover_sub(mortarV, aaV), __tsover_add(mortarV, aaV), cellV), smoothstep(__tsover_sub(mortarV, aaV), __tsover_add(mortarV, aaV), __tsover_sub(1, cellV)));
 	const brickMask = __tsover_mul(brickU, brickV);
-	const brickId = d.vec2f(std.floor(brickArg), row);
-	const q0 = std.fract(brickId.mul(d.vec2f(123.34, 345.45)));
-	const q1 = q0.add(std.dot(q0, q0.add(34.345)));
-	const rand = std.fract(__tsover_mul(q1.x, q1.y));
-	const variedFactor = std.max(__tsover_add(1, __tsover_mul(__tsover_mul(__tsover_sub(rand, .5), 2), variation)), 0);
-	return d.vec2f(brickMask, variedFactor);
+	const q0 = fract(vec2f(floor(brickArg), row).mul(vec2f(123.34, 345.45)));
+	const q1 = q0.add(dot(q0, q0.add(34.345)));
+	const rand = fract(__tsover_mul(q1.x, q1.y));
+	return vec2f(brickMask, max(__tsover_add(1, __tsover_mul(__tsover_mul(__tsover_sub(rand, .5), 2), variation)), 0));
 }), {
 	v: 1,
 	name: void 0,
@@ -839,8 +835,8 @@ const brickField = tgpu.fn([
 	},
 	externals: () => ({
 		DEG_TO_RAD,
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {

package/dist/core/{BrightnessContrast-mbv32DkA.js → BrightnessContrast-ZCKqJW7i.js}

@@ -1,14 +1,13 @@
-import { Bt as ZERO, Ht as call, Tn as d, n as tgpu } from "./coords-BkIjixe_.js";
-const brightnessContrastColor = tgpu.fn([
-	d.vec4f,
-	d.f32,
-	d.f32
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, brightness, contrastRaw) => {
+import { Ut as data_exports, d as ZERO, et as src_default, in as vec3f, on as vec4f, p as call, sn as f32 } from "./edges-BZUKQxSE.js";
+const brightnessContrastColor = src_default.fn([
+	vec4f,
+	f32,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, brightness, contrastRaw) => {
 	"use gpu";
 	const contrast = __tsover_add(contrastRaw, 1);
-	const half = d.vec3f(.5, .5, .5);
-	const result = color.xyz.sub(half).mul(contrast).add(half).add(d.vec3f(brightness, brightness, brightness));
-	return d.vec4f(result, color.w);
+	const half = vec3f(.5, .5, .5);
+	return vec4f(color.xyz.sub(half).mul(contrast).add(half).add(vec3f(brightness, brightness, brightness)), color.w);
 }), {
 	v: 1,
 	name: void 0,
@@ -129,7 +128,7 @@ const brightnessContrastColor = tgpu.fn([
 		]],
 		"externalNames": ["d"]
 	},
-	externals: () => ({ d })
+	externals: () => ({ d: data_exports })
 }) && $.f)({}));
 const componentDefinition = {
 	name: "BrightnessContrast",