shaders 3.0.447 → 3.0.449

package/dist/core/{Glow-D5AdnLvU.js → Glow-C2cEWdNE.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 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 } from "./edges-BXNBKxSN.js";
+import { n as createGuardedCompute } from "./compute-BjeJ0sIA.js";
+import { a as createVariableGaussianBlurCompute, n as DEFAULT_COMPUTE_HEIGHT, r as DEFAULT_COMPUTE_WIDTH, t as BLUR_MAP_FORMAT } from "./blur-tvWOoxKt.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-DAZB2GSn.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 { $t as vec2f, At as pow, Ct as floor, It as sin, Lt as smoothstep, Ot as mix, Tt as length, Vt as data_exports, _t as clamp, an as f32, et as src_default, gt as atan2, in as vec4f, mt as abs, nt as std_exports, p as call, wt as fract } from "./edges-BXNBKxSN.js";
+import { t as animatedTime } from "./porters-DBK1Aipq.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
 	})

package/dist/core/{Goo-C0_0QYne.js → Goo-B_WAqWYW.js}

@@ -1,8 +1,9 @@
-import { F as sdf_exports, Ht as call, J as std, Jt as vec4, Kt as floatE, Tn as d, n as tgpu, y as sdf3d_exports } from "./coords-BkIjixe_.js";
-import { n as glass_exports } from "./glass-sOqjtPJD.js";
-import { a as transformColor, c as transformPosition } from "./transformations-t0d2-uSX.js";
-import { t as animatedTime } from "./porters-BmU6G9TR.js";
-import { n as shapeEffectBoundingBoxDeclaration, t as resolveShapeType } from "./shapeEffectBounds-PQqKLQXO.js";
+import { $t as vec2f, At as pow, Dt as min, Et as max, It as sin, Lt as smoothstep, Ot as mix, Rt as sqrt, Ut as arrayOf, Vt as data_exports, _ as floatE, _t as clamp, 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, vt as cos, xt as exp, y as vec4 } from "./edges-BXNBKxSN.js";
+import { t as animatedTime } from "./porters-DBK1Aipq.js";
+import { h as sdf_exports } from "./sdf-R0EN3EvS.js";
+import { f as sdf3d_exports, n as shapeEffectBoundingBoxDeclaration, t as resolveShapeType } from "./shapeEffectBounds-CtKwBX8c.js";
+import { n as glass_exports } from "./glass-IfoQ8Prf.js";
+import { a as transformColor, c as transformPosition } from "./transformations-CsPUHppB.js";
 var { sdfSpaceUV, offsetUV } = glass_exports;
 var { createSvgSdfSampler, createAnalyticSdfSampler, driveAnalyticSubProps, ANALYTIC_SDF_EXTRA_FIELDS } = sdf_exports;
 var { createVolumetricFieldComputeNode, buildVolumetricFieldSampler, VOLUMETRIC_FIELD_EXTRA_FIELDS, is3dShapeType, isVolumetricShapeType } = sdf3d_exports;
@@ -21,23 +22,23 @@ var PHASE_INIT = [];
 for (let i = 0; i < N_CHARGES; i++) {
 	const theta = i * 2.399963;
 	const rr = Math.sqrt((i + .5) / N_CHARGES);
-	POS_FREQ_INIT.push(d.vec4f(rr * Math.cos(theta), rr * Math.sin(theta), .5 + jhash(i + 1), .5 + jhash(i + 7)));
-	PHASE_INIT.push(d.vec4f(.5 + jhash(i + 13), jhash(i + 2) * 6.2831853, jhash(i + 5) * 6.2831853, jhash(i + 9) * 6.2831853));
+	POS_FREQ_INIT.push(vec4f(rr * Math.cos(theta), rr * Math.sin(theta), .5 + jhash(i + 1), .5 + jhash(i + 7)));
+	PHASE_INIT.push(vec4f(.5 + jhash(i + 13), jhash(i + 2) * 6.2831853, jhash(i + 5) * 6.2831853, jhash(i + 9) * 6.2831853));
 }
-var POS_FREQ = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.const(d.arrayOf(d.vec4f, N_CHARGES), POS_FREQ_INIT), "POS_FREQ");
-var PHASE = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.const(d.arrayOf(d.vec4f, N_CHARGES), PHASE_INIT), "PHASE");
-const gooComposite = tgpu.fn([
-	d.vec4f,
-	d.vec4f,
-	d.vec4f,
-	d.vec2f,
-	d.vec4f,
-	d.vec3f,
-	d.vec4f,
-	d.vec4f,
-	d.vec4f,
-	d.vec4f
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((surf0, surfX, surfY, sdfUV, gooColor, specColor, p0, p1, p2, p3) => {
+var POS_FREQ = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.const(arrayOf(vec4f, N_CHARGES), POS_FREQ_INIT), "POS_FREQ");
+var PHASE = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.const(arrayOf(vec4f, N_CHARGES), PHASE_INIT), "PHASE");
+const gooComposite = src_default.fn([
+	vec4f,
+	vec4f,
+	vec4f,
+	vec2f,
+	vec4f,
+	vec3f,
+	vec4f,
+	vec4f,
+	vec4f,
+	vec4f
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((surf0, surfX, surfY, sdfUV, gooColor, specColor, p0, p1, p2, p3) => {
 	"use gpu";
 	const spread = __tsover_mul(p0.x, .45);
 	const driftAmp = __tsover_mul(p0.y, .12);
@@ -57,66 +58,64 @@ const gooComposite = tgpu.fn([
 	const animTime = p3.w;
 	const px = __tsover_sub(sdfUV.x, .5);
 	const py = __tsover_sub(sdfUV.y, .5);
-	const distC = std.sqrt(__tsover_add(__tsover_mul(px, px), __tsover_mul(py, py)));
+	const distC = sqrt(__tsover_add(__tsover_mul(px, px), __tsover_mul(py, py)));
 	const radiusMul = __tsover_add(.65, __tsover_mul(merge, .7));
 	const baseR = __tsover_mul(__tsover_mul(blobScale, .38), radiusMul);
-	if (distC > __tsover_add(__tsover_add(__tsover_add(spread, __tsover_mul(baseR, __tsover_add(1, breatheAmp))), driftAmp), .2)) return d.vec4f(0, 0, 0, 0);
-	const EPS = d.f32(.004);
-	let potC = d.f32(0);
-	let potX = d.f32(0);
-	let potY = d.f32(0);
+	if (distC > __tsover_add(__tsover_add(__tsover_add(spread, __tsover_mul(baseR, __tsover_add(1, breatheAmp))), driftAmp), .2)) return vec4f(0, 0, 0, 0);
+	const EPS = f32(.004);
+	let potC = f32(0);
+	let potX = f32(0);
+	let potY = f32(0);
 	for (let i = 0; i < N_CHARGES; i++) {
 		const pf = POS_FREQ.$[i];
 		const ph = PHASE.$[i];
-		const cx = __tsover_add(__tsover_mul(pf.x, spread), __tsover_mul(driftAmp, std.sin(__tsover_add(__tsover_mul(animTime, pf.z), ph.y))));
-		const cy = __tsover_add(__tsover_mul(pf.y, spread), __tsover_mul(driftAmp, std.cos(__tsover_add(__tsover_mul(animTime, pf.w), ph.z))));
-		const rVal = __tsover_mul(baseR, __tsover_add(1, __tsover_mul(breatheAmp, std.sin(__tsover_add(__tsover_mul(animTime, ph.x), ph.w)))));
-		const invR2 = __tsover_div(1, std.max(__tsover_mul(rVal, rVal), d.f32(1e-4)));
+		const cx = __tsover_add(__tsover_mul(pf.x, spread), __tsover_mul(driftAmp, sin(__tsover_add(__tsover_mul(animTime, pf.z), ph.y))));
+		const cy = __tsover_add(__tsover_mul(pf.y, spread), __tsover_mul(driftAmp, cos(__tsover_add(__tsover_mul(animTime, pf.w), ph.z))));
+		const rVal = __tsover_mul(baseR, __tsover_add(1, __tsover_mul(breatheAmp, sin(__tsover_add(__tsover_mul(animTime, ph.x), ph.w)))));
+		const invR2 = __tsover_div(1, max(__tsover_mul(rVal, rVal), f32(1e-4)));
 		const dcx = __tsover_sub(px, cx);
 		const dcy = __tsover_sub(py, cy);
-		potC = __tsover_add(potC, std.exp(__tsover_mul(__tsover_mul(__tsover_add(__tsover_mul(dcx, dcx), __tsover_mul(dcy, dcy)), invR2), -1)));
+		potC = __tsover_add(potC, exp(__tsover_mul(__tsover_mul(__tsover_add(__tsover_mul(dcx, dcx), __tsover_mul(dcy, dcy)), invR2), -1)));
 		const dxx = __tsover_sub(__tsover_add(px, EPS), cx);
-		potX = __tsover_add(potX, std.exp(__tsover_mul(__tsover_mul(__tsover_add(__tsover_mul(dxx, dxx), __tsover_mul(dcy, dcy)), invR2), -1)));
+		potX = __tsover_add(potX, exp(__tsover_mul(__tsover_mul(__tsover_add(__tsover_mul(dxx, dxx), __tsover_mul(dcy, dcy)), invR2), -1)));
 		const dyy = __tsover_sub(__tsover_add(py, EPS), cy);
-		potY = __tsover_add(potY, std.exp(__tsover_mul(__tsover_mul(__tsover_add(__tsover_mul(dcx, dcx), __tsover_mul(dyy, dyy)), invR2), -1)));
+		potY = __tsover_add(potY, exp(__tsover_mul(__tsover_mul(__tsover_add(__tsover_mul(dcx, dcx), __tsover_mul(dyy, dyy)), invR2), -1)));
 	}
-	const containerSoft = d.f32(.06);
-	const inside0 = __tsover_sub(1, std.smoothstep(__tsover_mul(containerSoft, -1), containerSoft, surf0.x));
-	const insideX = __tsover_sub(1, std.smoothstep(__tsover_mul(containerSoft, -1), containerSoft, surfX.x));
-	const insideY = __tsover_sub(1, std.smoothstep(__tsover_mul(containerSoft, -1), containerSoft, surfY.x));
-	const H0 = __tsover_add(__tsover_mul(potC, std.mix(d.f32(1), inside0, contain)), __tsover_mul(inside0, contain));
-	const Hx = __tsover_add(__tsover_mul(potX, std.mix(d.f32(1), insideX, contain)), __tsover_mul(insideX, contain));
-	const Hy = __tsover_add(__tsover_mul(potY, std.mix(d.f32(1), insideY, contain)), __tsover_mul(insideY, contain));
-	const soft = std.max(edgeSoftness, d.f32(.001));
-	const coverage = std.smoothstep(__tsover_sub(T, soft), __tsover_add(T, soft), H0);
+	const containerSoft = f32(.06);
+	const inside0 = __tsover_sub(1, smoothstep(__tsover_mul(containerSoft, -1), containerSoft, surf0.x));
+	const insideX = __tsover_sub(1, smoothstep(__tsover_mul(containerSoft, -1), containerSoft, surfX.x));
+	const insideY = __tsover_sub(1, smoothstep(__tsover_mul(containerSoft, -1), containerSoft, surfY.x));
+	const H0 = __tsover_add(__tsover_mul(potC, mix(f32(1), inside0, contain)), __tsover_mul(inside0, contain));
+	const Hx = __tsover_add(__tsover_mul(potX, mix(f32(1), insideX, contain)), __tsover_mul(insideX, contain));
+	const Hy = __tsover_add(__tsover_mul(potY, mix(f32(1), insideY, contain)), __tsover_mul(insideY, contain));
+	const soft = max(edgeSoftness, f32(.001));
+	const coverage = smoothstep(__tsover_sub(T, soft), __tsover_add(T, soft), H0);
 	const gradHx = __tsover_div(__tsover_sub(Hx, H0), EPS);
 	const gradHy = __tsover_div(__tsover_sub(Hy, H0), EPS);
 	const metaSlope = __tsover_add(__tsover_mul(bulge, .12), .03);
-	const reliefGate = std.min(std.min(inside0, insideX), insideY);
+	const reliefGate = min(min(inside0, insideX), insideY);
 	const shapeRelief = __tsover_mul(__tsover_mul(contain, 1.6), reliefGate);
-	const gradAx = std.clamp(__tsover_div(__tsover_sub(surfX.w, surf0.w), EPS), -6, 6);
-	const gradAy = std.clamp(__tsover_div(__tsover_sub(surfY.w, surf0.w), EPS), -6, 6);
-	const n = std.normalize(d.vec3f(__tsover_add(__tsover_mul(__tsover_mul(gradHx, -1), metaSlope), __tsover_mul(gradAx, shapeRelief)), __tsover_add(__tsover_mul(__tsover_mul(gradHy, -1), metaSlope), __tsover_mul(gradAy, shapeRelief)), -1));
-	const domeZ = __tsover_mul(std.sqrt(std.max(__tsover_sub(H0, T), d.f32(0))), bulge);
-	const shapeDepth = std.max(__tsover_mul(surf0.x, -1), d.f32(0));
-	const thick = std.clamp(__tsover_add(domeZ, __tsover_mul(__tsover_mul(shapeDepth, contain), 1.2)), 0, 1);
-	const lx = std.cos(__tsover_mul(lightAngle, DEG_TO_RAD));
-	const ly = std.sin(__tsover_mul(lightAngle, DEG_TO_RAD));
-	const L = std.normalize(d.vec3f(lx, ly, -.8));
-	const Hh = std.normalize(L.add(d.vec3f(0, 0, -1)));
-	const ndl = std.clamp(std.dot(n, L), 0, 1);
-	const ndh = std.clamp(std.dot(n, Hh), 0, 1);
-	const ndv = std.clamp(__tsover_mul(n.z, -1), 0, 1);
-	const specCore = __tsover_mul(std.pow(ndh, d.f32(232)), 1.7);
-	const specHalo = __tsover_mul(std.pow(ndh, d.f32(32)), .25);
-	const glint = __tsover_mul(std.smoothstep(.992, .999, ndh), 1.9);
-	const fres = __tsover_mul(std.pow(__tsover_sub(1, ndv), d.f32(5)), fresnelAmt);
+	const gradAx = clamp(__tsover_div(__tsover_sub(surfX.w, surf0.w), EPS), -6, 6);
+	const gradAy = clamp(__tsover_div(__tsover_sub(surfY.w, surf0.w), EPS), -6, 6);
+	const n = normalize(vec3f(__tsover_add(__tsover_mul(__tsover_mul(gradHx, -1), metaSlope), __tsover_mul(gradAx, shapeRelief)), __tsover_add(__tsover_mul(__tsover_mul(gradHy, -1), metaSlope), __tsover_mul(gradAy, shapeRelief)), -1));
+	const domeZ = __tsover_mul(sqrt(max(__tsover_sub(H0, T), f32(0))), bulge);
+	const shapeDepth = max(__tsover_mul(surf0.x, -1), f32(0));
+	const thick = clamp(__tsover_add(domeZ, __tsover_mul(__tsover_mul(shapeDepth, contain), 1.2)), 0, 1);
+	const L = normalize(vec3f(cos(__tsover_mul(lightAngle, DEG_TO_RAD)), sin(__tsover_mul(lightAngle, DEG_TO_RAD)), -.8));
+	const Hh = normalize(L.add(vec3f(0, 0, -1)));
+	const ndl = clamp(dot(n, L), 0, 1);
+	const ndh = clamp(dot(n, Hh), 0, 1);
+	const ndv = clamp(__tsover_mul(n.z, -1), 0, 1);
+	const specCore = __tsover_mul(pow(ndh, f32(232)), 1.7);
+	const specHalo = __tsover_mul(pow(ndh, f32(32)), .25);
+	const glint = __tsover_mul(smoothstep(.992, .999, ndh), 1.9);
+	const fres = __tsover_mul(pow(__tsover_sub(1, ndv), f32(5)), fresnelAmt);
 	const specRgb = specColor.mul(__tsover_mul(__tsover_add(__tsover_add(__tsover_add(specCore, specHalo), glint), fres), wetness));
-	const transmit = std.exp(__tsover_mul(__tsover_mul(absorbAmt, -1), __tsover_sub(1, thick)));
+	const transmit = exp(__tsover_mul(__tsover_mul(absorbAmt, -1), __tsover_sub(1, thick)));
 	const gooRgb = gooColor.xyz;
 	const sss = gooRgb.mul(__tsover_mul(translucency, transmit)).mul(__tsover_add(__tsover_mul(ndl, .5), .5));
 	const rgb = gooRgb.mul(__tsover_add(ambientAmt, __tsover_mul(ndl, .7))).add(sss).add(specRgb);
-	return d.vec4f(rgb.x, rgb.y, rgb.z, __tsover_mul(coverage, gooColor.w));
+	return vec4f(rgb.x, rgb.y, rgb.z, __tsover_mul(coverage, gooColor.w));
 }), {
 	v: 1,
 	name: void 0,
@@ -2041,8 +2040,8 @@ const gooComposite = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		std,
-		d,
+		std: std_exports,
+		d: data_exports,
 		N_CHARGES,
 		POS_FREQ,
 		PHASE,