shaders 3.0.448 → 3.0.450

package/dist/core/{Glitch-CUOJt5VX.js → Glitch-D1Dx8__X.js}

@@ -1,7 +1,7 @@
-import { Bt as ZERO, Ht as call, J as std, Tn as d, cn as unpremultiplyAlpha, n as tgpu } from "./coords-BkIjixe_.js";
-var hash11 = tgpu.fn([d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p) => {
+import { At as mix, Et as fract, N as unpremultiplyAlpha, Qt as struct, Rt as sin, Tt as floor, Ut as data_exports, Vt as step, d as ZERO, et as src_default, ht as abs, in as vec3f, nt as std_exports, on as vec4f, p as call, sn as f32, tn as vec2f, yt as clamp } from "./edges-BZUKQxSE.js";
+var hash11 = src_default.fn([f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p) => {
 	"use gpu";
-	return std.fract(__tsover_mul(std.sin(__tsover_mul(p, 78.233)), 43758.5453));
+	return fract(__tsover_mul(sin(__tsover_mul(p, 78.233)), 43758.5453));
 }), {
 	v: 1,
 	name: void 0,
@@ -39,88 +39,84 @@ var hash11 = tgpu.fn([d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEG
 		]]]],
 		"externalNames": ["std"]
 	},
-	externals: () => ({ std })
+	externals: () => ({ std: std_exports })
 }) && $.f)({}));
-const GlitchGeom = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(d.struct({
-	redUV: d.vec2f,
-	mirroredUV: d.vec2f,
-	blueUV: d.vec2f,
-	fillColor: d.vec3f,
-	colorBarStrength: d.f32,
-	scanlineEffect: d.f32
+const GlitchGeom = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+	redUV: vec2f,
+	mirroredUV: vec2f,
+	blueUV: vec2f,
+	fillColor: vec3f,
+	colorBarStrength: f32,
+	scanlineEffect: f32
 }), "GlitchGeom");
-const glitchGeom = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
+const glitchGeom = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
 ], GlitchGeom)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, time, intensity, speed, rgbShift, blockDensity, colorBarMix, mirrorChance, scanlines) => {
 	"use gpu";
 	const t = __tsover_mul(time, speed);
-	const slowFrame = std.floor(__tsover_mul(t, 2.5));
+	const slowFrame = floor(__tsover_mul(t, 2.5));
 	const slowHash = hash11(slowFrame);
 	const slowPulse = __tsover_mul(__tsover_mul(slowHash, slowHash), slowHash);
-	const fastFrame = std.floor(__tsover_mul(t, 10));
+	const fastFrame = floor(__tsover_mul(t, 10));
 	const fastHash = hash11(__tsover_add(fastFrame, 73));
 	const fastPulse = __tsover_mul(fastHash, fastHash);
 	const threshold = __tsover_sub(1, intensity);
-	const majorBurst = std.step(threshold, slowPulse);
-	const minorFlicker = std.step(__tsover_add(threshold, .15), fastPulse);
-	const glitchStrength = __tsover_mul(std.clamp(__tsover_add(__tsover_mul(majorBurst, .8), __tsover_mul(minorFlicker, .4)), 0, 1), intensity);
-	const bandY1 = std.floor(__tsover_mul(uv.y, blockDensity));
+	const majorBurst = step(threshold, slowPulse);
+	const minorFlicker = step(__tsover_add(threshold, .15), fastPulse);
+	const glitchStrength = __tsover_mul(clamp(__tsover_add(__tsover_mul(majorBurst, .8), __tsover_mul(minorFlicker, .4)), 0, 1), intensity);
+	const bandY1 = floor(__tsover_mul(uv.y, blockDensity));
 	const bandSeed1 = __tsover_add(__tsover_mul(bandY1, .37), __tsover_mul(slowFrame, 7.13));
 	const bandHash1 = hash11(bandSeed1);
-	const bandActive1 = std.step(__tsover_sub(1, __tsover_mul(glitchStrength, .5)), bandHash1);
+	const bandActive1 = step(__tsover_sub(1, __tsover_mul(glitchStrength, .5)), bandHash1);
 	const displace1 = __tsover_mul(__tsover_mul(__tsover_sub(hash11(__tsover_add(bandSeed1, 42)), .5), .25), bandActive1);
-	const bandY2 = std.floor(__tsover_mul(uv.y, __tsover_mul(blockDensity, 2)));
+	const bandY2 = floor(__tsover_mul(uv.y, __tsover_mul(blockDensity, 2)));
 	const bandSeed2 = __tsover_add(__tsover_mul(bandY2, .53), __tsover_mul(fastFrame, 3.37));
 	const bandHash2 = hash11(bandSeed2);
-	const bandActive2 = std.step(__tsover_sub(1, __tsover_mul(glitchStrength, .7)), bandHash2);
+	const bandActive2 = step(__tsover_sub(1, __tsover_mul(glitchStrength, .7)), bandHash2);
 	const displace2 = __tsover_mul(__tsover_mul(__tsover_sub(hash11(__tsover_add(bandSeed2, 99)), .5), .12), bandActive2);
-	const bandY3 = std.floor(__tsover_mul(uv.y, __tsover_mul(blockDensity, 4)));
+	const bandY3 = floor(__tsover_mul(uv.y, __tsover_mul(blockDensity, 4)));
 	const bandSeed3 = __tsover_add(__tsover_mul(bandY3, .71), __tsover_mul(fastFrame, 11.71));
 	const bandHash3 = hash11(bandSeed3);
-	const bandActive3 = std.step(__tsover_sub(1, __tsover_mul(glitchStrength, .9)), bandHash3);
+	const bandActive3 = step(__tsover_sub(1, __tsover_mul(glitchStrength, .9)), bandHash3);
 	const displace3 = __tsover_mul(__tsover_mul(__tsover_sub(hash11(__tsover_add(bandSeed3, 173)), .5), .05), bandActive3);
-	const colX = std.floor(__tsover_mul(uv.x, 4));
+	const colX = floor(__tsover_mul(uv.x, 4));
 	const blockSeed = __tsover_add(__tsover_add(__tsover_mul(colX, .41), __tsover_mul(bandY1, .67)), __tsover_mul(slowFrame, 2.31));
 	const blockHash = hash11(blockSeed);
-	const blockActive = std.step(__tsover_sub(1, __tsover_mul(glitchStrength, .35)), blockHash);
+	const blockActive = step(__tsover_sub(1, __tsover_mul(glitchStrength, .35)), blockHash);
 	const blockDisplace = __tsover_mul(__tsover_mul(__tsover_sub(hash11(__tsover_add(blockSeed, 77)), .5), .18), blockActive);
 	const totalDisplaceX = __tsover_add(__tsover_add(__tsover_add(displace1, displace2), displace3), blockDisplace);
 	const vertJitter = __tsover_mul(__tsover_mul(bandActive1, __tsover_sub(hash11(__tsover_add(bandSeed1, 200)), .5)), .012);
-	const displacedUV = d.vec2f(std.clamp(__tsover_add(uv.x, __tsover_mul(totalDisplaceX, glitchStrength)), 0, 1), std.clamp(__tsover_add(uv.y, __tsover_mul(vertJitter, glitchStrength)), 0, 1));
+	const displacedUV = vec2f(clamp(__tsover_add(uv.x, __tsover_mul(totalDisplaceX, glitchStrength)), 0, 1), clamp(__tsover_add(uv.y, __tsover_mul(vertJitter, glitchStrength)), 0, 1));
 	const mirrorSeed = __tsover_add(__tsover_add(__tsover_mul(colX, .83), __tsover_mul(bandY1, 1.17)), __tsover_mul(slowFrame, 4.57));
 	const hMirrorHash = hash11(mirrorSeed);
 	const vMirrorHash = hash11(__tsover_add(mirrorSeed, 500));
-	const hMirrorActive = __tsover_mul(std.step(__tsover_sub(1, __tsover_mul(mirrorChance, glitchStrength)), hMirrorHash), bandActive1);
-	const vMirrorActive = __tsover_mul(std.step(__tsover_sub(1, __tsover_mul(__tsover_mul(mirrorChance, glitchStrength), .4)), vMirrorHash), bandActive1);
-	const mirroredUV = d.vec2f(std.mix(displacedUV.x, __tsover_sub(1, displacedUV.x), hMirrorActive), std.mix(displacedUV.y, __tsover_sub(1, displacedUV.y), vMirrorActive));
-	const rgbOffset = __tsover_mul(__tsover_mul(rgbShift, .003), __tsover_add(glitchStrength, __tsover_mul(std.abs(totalDisplaceX), 2)));
-	const redUV = d.vec2f(std.clamp(__tsover_add(mirroredUV.x, rgbOffset), 0, 1), mirroredUV.y);
-	const blueUV = d.vec2f(std.clamp(__tsover_sub(mirroredUV.x, rgbOffset), 0, 1), mirroredUV.y);
+	const hMirrorActive = __tsover_mul(step(__tsover_sub(1, __tsover_mul(mirrorChance, glitchStrength)), hMirrorHash), bandActive1);
+	const vMirrorActive = __tsover_mul(step(__tsover_sub(1, __tsover_mul(__tsover_mul(mirrorChance, glitchStrength), .4)), vMirrorHash), bandActive1);
+	const mirroredUV = vec2f(mix(displacedUV.x, __tsover_sub(1, displacedUV.x), hMirrorActive), mix(displacedUV.y, __tsover_sub(1, displacedUV.y), vMirrorActive));
+	const rgbOffset = __tsover_mul(__tsover_mul(rgbShift, .003), __tsover_add(glitchStrength, __tsover_mul(abs(totalDisplaceX), 2)));
+	const redUV = vec2f(clamp(__tsover_add(mirroredUV.x, rgbOffset), 0, 1), mirroredUV.y);
+	const blueUV = vec2f(clamp(__tsover_sub(mirroredUV.x, rgbOffset), 0, 1), mirroredUV.y);
 	const fillStyleHash = hash11(__tsover_add(blockSeed, 555));
 	const barOffset = hash11(__tsover_add(__tsover_add(bandY1, __tsover_mul(slowFrame, 3.33)), 333));
-	const barX = std.fract(__tsover_add(__tsover_mul(uv.x, 3), __tsover_mul(barOffset, 7)));
-	const barIndex = std.floor(__tsover_mul(barX, 7));
-	const barR = __tsover_add(__tsover_sub(1, std.step(2, barIndex)), __tsover_mul(std.step(4, barIndex), __tsover_sub(1, std.step(6, barIndex))));
-	const barG = __tsover_sub(1, std.step(4, barIndex));
-	const barB = __tsover_sub(1, std.step(.5, std.fract(__tsover_mul(barIndex, .5))));
-	const smpteColor = d.vec3f(barR, barG, barB);
-	const solidHue = std.fract(__tsover_add(__tsover_mul(hash11(__tsover_add(bandY1, 13)), .8), __tsover_mul(slowFrame, .07)));
+	const barX = fract(__tsover_add(__tsover_mul(uv.x, 3), __tsover_mul(barOffset, 7)));
+	const barIndex = floor(__tsover_mul(barX, 7));
+	const smpteColor = vec3f(__tsover_add(__tsover_sub(1, step(2, barIndex)), __tsover_mul(step(4, barIndex), __tsover_sub(1, step(6, barIndex)))), __tsover_sub(1, step(4, barIndex)), __tsover_sub(1, step(.5, fract(__tsover_mul(barIndex, .5)))));
+	const solidHue = fract(__tsover_add(__tsover_mul(hash11(__tsover_add(bandY1, 13)), .8), __tsover_mul(slowFrame, .07)));
 	const sh6 = __tsover_mul(solidHue, 6);
-	const solidColor = d.vec3f(std.clamp(__tsover_sub(std.abs(__tsover_sub(sh6, 3)), 1), 0, 1), std.clamp(__tsover_sub(2, std.abs(__tsover_sub(sh6, 2))), 0, 1), std.clamp(__tsover_sub(2, std.abs(__tsover_sub(sh6, 4))), 0, 1)).mul(1.3);
-	const fillColor = std.mix(solidColor, smpteColor, d.vec3f(std.step(.5, fillStyleHash)));
+	const fillColor = mix(vec3f(clamp(__tsover_sub(abs(__tsover_sub(sh6, 3)), 1), 0, 1), clamp(__tsover_sub(2, abs(__tsover_sub(sh6, 2))), 0, 1), clamp(__tsover_sub(2, abs(__tsover_sub(sh6, 4))), 0, 1)).mul(1.3), smpteColor, vec3f(step(.5, fillStyleHash)));
 	const colorBarStrength = __tsover_mul(__tsover_mul(__tsover_mul(bandActive1, blockActive), colorBarMix), glitchStrength);
-	const anyDistortion = std.clamp(__tsover_add(__tsover_add(bandActive1, bandActive2), bandActive3), 0, 1);
+	const anyDistortion = clamp(__tsover_add(__tsover_add(bandActive1, bandActive2), bandActive3), 0, 1);
 	const pixelY = __tsover_mul(uv.y, viewport.y);
-	const scanlineWave = __tsover_add(__tsover_mul(std.sin(__tsover_mul(pixelY, 3.14159265)), .5), .5);
+	const scanlineWave = __tsover_add(__tsover_mul(sin(__tsover_mul(pixelY, 3.14159265)), .5), .5);
 	return GlitchGeom({
 		redUV,
 		mirroredUV,
@@ -1717,22 +1713,22 @@ const glitchGeom = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		std,
+		std: std_exports,
 		hash11,
-		d,
+		d: data_exports,
 		GlitchGeom
 	})
 }) && $.f)({}));
-const glitchCombine = tgpu.fn([
-	d.f32,
-	d.f32,
-	d.f32,
+const glitchCombine = src_default.fn([
+	f32,
+	f32,
+	f32,
+	f32,
 	GlitchGeom
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((r, g, b, geom) => {
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((r, g, b, a, geom) => {
 	"use gpu";
-	const glitchedColor = d.vec3f(r, g, b);
-	const finalColor = std.mix(glitchedColor, geom.fillColor, d.vec3f(geom.colorBarStrength)).mul(geom.scanlineEffect);
-	return d.vec4f(finalColor.x, finalColor.y, finalColor.z, 1);
+	const finalColor = mix(vec3f(r, g, b), geom.fillColor.mul(a), vec3f(geom.colorBarStrength)).mul(geom.scanlineEffect);
+	return vec4f(finalColor.x, finalColor.y, finalColor.z, a);
 }), {
 	v: 1,
 	name: void 0,
@@ -1750,6 +1746,10 @@ const glitchCombine = tgpu.fn([
 				"type": "i",
 				"name": "b"
 			},
+			{
+				"type": "i",
+				"name": "a"
+			},
 			{
 				"type": "i",
 				"name": "geom"
@@ -1786,9 +1786,17 @@ const glitchCombine = tgpu.fn([
 					[
 						"glitchedColor",
 						[
-							7,
-							"geom",
-							"fillColor"
+							6,
+							[
+								7,
+								[
+									7,
+									"geom",
+									"fillColor"
+								],
+								"mul"
+							],
+							["a"]
 						],
 						[
 							6,
@@ -1846,15 +1854,15 @@ const glitchCombine = tgpu.fn([
 						"finalColor",
 						"z"
 					],
-					[5, "1"]
+					"a"
 				]
 			]]
 		]],
 		"externalNames": ["d", "std"]
 	},
 	externals: () => ({
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {
@@ -1965,10 +1973,14 @@ const componentDefinition = {
 			uniforms.mirrorAmount,
 			uniforms.scanlineIntensity
 		]);
+		const rSample = texture.sample(geom.member("redUV")).member("r");
+		const gVec = texture.sample(geom.member("mirroredUV"));
+		const bSample = texture.sample(geom.member("blueUV")).member("b");
 		return call(unpremultiplyAlpha, "unpremultiplyAlpha", [call(glitchCombine, "glitchCombine", [
-			texture.sample(geom.member("redUV")).member("r"),
-			texture.sample(geom.member("mirroredUV")).member("g"),
-			texture.sample(geom.member("blueUV")).member("b"),
+			rSample,
+			gVec.member("g"),
+			bSample,
+			gVec.member("a"),
 			geom
 		])]);
 	}

package/dist/core/{Glow-D5AdnLvU.js → Glow-Bd9_o_Kv.js}

@@ -1,15 +1,16 @@
-import { Bt as ZERO, G as DEFAULT_COMPUTE_WIDTH, Ht as call, J as std, Tn as d, U as BLUR_MAP_FORMAT, W as DEFAULT_COMPUTE_HEIGHT, X as createGuardedCompute, cn as unpremultiplyAlpha, n as tgpu, q as createVariableGaussianBlurCompute } from "./coords-BkIjixe_.js";
+import { At as mix, 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, yt as clamp } from "./edges-BZUKQxSE.js";
+import { n as createGuardedCompute } from "./compute-BoeIXi0l.js";
+import { a as createVariableGaussianBlurCompute, n as DEFAULT_COMPUTE_HEIGHT, r as DEFAULT_COMPUTE_WIDTH, t as BLUR_MAP_FORMAT } from "./blur-DKmdsW6d.js";
 var BRIGHT_FORMAT = "rgba16float";
-const glowCompose = tgpu.fn([
-	d.vec4f,
-	d.vec4f,
-	d.f32
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((original, bloom, intensity) => {
+const glowCompose = src_default.fn([
+	vec4f,
+	vec4f,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((original, bloom, intensity) => {
 	"use gpu";
 	const finalColor = original.xyz.add(bloom.xyz.mul(intensity));
-	const glowAlpha = std.clamp(__tsover_mul(bloom.w, intensity), 0, 1);
-	const finalAlpha = __tsover_add(original.w, __tsover_mul(glowAlpha, __tsover_sub(1, original.w)));
-	return d.vec4f(finalColor, finalAlpha);
+	const glowAlpha = clamp(__tsover_mul(bloom.w, intensity), 0, 1);
+	return vec4f(finalColor, __tsover_add(original.w, __tsover_mul(glowAlpha, __tsover_sub(1, original.w))));
 }), {
 	v: 1,
 	name: void 0,
@@ -125,64 +126,64 @@ const glowCompose = tgpu.fn([
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({})).$name("glowCompose");
 function glowPrepassParams() {
-	return d.struct({
-		threshold: d.f32,
-		size: d.f32,
-		inputWidth: d.f32,
-		inputHeight: d.f32
+	return struct({
+		threshold: f32,
+		size: f32,
+		inputWidth: f32,
+		inputHeight: f32
 	});
 }
 function glowPrepassMapParams() {
-	return d.struct({
-		threshold: 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({
+		threshold: f32,
+		inputWidth: f32,
+		inputHeight: f32,
+		inputMin: f32,
+		inputMax: f32,
+		outputMin: f32,
+		outputMax: f32,
+		curve: f32
 	});
 }
 function buildGlowPrepassGraph(computeWidth, computeHeight) {
 	const Params = glowPrepassParams();
-	const layout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
-		childTexture: { texture: d.texture2d(d.f32) },
-		brightMap: { storageTexture: d.textureStorage2d(BRIGHT_FORMAT, "write-only") },
-		blurMap: { storageTexture: d.textureStorage2d(BLUR_MAP_FORMAT, "write-only") },
+	const layout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
+		childTexture: { texture: texture2d(f32) },
+		brightMap: { storageTexture: textureStorage2d(BRIGHT_FORMAT, "write-only") },
+		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 iw = p.inputWidth;
 			const ih = p.inputHeight;
-			const inputWm1 = d.i32(__tsover_sub(iw, 1));
-			const inputHm1 = d.i32(__tsover_sub(ih, 1));
-			let sample = d.vec4f(0, 0, 0, 0);
+			const inputWm1 = i32(__tsover_sub(iw, 1));
+			const inputHm1 = i32(__tsover_sub(ih, 1));
+			let sample = vec4f(0, 0, 0, 0);
 			for (let ty = 0; ty < 4; ty++) for (let tx = 0; tx < 4; tx++) {
-				const su = __tsover_div(__tsover_add(d.f32(cx), __tsover_div(__tsover_add(d.f32(tx), .5), 4)), computeWidth);
-				const sv = __tsover_div(__tsover_add(d.f32(cy), __tsover_div(__tsover_add(d.f32(ty), .5), 4)), computeHeight);
-				const sx = std.clamp(d.i32(__tsover_mul(su, iw)), 0, inputWm1);
-				const sy = std.clamp(d.i32(__tsover_mul(sv, ih)), 0, inputHm1);
-				sample = sample.add(std.textureLoad(layout.$.childTexture, d.vec2u(d.u32(sx), d.u32(sy)), 0));
+				const su = __tsover_div(__tsover_add(f32(cx), __tsover_div(__tsover_add(f32(tx), .5), 4)), computeWidth);
+				const sv = __tsover_div(__tsover_add(f32(cy), __tsover_div(__tsover_add(f32(ty), .5), 4)), computeHeight);
+				const sx = clamp(i32(__tsover_mul(su, iw)), 0, inputWm1);
+				const sy = clamp(i32(__tsover_mul(sv, ih)), 0, inputHm1);
+				sample = sample.add(textureLoad(layout.$.childTexture, vec2u(u32(sx), u32(sy)), 0));
 			}
 			sample = sample.mul(.0625);
 			const threshold = p.threshold;
 			const knee = __tsover_add(__tsover_mul(threshold, .5), 1e-4);
-			const lum = std.dot(sample.xyz, d.vec3f(.2126, .7152, .0722));
-			const soft = std.clamp(__tsover_add(__tsover_sub(lum, threshold), knee), 0, __tsover_mul(knee, 2));
+			const lum = dot(sample.xyz, vec3f(.2126, .7152, .0722));
+			const soft = clamp(__tsover_add(__tsover_sub(lum, threshold), knee), 0, __tsover_mul(knee, 2));
 			const softCurve = __tsover_div(__tsover_mul(soft, soft), __tsover_mul(knee, 4));
-			const mask = __tsover_div(std.max(softCurve, __tsover_sub(lum, threshold)), std.max(lum, 1e-4));
-			std.textureStore(layout.$.brightMap, d.vec2u(cx, cy), d.vec4f(sample.xyz.mul(mask), __tsover_mul(sample.w, mask)));
-			std.textureStore(layout.$.blurMap, d.vec2u(cx, cy), d.vec4f(p.size, 0, 0, 1));
+			const mask = __tsover_div(max(softCurve, __tsover_sub(lum, threshold)), max(lum, 1e-4));
+			textureStore(layout.$.brightMap, vec2u(cx, cy), vec4f(sample.xyz.mul(mask), __tsover_mul(sample.w, mask)));
+			textureStore(layout.$.blurMap, vec2u(cx, cy), vec4f(p.size, 0, 0, 1));
 		}), {
 			v: 1,
 			name: void 0,
@@ -785,10 +786,10 @@ function buildGlowPrepassGraph(computeWidth, computeHeight) {
 			},
 			externals: () => ({
 				layout,
-				d,
+				d: data_exports,
 				computeWidth,
 				computeHeight,
-				std
+				std: std_exports
 			})
 		}) && $.f)({})).$name("glowExtractAndFill"),
 		Params
@@ -796,50 +797,48 @@ function buildGlowPrepassGraph(computeWidth, computeHeight) {
 }
 function buildGlowPrepassMapGraph(computeWidth, computeHeight, channel) {
 	const Params = glowPrepassMapParams();
-	const layout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
-		childTexture: { texture: d.texture2d(d.f32) },
-		source: { texture: d.texture2d(d.f32) },
-		brightMap: { storageTexture: d.textureStorage2d(BRIGHT_FORMAT, "write-only") },
-		blurMap: { storageTexture: d.textureStorage2d(BLUR_MAP_FORMAT, "write-only") },
+	const layout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
+		childTexture: { texture: texture2d(f32) },
+		source: { texture: texture2d(f32) },
+		brightMap: { storageTexture: textureStorage2d(BRIGHT_FORMAT, "write-only") },
+		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 iw = p.inputWidth;
 			const ih = p.inputHeight;
-			const inputWm1 = d.i32(__tsover_sub(iw, 1));
-			const inputHm1 = d.i32(__tsover_sub(ih, 1));
-			let sample = d.vec4f(0, 0, 0, 0);
+			const inputWm1 = i32(__tsover_sub(iw, 1));
+			const inputHm1 = i32(__tsover_sub(ih, 1));
+			let sample = vec4f(0, 0, 0, 0);
 			for (let ty = 0; ty < 4; ty++) for (let tx = 0; tx < 4; tx++) {
-				const su = __tsover_div(__tsover_add(d.f32(cx), __tsover_div(__tsover_add(d.f32(tx), .5), 4)), computeWidth);
-				const sv = __tsover_div(__tsover_add(d.f32(cy), __tsover_div(__tsover_add(d.f32(ty), .5), 4)), computeHeight);
-				const sx = std.clamp(d.i32(__tsover_mul(su, iw)), 0, inputWm1);
-				const sy = std.clamp(d.i32(__tsover_mul(sv, ih)), 0, inputHm1);
-				sample = sample.add(std.textureLoad(layout.$.childTexture, d.vec2u(d.u32(sx), d.u32(sy)), 0));
+				const su = __tsover_div(__tsover_add(f32(cx), __tsover_div(__tsover_add(f32(tx), .5), 4)), computeWidth);
+				const sv = __tsover_div(__tsover_add(f32(cy), __tsover_div(__tsover_add(f32(ty), .5), 4)), computeHeight);
+				const sx = clamp(i32(__tsover_mul(su, iw)), 0, inputWm1);
+				const sy = clamp(i32(__tsover_mul(sv, ih)), 0, inputHm1);
+				sample = sample.add(textureLoad(layout.$.childTexture, vec2u(u32(sx), u32(sy)), 0));
 			}
 			sample = sample.mul(.0625);
 			const threshold = p.threshold;
 			const knee = __tsover_add(__tsover_mul(threshold, .5), 1e-4);
-			const lum = std.dot(sample.xyz, d.vec3f(.2126, .7152, .0722));
-			const soft = std.clamp(__tsover_add(__tsover_sub(lum, threshold), knee), 0, __tsover_mul(knee, 2));
+			const lum = dot(sample.xyz, vec3f(.2126, .7152, .0722));
+			const soft = clamp(__tsover_add(__tsover_sub(lum, threshold), knee), 0, __tsover_mul(knee, 2));
 			const softCurve = __tsover_div(__tsover_mul(soft, soft), __tsover_mul(knee, 4));
-			const mask = __tsover_div(std.max(softCurve, __tsover_sub(lum, threshold)), std.max(lum, 1e-4));
-			std.textureStore(layout.$.brightMap, d.vec2u(cx, cy), d.vec4f(sample.xyz.mul(mask), __tsover_mul(sample.w, mask)));
-			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, iw))), 0, inputWm1);
-			const srcY = std.clamp(d.i32(std.round(__tsover_mul(v, ih))), 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 = std.mix(p.outputMin, p.outputMax, eased);
-			std.textureStore(layout.$.blurMap, d.vec2u(cx, cy), d.vec4f(radius, 0, 0, 1));
+			const mask = __tsover_div(max(softCurve, __tsover_sub(lum, threshold)), max(lum, 1e-4));
+			textureStore(layout.$.brightMap, vec2u(cx, cy), vec4f(sample.xyz.mul(mask), __tsover_mul(sample.w, mask)));
+			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, iw))), 0, inputWm1);
+			const srcY = clamp(i32(round(__tsover_mul(v, ih))), 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 = mix(p.outputMin, p.outputMax, eased);
+			textureStore(layout.$.blurMap, vec2u(cx, cy), vec4f(radius, 0, 0, 1));
 		}), {
 			v: 1,
 			name: void 0,
@@ -1832,10 +1831,10 @@ function buildGlowPrepassMapGraph(computeWidth, computeHeight, channel) {
 			},
 			externals: () => ({
 				layout,
-				d,
+				d: data_exports,
 				computeWidth,
 				computeHeight,
-				std,
+				std: std_exports,
 				channel
 			})
 		}) && $.f)({})).$name("glowExtractAndFillVariable"),

package/dist/core/{Godrays-BeQCWVw7.js → Godrays-DRPRWGPm.js}

@@ -1,9 +1,9 @@
-import { Ht as call, J as std, Tn as d, n as tgpu } from "./coords-BkIjixe_.js";
-import { a as transformColor, c as transformPosition } from "./transformations-t0d2-uSX.js";
-import { t as animatedTime } from "./porters-BmU6G9TR.js";
-var godraysHash = tgpu.fn([d.vec2f], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p) => {
+import { At as mix, Dt as length, Et as fract, Mt as pow, Rt as sin, Tt as floor, Ut as data_exports, _t as atan2, et as src_default, ht as abs, nt as std_exports, on as vec4f, p as call, sn as f32, tn as vec2f, yt as clamp, zt as smoothstep } from "./edges-BZUKQxSE.js";
+import { t as animatedTime } from "./porters-DogLzpKT.js";
+import { a as transformColor, c as transformPosition } from "./transformations-CsPUHppB.js";
+var godraysHash = src_default.fn([vec2f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p) => {
 	"use gpu";
-	return std.fract(__tsover_mul(std.sin(__tsover_add(__tsover_mul(p.x, 127.1), __tsover_mul(p.y, 311.7))), 43758.5453));
+	return fract(__tsover_mul(sin(__tsover_add(__tsover_mul(p.x, 127.1), __tsover_mul(p.y, 311.7))), 43758.5453));
 }), {
 	v: 1,
 	name: void 0,
@@ -59,20 +59,18 @@ var godraysHash = tgpu.fn([d.vec2f], d.f32)(/* @__PURE__ */ (($) => (globalThis.
 		]]]],
 		"externalNames": ["std"]
 	},
-	externals: () => ({ std })
+	externals: () => ({ std: std_exports })
 }) && $.f)({}));
-var godraysValueNoise = tgpu.fn([d.vec2f], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((st) => {
+var godraysValueNoise = src_default.fn([vec2f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((st) => {
 	"use gpu";
-	const i = std.floor(st);
-	const f = std.fract(st);
+	const i = floor(st);
+	const f = fract(st);
 	const a = godraysHash(i);
-	const b = godraysHash(d.vec2f(__tsover_add(i.x, 1), i.y));
-	const c = godraysHash(d.vec2f(i.x, __tsover_add(i.y, 1)));
-	const e = godraysHash(d.vec2f(__tsover_add(i.x, 1), __tsover_add(i.y, 1)));
+	const b = godraysHash(vec2f(__tsover_add(i.x, 1), i.y));
+	const c = godraysHash(vec2f(i.x, __tsover_add(i.y, 1)));
+	const e = godraysHash(vec2f(__tsover_add(i.x, 1), __tsover_add(i.y, 1)));
 	const u = f.mul(f).mul(f.mul(-2).add(3));
-	const x1 = std.mix(a, b, u.x);
-	const x2 = std.mix(c, e, u.x);
-	return std.mix(x1, x2, u.y);
+	return mix(mix(a, b, u.x), mix(c, e, u.x), u.y);
 }), {
 	v: 1,
 	name: void 0,
@@ -320,23 +318,22 @@ var godraysValueNoise = tgpu.fn([d.vec2f], d.f32)(/* @__PURE__ */ (($) => (globa
 		]
 	},
 	externals: () => ({
-		std,
+		std: std_exports,
 		godraysHash,
-		d
+		d: data_exports
 	})
 }) && $.f)({}));
-var godraysRaysShape = tgpu.fn([
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((a, aWrapped, blend, r, freq, intensity) => {
+var godraysRaysShape = src_default.fn([
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((a, aWrapped, blend, r, freq, intensity) => {
 	"use gpu";
-	const nLeft = std.pow(godraysValueNoise(d.vec2f(__tsover_mul(a, freq), r)), intensity);
-	const nRight = std.pow(godraysValueNoise(d.vec2f(__tsover_mul(aWrapped, freq), r)), intensity);
-	return std.mix(nRight, nLeft, blend);
+	const nLeft = pow(godraysValueNoise(vec2f(__tsover_mul(a, freq), r)), intensity);
+	return mix(pow(godraysValueNoise(vec2f(__tsover_mul(aWrapped, freq), r)), intensity), nLeft, blend);
 }), {
 	v: 1,
 	name: void 0,
@@ -449,37 +446,37 @@ var godraysRaysShape = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		std,
+		std: std_exports,
 		godraysValueNoise,
-		d
+		d: data_exports
 	})
 }) && $.f)({}));
 var TAU = 6.283185307179586;
-const godraysColor = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.vec4f,
-	d.vec4f
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, animTimeRaw, center, density, intensity, spotty, rayColor, bgColor) => {
+const godraysColor = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	vec4f,
+	vec4f
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, animTimeRaw, center, density, intensity, spotty, rayColor, bgColor) => {
 	"use gpu";
 	const aspect = __tsover_div(viewport.x, viewport.y);
-	const centerPos = d.vec2f(center.x, __tsover_sub(1, center.y));
+	const centerPos = vec2f(center.x, __tsover_sub(1, center.y));
 	const delta = uv.sub(centerPos);
-	const shapeUV = d.vec2f(__tsover_mul(delta.x, aspect), delta.y);
+	const shapeUV = vec2f(__tsover_mul(delta.x, aspect), delta.y);
 	const animTime = __tsover_mul(animTimeRaw, .2);
-	const angle = std.atan2(shapeUV.y, shapeUV.x);
-	const angleWrapped = __tsover_sub(angle, __tsover_mul(TAU, std.floor(__tsover_div(angle, TAU))));
-	const blendFactor = std.smoothstep(-.15, .15, shapeUV.x);
-	const radius = std.length(shapeUV);
-	const spots = __tsover_mul(6.5, std.abs(spotty));
-	const intensityCalc = __tsover_sub(4, __tsover_mul(3, std.clamp(intensity, 0, 1)));
+	const angle = atan2(shapeUV.y, shapeUV.x);
+	const angleWrapped = __tsover_sub(angle, __tsover_mul(TAU, floor(__tsover_div(angle, TAU))));
+	const blendFactor = smoothstep(-.15, .15, shapeUV.x);
+	const radius = length(shapeUV);
+	const spots = __tsover_mul(6.5, abs(spotty));
+	const intensityCalc = __tsover_sub(4, __tsover_mul(3, clamp(intensity, 0, 1)));
 	const dens = __tsover_mul(6, density);
-	let accumRay = d.f32(0);
+	let accumRay = f32(0);
 	const r1 = __tsover_sub(__tsover_mul(radius, 1), __tsover_mul(animTime, 3));
 	const r2 = __tsover_sub(__tsover_mul(__tsover_mul(radius, .5), __tsover_add(1, spots)), __tsover_mul(animTime, 2));
 	const f1 = __tsover_mul(dens, 5);
@@ -492,14 +489,13 @@ const godraysColor = tgpu.fn([
 	let ray2 = godraysRaysShape(angle, angleWrapped, blendFactor, r3, f2, intensityCalc);
 	ray2 = __tsover_mul(ray2, godraysRaysShape(angle, angleWrapped, blendFactor, r4, __tsover_mul(f2, 3.5), intensityCalc));
 	accumRay = __tsover_add(accumRay, __tsover_mul(ray2, .7));
-	const rayEffect = std.clamp(accumRay, 0, 1);
+	const rayEffect = clamp(accumRay, 0, 1);
 	const rayA = __tsover_mul(rayEffect, rayColor.w);
 	const finalAlpha = __tsover_add(rayA, __tsover_mul(bgColor.w, __tsover_sub(1, rayA)));
-	const safeAlpha = std.clamp(finalAlpha, .001, 1);
+	const safeAlpha = clamp(finalAlpha, .001, 1);
 	const rayContribution = rayColor.xyz.mul(rayA);
 	const bgContribution = bgColor.xyz.mul(bgColor.w).mul(__tsover_sub(1, rayA));
-	const finalColor = rayContribution.add(bgContribution).div(safeAlpha);
-	return d.vec4f(finalColor, finalAlpha);
+	return vec4f(rayContribution.add(bgContribution).div(safeAlpha), finalAlpha);
 }), {
 	v: 1,
 	name: void 0,
@@ -1186,8 +1182,8 @@ const godraysColor = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		d,
-		std,
+		d: data_exports,
+		std: std_exports,
 		TAU,
 		godraysRaysShape
 	})