shaders 3.0.448 → 3.0.450

package/dist/core/{FractalNoise-mMVLGmIv.js → FractalNoise-D9HYiOdr.js}

@@ -1,43 +1,45 @@
-import { $ as mixStopsOrColorsExpr, Ht as call, J as std, Tn as d, n as tgpu, pt as noise_exports, ut as mxNoiseFloat2 } from "./coords-BkIjixe_.js";
-import { a as transformColor, o as transformColorSpace, r as transformAngle, t as colorSpaceOptions } from "./transformations-t0d2-uSX.js";
-import { h as colorStopsPropConfig, t as animatedTime } from "./porters-BmU6G9TR.js";
+import { Rt as sin, Ut as data_exports, bt as cos, cn as i32, et as src_default, mt as select, nt as std_exports, p as call, sn as f32, tn as vec2f, yt as clamp } from "./edges-BZUKQxSE.js";
+import { h as colorStopsPropConfig, t as animatedTime } from "./porters-DogLzpKT.js";
+import { p as noise_exports, u as mxNoiseFloat2 } from "./noise-Cq0KUOSC.js";
+import { t as mixStopsOrColorsExpr } from "./noiseColor-CQyzqpVZ.js";
+import { a as transformColor, o as transformColorSpace, r as transformAngle, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
 var GOLDEN = 2.39996;
-const fractalNoiseValue = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, angle, animTime, seed, detail, contrast, octaveCount) => {
+const fractalNoiseValue = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, angle, animTime, seed, detail, contrast, octaveCount) => {
 	"use gpu";
 	const aspect = __tsover_div(viewport.x, viewport.y);
 	const angleRad = __tsover_mul(angle, .0174533);
-	const cosA = std.cos(angleRad);
-	const sinA = std.sin(angleRad);
+	const cosA = cos(angleRad);
+	const sinA = sin(angleRad);
 	const au = __tsover_sub(__tsover_mul(uv.x, aspect), __tsover_mul(aspect, .5));
 	const av = __tsover_sub(uv.y, .5);
 	const ru = __tsover_add(__tsover_mul(au, cosA), __tsover_mul(av, sinA));
 	const rv = __tsover_add(__tsover_mul(au, -sinA), __tsover_mul(av, cosA));
-	const n = d.i32(octaveCount);
-	let octaveScale = d.f32(2);
-	let weight = d.f32(1);
-	let accumulated = d.f32(0);
-	let totalWeight = d.f32(0);
+	const n = i32(octaveCount);
+	let octaveScale = f32(2);
+	let weight = f32(1);
+	let accumulated = f32(0);
+	let totalWeight = f32(0);
 	for (let i = 0; i < 8; i++) {
-		const fi = d.f32(i);
-		const dirX = std.cos(__tsover_mul(fi, GOLDEN));
-		const dirY = std.sin(__tsover_mul(fi, GOLDEN));
-		const coord = d.vec2f(__tsover_add(__tsover_add(__tsover_mul(ru, octaveScale), __tsover_mul(animTime, dirX)), seed), __tsover_add(__tsover_add(__tsover_mul(rv, octaveScale), __tsover_mul(animTime, dirY)), __tsover_mul(seed, .7)));
-		const active = std.select(d.f32(0), d.f32(1), i < n);
+		const fi = f32(i);
+		const dirX = cos(__tsover_mul(fi, GOLDEN));
+		const dirY = sin(__tsover_mul(fi, GOLDEN));
+		const coord = vec2f(__tsover_add(__tsover_add(__tsover_mul(ru, octaveScale), __tsover_mul(animTime, dirX)), seed), __tsover_add(__tsover_add(__tsover_mul(rv, octaveScale), __tsover_mul(animTime, dirY)), __tsover_mul(seed, .7)));
+		const active = select(f32(0), f32(1), i < n);
 		accumulated = __tsover_add(accumulated, __tsover_mul(__tsover_mul(mxNoiseFloat2(coord), weight), active));
 		totalWeight = __tsover_add(totalWeight, __tsover_mul(weight, active));
 		octaveScale = __tsover_mul(octaveScale, detail);
 		weight = __tsover_mul(weight, contrast);
 	}
-	return std.clamp(__tsover_add(__tsover_mul(__tsover_div(accumulated, totalWeight), .5), .5), 0, 1);
+	return clamp(__tsover_add(__tsover_mul(__tsover_div(accumulated, totalWeight), .5), .5), 0, 1);
 }), {
 	v: 1,
 	name: void 0,
@@ -548,8 +550,8 @@ const fractalNoiseValue = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		std,
-		d,
+		std: std_exports,
+		d: data_exports,
 		GOLDEN,
 		noise: noise_exports
 	})

package/dist/core/{Frost-M53tZlcf.js → Frost-DQZZxdTk.js}

@@ -1,8 +1,10 @@
-import { F as sdf_exports, Ht as call, J as std, Jt as vec4, Kt as floatE, Tn as d, ft as mxWorleyNoiseFloat2Pub, n as tgpu, pt as noise_exports, ut as mxNoiseFloat2, 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 { At as mix, Bt as sqrt, Ct as exp, Mt as pow, Ot as max, Rt as sin, St as dot, Ut as data_exports, _ as floatE, bt as cos, et as src_default, in as vec3f, jt as normalize, mt as select, nt as std_exports, on as vec4f, p as call, sn as f32, tn as vec2f, y as vec4, yt as clamp, zt as smoothstep } from "./edges-BZUKQxSE.js";
+import { t as animatedTime } from "./porters-DogLzpKT.js";
+import { f as mxWorleyNoiseFloat2Pub, p as noise_exports, u as mxNoiseFloat2 } from "./noise-Cq0KUOSC.js";
+import { h as sdf_exports } from "./sdf-o99ONcMJ.js";
+import { f as sdf3d_exports, n as shapeEffectBoundingBoxDeclaration, t as resolveShapeType } from "./shapeEffectBounds-Dg4GQ5vW.js";
+import { n as glass_exports } from "./glass-BVqgjSPg.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;
@@ -11,18 +13,18 @@ var DEFAULT_SHAPE_CONFIG = JSON.stringify({
 	type: "circleSDF",
 	radius: .35
 });
-const frostComposite = tgpu.fn([
-	d.vec4f,
-	d.vec4f,
-	d.vec4f,
-	d.vec2f,
-	d.vec2f,
-	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, viewportSize, iceColor, p0, p1, p2, p3) => {
+const frostComposite = src_default.fn([
+	vec4f,
+	vec4f,
+	vec4f,
+	vec2f,
+	vec2f,
+	vec3f,
+	vec4f,
+	vec4f,
+	vec4f,
+	vec4f
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((surf0, surfX, surfY, sdfUV, viewportSize, iceColor, p0, p1, p2, p3) => {
 	"use gpu";
 	const scale = p0.x;
 	const edgeSoftness = p0.y;
@@ -40,82 +42,77 @@ const frostComposite = tgpu.fn([
 	const ambientAmt = p3.y;
 	const animTime = p3.z;
 	const volumetric = p3.w;
-	const sharp = std.max(__tsover_mul(edgeSoftness, .5), .001);
+	const sharp = max(__tsover_mul(edgeSoftness, .5), .001);
 	const pxH = __tsover_div(1, viewportSize.y);
 	const sdfRaw = surf0.x;
 	const sdf = __tsover_div(sdfRaw, scale);
-	if (sdf > __tsover_mul(pxH, 2)) return d.vec4f(0, 0, 0, 0);
+	if (sdf > __tsover_mul(pxH, 2)) return vec4f(0, 0, 0, 0);
 	const EPS = .01;
 	const gradX = __tsover_div(__tsover_sub(surfX.x, sdfRaw), EPS);
 	const gradY = __tsover_div(__tsover_sub(surfY.x, sdfRaw), EPS);
-	const rb1 = std.clamp(__tsover_mul(__tsover_div(__tsover_mul(sdf, -1), sharp), 32), 0, 1);
-	const pdx = std.select(__tsover_sub(sdfUV.x, .5), surf0.y, volumetric > .5);
-	const pdy = std.select(__tsover_sub(sdfUV.y, .5), surf0.z, volumetric > .5);
-	const thicknessRange = std.max(d.f32(.3), .01);
-	const depthNorm = std.clamp(__tsover_div(__tsover_mul(sdf, -1), thicknessRange), 0, 1);
-	const ddx = std.clamp(__tsover_div(__tsover_sub(surfX.w, surf0.w), EPS), -4, 4);
-	const ddy = std.clamp(__tsover_div(__tsover_sub(surfY.w, surf0.w), EPS), -4, 4);
-	const nVol = std.normalize(d.vec3f(ddx, ddy, -1));
-	const bevelSlope = __tsover_mul(std.sqrt(std.max(__tsover_sub(1, __tsover_mul(depthNorm, depthNorm)), d.f32(0))), 1.8);
-	const nFlat = std.normalize(d.vec3f(__tsover_mul(gradX, bevelSlope), __tsover_mul(gradY, bevelSlope), -1));
-	const nBase = std.select(nFlat, nVol, volumetric > .5);
-	const steepness = std.select(d.f32(0), std.clamp(__tsover_add(__tsover_mul(ddx, ddx), __tsover_mul(ddy, ddy)), 0, 2), volumetric > .5);
+	const rb1 = clamp(__tsover_mul(__tsover_div(__tsover_mul(sdf, -1), sharp), 32), 0, 1);
+	const pdx = select(__tsover_sub(sdfUV.x, .5), surf0.y, volumetric > .5);
+	const pdy = select(__tsover_sub(sdfUV.y, .5), surf0.z, volumetric > .5);
+	const thicknessRange = max(f32(.3), .01);
+	const depthNorm = clamp(__tsover_div(__tsover_mul(sdf, -1), thicknessRange), 0, 1);
+	const ddx = clamp(__tsover_div(__tsover_sub(surfX.w, surf0.w), EPS), -4, 4);
+	const ddy = clamp(__tsover_div(__tsover_sub(surfY.w, surf0.w), EPS), -4, 4);
+	const nVol = normalize(vec3f(ddx, ddy, -1));
+	const bevelSlope = __tsover_mul(sqrt(max(__tsover_sub(1, __tsover_mul(depthNorm, depthNorm)), f32(0))), 1.8);
+	const nBase = select(normalize(vec3f(__tsover_mul(gradX, bevelSlope), __tsover_mul(gradY, bevelSlope), -1)), nVol, volumetric > .5);
+	const steepness = select(f32(0), clamp(__tsover_add(__tsover_mul(ddx, ddx), __tsover_mul(ddy, ddy)), 0, 2), volumetric > .5);
 	const steepAtten = __tsover_div(1, __tsover_add(1, __tsover_mul(steepness, 2)));
-	const thickVol = std.clamp(__tsover_mul(__tsover_mul(sdf, -1), 2), 0, 1.2);
-	const thickFlat = __tsover_mul(std.clamp(__tsover_mul(sdf, -1), 0, .5), 2);
-	const thicknessRaw = std.select(thickFlat, thickVol, volumetric > .5);
+	const thickVol = clamp(__tsover_mul(__tsover_mul(sdf, -1), 2), 0, 1.2);
+	const thicknessRaw = select(__tsover_mul(clamp(__tsover_mul(sdf, -1), 0, .5), 2), thickVol, volumetric > .5);
 	const thickness = __tsover_mul(thicknessRaw, density);
-	const depthT = std.clamp(__tsover_mul(thickness, 1.2), 0, 1);
-	const absorb = d.vec3f(1.6, .85, .45).mul(absorption);
-	const transmit = d.vec3f(std.exp(__tsover_mul(__tsover_mul(thickness, absorb.x), -1)), std.exp(__tsover_mul(__tsover_mul(thickness, absorb.y), -1)), std.exp(__tsover_mul(__tsover_mul(thickness, absorb.z), -1)));
-	const scatteredRgb = std.mix(d.vec3f(1, 1, 1), iceColor, d.vec3f(depthT)).mul(transmit);
-	const frostDepthU = std.max(__tsover_mul(frostDepth, .3), .01);
-	const edgeMask = __tsover_sub(1, std.smoothstep(0, frostDepthU, __tsover_mul(sdf, -1)));
+	const depthT = clamp(__tsover_mul(thickness, 1.2), 0, 1);
+	const absorb = vec3f(1.6, .85, .45).mul(absorption);
+	const transmit = vec3f(exp(__tsover_mul(__tsover_mul(thickness, absorb.x), -1)), exp(__tsover_mul(__tsover_mul(thickness, absorb.y), -1)), exp(__tsover_mul(__tsover_mul(thickness, absorb.z), -1)));
+	const scatteredRgb = mix(vec3f(1, 1, 1), iceColor, vec3f(depthT)).mul(transmit);
+	const frostDepthU = max(__tsover_mul(frostDepth, .3), .01);
+	const edgeMask = __tsover_sub(1, smoothstep(0, frostDepthU, __tsover_mul(sdf, -1)));
 	const frostField = __tsover_mul(edgeMask, frostAmount);
 	const frostScale = __tsover_mul(frostScaleP, 60);
 	const feps = .004;
-	let frostPerturbX = d.f32(0);
-	let frostPerturbY = d.f32(0);
-	let crackLines = d.f32(0);
+	let frostPerturbX = f32(0);
+	let frostPerturbY = f32(0);
+	let crackLines = f32(0);
 	if (frostField > 0) {
-		const fn0 = mxNoiseFloat2(d.vec2f(__tsover_mul(pdx, frostScale), __tsover_mul(pdy, frostScale)));
-		const fnx = __tsover_div(__tsover_sub(mxNoiseFloat2(d.vec2f(__tsover_mul(__tsover_add(pdx, feps), frostScale), __tsover_mul(pdy, frostScale))), fn0), feps);
-		const fny = __tsover_div(__tsover_sub(mxNoiseFloat2(d.vec2f(__tsover_mul(pdx, frostScale), __tsover_mul(__tsover_add(pdy, feps), frostScale))), fn0), feps);
+		const fn0 = mxNoiseFloat2(vec2f(__tsover_mul(pdx, frostScale), __tsover_mul(pdy, frostScale)));
+		const fnx = __tsover_div(__tsover_sub(mxNoiseFloat2(vec2f(__tsover_mul(__tsover_add(pdx, feps), frostScale), __tsover_mul(pdy, frostScale))), fn0), feps);
+		const fny = __tsover_div(__tsover_sub(mxNoiseFloat2(vec2f(__tsover_mul(pdx, frostScale), __tsover_mul(__tsover_add(pdy, feps), frostScale))), fn0), feps);
 		const frostNormalAmp = __tsover_mul(__tsover_mul(frostField, frostRoughness), steepAtten);
 		frostPerturbX = __tsover_mul(__tsover_mul(fnx, frostNormalAmp), .03);
 		frostPerturbY = __tsover_mul(__tsover_mul(fny, frostNormalAmp), .03);
 		const wScale = __tsover_mul(frostScaleP, 40);
-		const wc = mxWorleyNoiseFloat2Pub(d.vec2f(__tsover_mul(pdx, wScale), __tsover_mul(pdy, wScale)), 1);
-		crackLines = __tsover_mul(std.smoothstep(.25, 0, wc), frostField);
+		const wc = mxWorleyNoiseFloat2Pub(vec2f(__tsover_mul(pdx, wScale), __tsover_mul(pdy, wScale)), 1);
+		crackLines = __tsover_mul(smoothstep(.25, 0, wc), frostField);
 	}
-	const n = std.normalize(nBase.add(d.vec3f(frostPerturbX, frostPerturbY, 0)));
-	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, -.6));
-	const H = std.normalize(L.add(d.vec3f(0, 0, -1)));
-	const ndl = std.dot(n, L);
-	const ndh = std.clamp(std.dot(n, H), 0, 1);
-	const wrap = __tsover_add(__tsover_mul(ndl, .5), .5);
-	const sssDiffuse = std.pow(wrap, d.f32(.7));
-	const backLight = std.clamp(__tsover_add(__tsover_mul(std.dot(L, d.vec3f(0, 0, 1)), .5), .5), 0, 1);
+	const n = normalize(nBase.add(vec3f(frostPerturbX, frostPerturbY, 0)));
+	const L = normalize(vec3f(cos(__tsover_mul(lightAngle, DEG_TO_RAD)), sin(__tsover_mul(lightAngle, DEG_TO_RAD)), -.6));
+	const H = normalize(L.add(vec3f(0, 0, -1)));
+	const ndl = dot(n, L);
+	const ndh = clamp(dot(n, H), 0, 1);
+	const sssDiffuse = pow(__tsover_add(__tsover_mul(ndl, .5), .5), f32(.7));
+	const backLight = clamp(__tsover_add(__tsover_mul(dot(L, vec3f(0, 0, 1)), .5), .5), 0, 1);
 	const forwardGlow = transmit.mul(backLight).mul(scatter).mul(__tsover_sub(1, __tsover_mul(depthT, .4)));
 	const sssRgb = scatteredRgb.mul(__tsover_add(__tsover_mul(sssDiffuse, .6), .5)).add(forwardGlow.mul(.5));
-	let sparkleGlint = d.f32(0);
+	let sparkleGlint = f32(0);
 	if (frostField > 0) {
-		const glintField = __tsover_add(__tsover_mul(mxNoiseFloat2(d.vec2f(__tsover_add(__tsover_mul(pdx, 190), 13.7), __tsover_sub(__tsover_mul(pdy, 190), 4.3))), .5), .5);
-		const twinkle = __tsover_add(__tsover_mul(std.sin(__tsover_add(__tsover_mul(animTime, 3), __tsover_mul(glintField, 40))), .5), .5);
-		sparkleGlint = __tsover_mul(__tsover_mul(__tsover_mul(std.smoothstep(.72, .96, __tsover_mul(glintField, twinkle)), __tsover_add(__tsover_mul(std.pow(ndh, d.f32(6)), .6), .4)), frostField), sparkleAmt);
+		const glintField = __tsover_add(__tsover_mul(mxNoiseFloat2(vec2f(__tsover_add(__tsover_mul(pdx, 190), 13.7), __tsover_sub(__tsover_mul(pdy, 190), 4.3))), .5), .5);
+		const twinkle = __tsover_add(__tsover_mul(sin(__tsover_add(__tsover_mul(animTime, 3), __tsover_mul(glintField, 40))), .5), .5);
+		sparkleGlint = __tsover_mul(__tsover_mul(__tsover_mul(smoothstep(.72, .96, __tsover_mul(glintField, twinkle)), __tsover_add(__tsover_mul(pow(ndh, f32(6)), .6), .4)), frostField), sparkleAmt);
 	}
-	const frostRgb = d.vec3f(.95, .98, 1).mul(__tsover_add(__tsover_mul(crackLines, .4), __tsover_mul(sparkleGlint, 4)));
-	const cosView = std.clamp(__tsover_mul(n.z, -1), 0, 1);
+	const frostRgb = vec3f(.95, .98, 1).mul(__tsover_add(__tsover_mul(crackLines, .4), __tsover_mul(sparkleGlint, 4)));
+	const cosView = clamp(__tsover_mul(n.z, -1), 0, 1);
 	const grazing = __tsover_sub(1, cosView);
-	const fres = __tsover_mul(std.pow(grazing, d.f32(3)), fresnelAmt);
-	const fresnelRgb = d.vec3f(.85, .93, 1).mul(__tsover_mul(fres, 1.5));
-	const broadSpec = __tsover_mul(__tsover_mul(std.pow(ndh, d.f32(16)), .4), gloss);
-	const ambient = d.vec3f(.4, .46, .55).mul(ambientAmt);
-	const iceRgb = sssRgb.add(ambient).add(d.vec3f(broadSpec, broadSpec, broadSpec)).add(fresnelRgb).add(frostRgb);
-	const transition = std.smoothstep(0, 1, rb1);
-	return d.vec4f(iceRgb.x, iceRgb.y, iceRgb.z, transition);
+	const fres = __tsover_mul(pow(grazing, f32(3)), fresnelAmt);
+	const fresnelRgb = vec3f(.85, .93, 1).mul(__tsover_mul(fres, 1.5));
+	const broadSpec = __tsover_mul(__tsover_mul(pow(ndh, f32(16)), .4), gloss);
+	const ambient = vec3f(.4, .46, .55).mul(ambientAmt);
+	const iceRgb = sssRgb.add(ambient).add(vec3f(broadSpec, broadSpec, broadSpec)).add(fresnelRgb).add(frostRgb);
+	const transition = smoothstep(0, 1, rb1);
+	return vec4f(iceRgb.x, iceRgb.y, iceRgb.z, transition);
 }), {
 	v: 1,
 	name: void 0,
@@ -2319,8 +2316,8 @@ const frostComposite = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		std,
-		d,
+		std: std_exports,
+		d: data_exports,
 		noise: noise_exports,
 		DEG_TO_RAD
 	})

package/dist/core/{GaborNoise-BhXywN1d.js → GaborNoise-D7BP0K4g.js}

@@ -1,17 +1,19 @@
-import { Ht as call, J as std, Tn as d, at as gabor12, 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 gaborNoiseField = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, scale, seed, frequency, animTime) => {
+import { Ct as exp, Ut as data_exports, et as src_default, nt as std_exports, p as call, sn as f32, tn as vec2f } from "./edges-BZUKQxSE.js";
+import { t as animatedTime } from "./porters-DogLzpKT.js";
+import { a as gabor12, p as noise_exports } from "./noise-Cq0KUOSC.js";
+import { n as toneAndColorExpr } from "./noiseColor-CQyzqpVZ.js";
+import { i as noiseToneProps, r as noiseSpeedProp, t as noiseColorProps } from "./noiseColor-DjCUZ_8u.js";
+const gaborNoiseField = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, scale, seed, frequency, 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);
+	const pos = vec2f(__tsover_mul(uv.x, aspect), uv.y).mul(exp(scale)).add(seed);
 	return __tsover_add(__tsover_mul(gabor12(pos, frequency, animTime), .5), .5);
 }), {
 	v: 1,
@@ -148,8 +150,8 @@ const gaborNoiseField = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		d,
-		std,
+		d: data_exports,
+		std: std_exports,
 		noise: noise_exports
 	})
 }) && $.f)({}));

package/dist/core/{Glass-B9D_52op.js → Glass-CzCVnGn-.js}

@@ -1,7 +1,9 @@
-import { Bt as ZERO, F as sdf_exports, K as createGaussianBlurCompute, y as sdf3d_exports } from "./coords-BkIjixe_.js";
-import { n as glass_exports } from "./glass-sOqjtPJD.js";
-import { a as transformColor, c as transformPosition, i as transformBoolean } from "./transformations-t0d2-uSX.js";
-import { n as shapeEffectBoundingBoxDeclaration, t as resolveShapeType } from "./shapeEffectBounds-PQqKLQXO.js";
+import { d as ZERO } from "./edges-BZUKQxSE.js";
+import { i as createGaussianBlurCompute } from "./blur-DKmdsW6d.js";
+import { h as sdf_exports } from "./sdf-o99ONcMJ.js";
+import { f as sdf3d_exports, n as shapeEffectBoundingBoxDeclaration, t as resolveShapeType } from "./shapeEffectBounds-Dg4GQ5vW.js";
+import { n as glass_exports } from "./glass-BVqgjSPg.js";
+import { a as transformColor, c as transformPosition, i as transformBoolean } from "./transformations-CsPUHppB.js";
 var { applyGlassEffect } = glass_exports;
 var { createSvgSdfSamplerWithGradients, createAnalyticSdfSampler, driveAnalyticSubProps, ANALYTIC_SDF_EXTRA_FIELDS } = sdf_exports;
 var { createVolumetricFieldComputeNode, buildVolumetricFieldSampler, VOLUMETRIC_FIELD_EXTRA_FIELDS, is3dShapeType, isVolumetricShapeType } = sdf3d_exports;

package/dist/core/{GlassTiles-DIkGYgVE.js → GlassTiles-DJzPPqwz.js}

@@ -1,35 +1,32 @@
-import { Bt as ZERO, Ht as call, J as std, Mt as edgeClampUV, Rt as sampleCatmullRomExpr, Tn as d, cn as unpremultiplyAlpha, n as tgpu } from "./coords-BkIjixe_.js";
+import { N as unpremultiplyAlpha, Ot as max, Rt as sin, Tt as floor, Ut as data_exports, bt as cos, d as ZERO, et as src_default, l as sampleCatmullRomExpr, mt as select, nt as std_exports, p as call, r as edgeClampUV, sn as f32, tn as vec2f } from "./edges-BZUKQxSE.js";
 var DEG_TO_RAD = Math.PI / 180;
-const glassTilesUV = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, intensity, baseTileCount, rotationDegrees, roundnessAmount) => {
+const glassTilesUV = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, intensity, baseTileCount, rotationDegrees, roundnessAmount) => {
 	"use gpu";
 	const isWide = aspect > 1;
-	const tileCount = d.vec2f(std.select(__tsover_mul(baseTileCount, aspect), baseTileCount, isWide), std.select(baseTileCount, __tsover_div(baseTileCount, aspect), isWide));
-	const aspectCorrectedUV = d.vec2f(__tsover_mul(uv.x, aspect), uv.y);
+	const tileCount = vec2f(select(__tsover_mul(baseTileCount, aspect), baseTileCount, isWide), select(baseTileCount, __tsover_div(baseTileCount, aspect), isWide));
+	const aspectCorrectedUV = vec2f(__tsover_mul(uv.x, aspect), uv.y);
 	const rotationRadians = __tsover_mul(rotationDegrees, DEG_TO_RAD);
-	const cosA = std.cos(rotationRadians);
-	const sinA = std.sin(rotationRadians);
-	const centered = aspectCorrectedUV.sub(d.vec2f(__tsover_mul(.5, aspect), .5));
-	const rotatedX = __tsover_sub(__tsover_mul(centered.x, cosA), __tsover_mul(centered.y, sinA));
-	const rotatedY = __tsover_add(__tsover_mul(centered.x, sinA), __tsover_mul(centered.y, cosA));
-	const rotatedUV = d.vec2f(rotatedX, rotatedY).add(d.vec2f(__tsover_mul(.5, aspect), .5));
-	const gridUV = d.vec2f(__tsover_div(rotatedUV.x, aspect), rotatedUV.y);
-	const cellCoord = std.floor(gridUV.mul(tileCount)).div(tileCount);
+	const cosA = cos(rotationRadians);
+	const sinA = sin(rotationRadians);
+	const centered = aspectCorrectedUV.sub(vec2f(__tsover_mul(.5, aspect), .5));
+	const rotatedUV = vec2f(__tsover_sub(__tsover_mul(centered.x, cosA), __tsover_mul(centered.y, sinA)), __tsover_add(__tsover_mul(centered.x, sinA), __tsover_mul(centered.y, cosA))).add(vec2f(__tsover_mul(.5, aspect), .5));
+	const gridUV = vec2f(__tsover_div(rotatedUV.x, aspect), rotatedUV.y);
+	const cellCoord = floor(gridUV.mul(tileCount)).div(tileCount);
 	const localUV = gridUV.sub(cellCoord);
-	const oneOverTile = d.vec2f(1, 1).div(tileCount);
-	const fromCenter = localUV.div(oneOverTile).sub(d.vec2f(.5, .5));
+	const oneOverTile = vec2f(1, 1).div(tileCount);
+	const fromCenter = localUV.div(oneOverTile).sub(vec2f(.5, .5));
 	const distFromCenter = __tsover_add(__tsover_mul(fromCenter.x, fromCenter.x), __tsover_mul(fromCenter.y, fromCenter.y));
-	const roundnessFactor = __tsover_sub(1, __tsover_mul(distFromCenter, __tsover_mul(roundnessAmount, 4)));
-	const clampedRoundness = std.max(roundnessFactor, 0);
+	const clampedRoundness = max(__tsover_sub(1, __tsover_mul(distFromCenter, __tsover_mul(roundnessAmount, 4))), 0);
 	const distortionFactor = __tsover_mul(intensity, .025);
 	const scaleFactor = __tsover_mul(distortionFactor, clampedRoundness);
-	const distortion = d.vec2f(__tsover_div(__tsover_mul(fromCenter.x, scaleFactor), aspect), __tsover_mul(fromCenter.y, scaleFactor));
+	const distortion = vec2f(__tsover_div(__tsover_mul(fromCenter.x, scaleFactor), aspect), __tsover_mul(fromCenter.y, scaleFactor));
 	return uv.add(distortion);
 }), {
 	v: 1,
@@ -562,8 +559,8 @@ const glassTilesUV = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		d,
-		std,
+		d: data_exports,
+		std: std_exports,
 		DEG_TO_RAD
 	})
 }) && $.f)({}));