shaders 3.0.447 → 3.0.449

package/dist/core/{FractalNoise-mMVLGmIv.js → FractalNoise-DIrQ3eQj.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 { $t as vec2f, It as sin, Vt as data_exports, _t as clamp, an as f32, et as src_default, nt as std_exports, on as i32, p as call, pt as select, vt as cos } from "./edges-BXNBKxSN.js";
+import { h as colorStopsPropConfig, t as animatedTime } from "./porters-DBK1Aipq.js";
+import { p as noise_exports, u as mxNoiseFloat2 } from "./noise-wTSHXgFz.js";
+import { t as mixStopsOrColorsExpr } from "./noiseColor-CPakiKNF.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-B_3JSI2H.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 { $t as vec2f, At as pow, Et as max, It as sin, Lt as smoothstep, Ot as mix, Rt as sqrt, 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, pt as select, vt as cos, xt as exp, y as vec4 } from "./edges-BXNBKxSN.js";
+import { t as animatedTime } from "./porters-DBK1Aipq.js";
+import { f as mxWorleyNoiseFloat2Pub, p as noise_exports, u as mxNoiseFloat2 } from "./noise-wTSHXgFz.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;
@@ -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-4FWeA9yr.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 { $t as vec2f, Vt as data_exports, an as f32, et as src_default, nt as std_exports, p as call, xt as exp } from "./edges-BXNBKxSN.js";
+import { t as animatedTime } from "./porters-DBK1Aipq.js";
+import { a as gabor12, p as noise_exports } from "./noise-wTSHXgFz.js";
+import { n as toneAndColorExpr } from "./noiseColor-CPakiKNF.js";
+import { i as noiseToneProps, r as noiseSpeedProp, t as noiseColorProps } from "./noiseColor-DscZM9CO.js";
+const 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-wOhmSf3v.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-BXNBKxSN.js";
+import { i as createGaussianBlurCompute } from "./blur-tvWOoxKt.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, 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-DgdAiEuy.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 { $t as vec2f, Ct as floor, Et as max, It as sin, N as unpremultiplyAlpha, Vt as data_exports, an as f32, d as ZERO, et as src_default, l as sampleCatmullRomExpr, nt as std_exports, p as call, pt as select, r as edgeClampUV, vt as cos } from "./edges-BXNBKxSN.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)({}));

package/dist/core/{Glitch-CUOJt5VX.js → Glitch-BOiywFUR.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 { $t as vec2f, Ct as floor, It as sin, N as unpremultiplyAlpha, Ot as mix, Vt as data_exports, Xt as struct, _t as clamp, an as f32, d as ZERO, et as src_default, in as vec4f, mt as abs, nn as vec3f, nt as std_exports, p as call, wt as fract, zt as step } from "./edges-BXNBKxSN.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,21 @@ 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,
 	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, 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, vec3f(geom.colorBarStrength)).mul(geom.scanlineEffect);
+	return vec4f(finalColor.x, finalColor.y, finalColor.z, 1);
 }), {
 	v: 1,
 	name: void 0,
@@ -1853,8 +1848,8 @@ const glitchCombine = tgpu.fn([
 		"externalNames": ["d", "std"]
 	},
 	externals: () => ({
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {