shaders 3.0.448 → 3.0.450

package/dist/core/{HexGrid-B6wNW-45.js → HexGrid-By9k0YuI.js}

@@ -1,12 +1,12 @@
-import { Ht as call, J as std, Jt as vec4, Tn as d, gn as mixColorsVariants, hn as mixColorsLinear, n as tgpu } from "./coords-BkIjixe_.js";
-import { a as transformColor, o as transformColorSpace, r as transformAngle, t as colorSpaceOptions } from "./transformations-t0d2-uSX.js";
+import { Et as fract, H as mixColorsLinear, It as round, Ot as max, Rt as sin, St as dot, Tt as floor, U as mixColorsVariants, Ut as data_exports, Vt as step, bt as cos, et as src_default, ht as abs, lt as fwidth, mt as select, nt as std_exports, p as call, sn as f32, tn as vec2f, y as vec4, zt as smoothstep } from "./edges-BZUKQxSE.js";
+import { a as transformColor, o as transformColorSpace, r as transformAngle, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
 var DEG_TO_RAD = Math.PI / 180;
 var SQRT3 = Math.sqrt(3);
 var INV_SQRT3_2 = 2 / Math.sqrt(3);
 var SQRT3_2 = Math.sqrt(3) / 2;
-var flooredMod2 = tgpu.fn([d.vec2f, d.vec2f], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p, m) => {
+var flooredMod2 = src_default.fn([vec2f, vec2f], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p, m) => {
 	"use gpu";
-	return d.vec2f(__tsover_sub(p.x, __tsover_mul(m.x, std.floor(__tsover_div(p.x, m.x)))), __tsover_sub(p.y, __tsover_mul(m.y, std.floor(__tsover_div(p.y, m.y)))));
+	return vec2f(__tsover_sub(p.x, __tsover_mul(m.x, floor(__tsover_div(p.x, m.x)))), __tsover_sub(p.y, __tsover_mul(m.y, floor(__tsover_div(p.y, m.y)))));
 }), {
 	v: 1,
 	name: void 0,
@@ -108,52 +108,49 @@ var flooredMod2 = tgpu.fn([d.vec2f, d.vec2f], d.vec2f)(/* @__PURE__ */ (($) => (
 		"externalNames": ["d", "std"]
 	},
 	externals: () => ({
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
-const hexGridField = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, cells, thickness, rotation, softness, variation) => {
+const hexGridField = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, cells, thickness, rotation, softness, variation) => {
 	"use gpu";
 	const aspect = __tsover_div(viewport.x, viewport.y);
-	const correctedUV = d.vec2f(__tsover_mul(uv.x, aspect), uv.y);
+	const correctedUV = vec2f(__tsover_mul(uv.x, aspect), uv.y);
 	const ang = -__tsover_mul(rotation, DEG_TO_RAD);
-	const cosR = std.cos(ang);
-	const sinR = std.sin(ang);
+	const cosR = cos(ang);
+	const sinR = sin(ang);
 	const centerX = __tsover_mul(aspect, .5);
 	const centerY = .5;
 	const cx = __tsover_sub(correctedUV.x, centerX);
 	const cy = __tsover_sub(correctedUV.y, centerY);
-	const scaledUV = d.vec2f(__tsover_add(__tsover_sub(__tsover_mul(cx, cosR), __tsover_mul(cy, sinR)), centerX), __tsover_add(__tsover_add(__tsover_mul(cx, sinR), __tsover_mul(cy, cosR)), centerY)).mul(cells);
-	const s = d.vec2f(SQRT3, 1);
+	const scaledUV = vec2f(__tsover_add(__tsover_sub(__tsover_mul(cx, cosR), __tsover_mul(cy, sinR)), centerX), __tsover_add(__tsover_add(__tsover_mul(cx, sinR), __tsover_mul(cy, cosR)), centerY)).mul(cells);
+	const s = vec2f(SQRT3, 1);
 	const sh = s.mul(.5);
 	const a = flooredMod2(scaledUV, s).sub(sh);
 	const b = flooredMod2(scaledUV.sub(sh), s).sub(sh);
-	const gv = std.select(b, a, std.dot(a, a) < std.dot(b, b));
+	const gv = select(b, a, dot(a, a) < dot(b, b));
 	const cellId = scaledUV.sub(gv);
-	const ix = std.round(__tsover_mul(cellId.x, INV_SQRT3_2));
-	const iy = std.round(__tsover_mul(cellId.y, 2));
-	const q0 = std.fract(d.vec2f(ix, iy).mul(d.vec2f(123.34, 345.45)));
-	const q1 = q0.add(std.dot(q0, q0.add(34.345)));
-	const rand = std.fract(__tsover_mul(q1.x, q1.y));
-	const variedFactor = std.max(__tsover_add(1, __tsover_mul(__tsover_mul(__tsover_sub(rand, .5), 2), variation)), 0);
-	const pAbs = d.vec2f(std.abs(gv.x), std.abs(gv.y));
-	const hexDist = std.max(std.dot(pAbs, d.vec2f(SQRT3_2, .5)), pAbs.y);
+	const q0 = fract(vec2f(round(__tsover_mul(cellId.x, INV_SQRT3_2)), round(__tsover_mul(cellId.y, 2))).mul(vec2f(123.34, 345.45)));
+	const q1 = q0.add(dot(q0, q0.add(34.345)));
+	const rand = fract(__tsover_mul(q1.x, q1.y));
+	const variedFactor = max(__tsover_add(1, __tsover_mul(__tsover_mul(__tsover_sub(rand, .5), 2), variation)), 0);
+	const pAbs = vec2f(abs(gv.x), abs(gv.y));
+	const hexDist = max(dot(pAbs, vec2f(SQRT3_2, .5)), pAbs.y);
 	const edgeDist = __tsover_sub(.5, hexDist);
 	const lineWidth = __tsover_mul(thickness, .01);
-	const pixel = __tsover_mul(std.fwidth(scaledUV.x), .5);
+	const pixel = __tsover_mul(fwidth(scaledUV.x), .5);
 	const soft = __tsover_mul(softness, .5);
-	const lo = std.max(__tsover_sub(lineWidth, soft), 0);
+	const lo = max(__tsover_sub(lineWidth, soft), 0);
 	const hi = __tsover_add(__tsover_add(lineWidth, pixel), soft);
-	const lineMask = __tsover_mul(__tsover_sub(1, std.smoothstep(lo, hi, edgeDist)), std.step(1e-4, lineWidth));
-	return d.vec2f(lineMask, variedFactor);
+	return vec2f(__tsover_mul(__tsover_sub(1, smoothstep(lo, hi, edgeDist)), step(1e-4, lineWidth)), variedFactor);
 }), {
 	v: 1,
 	name: void 0,
@@ -881,9 +878,9 @@ const hexGridField = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		DEG_TO_RAD,
-		std,
+		std: std_exports,
 		SQRT3,
 		flooredMod2,
 		INV_SQRT3_2,

package/dist/core/{Hologram-XejRN51V.js → Hologram-Cf25ONOE.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, 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, Ct as exp, Et as fract, Mt as pow, Ot as max, Rt as sin, St as dot, Ut as data_exports, _ as floatE, et as src_default, ht as abs, in as vec3f, jt as normalize, kt as min, 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 { 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,9 +13,9 @@ var DEFAULT_SHAPE_CONFIG = JSON.stringify({
 	radius: .35
 });
 var TWO_PI = 6.283185307179586;
-const hologramHash21 = tgpu.fn([d.vec2f], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p) => {
+const hologramHash21 = src_default.fn([vec2f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p) => {
 	"use gpu";
-	return std.fract(__tsover_mul(std.sin(std.dot(p, d.vec2f(12.9898, 78.233))), 43758.5453));
+	return fract(__tsover_mul(sin(dot(p, vec2f(12.9898, 78.233))), 43758.5453));
 }), {
 	v: 1,
 	name: void 0,
@@ -63,19 +65,19 @@ const hologramHash21 = tgpu.fn([d.vec2f], d.f32)(/* @__PURE__ */ (($) => (global
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
-const hologramDisplaceUV = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, distortion, animTime) => {
+const hologramDisplaceUV = src_default.fn([
+	vec2f,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, distortion, animTime) => {
 	"use gpu";
-	const wob = __tsover_add(__tsover_mul(std.sin(__tsover_add(__tsover_mul(uv.y, 38), __tsover_mul(animTime, 2.3))), .5), __tsover_mul(std.sin(__tsover_sub(__tsover_mul(uv.y, 11.5), __tsover_mul(animTime, 1.7))), .5));
+	const wob = __tsover_add(__tsover_mul(sin(__tsover_add(__tsover_mul(uv.y, 38), __tsover_mul(animTime, 2.3))), .5), __tsover_mul(sin(__tsover_sub(__tsover_mul(uv.y, 11.5), __tsover_mul(animTime, 1.7))), .5));
 	const dispX = __tsover_mul(__tsover_mul(wob, distortion), .012);
-	return d.vec2f(__tsover_add(uv.x, dispX), uv.y);
+	return vec2f(__tsover_add(uv.x, dispX), uv.y);
 }), {
 	v: 1,
 	name: void 0,
@@ -210,24 +212,24 @@ const hologramDisplaceUV = tgpu.fn([
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
-const hologramComposite = tgpu.fn([
-	d.vec4f,
-	d.vec4f,
-	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 = ((sC, sR, sL, sU, sD, uv, viewportSize, color, p0, p1, p2, p3) => {
+const hologramComposite = src_default.fn([
+	vec4f,
+	vec4f,
+	vec4f,
+	vec4f,
+	vec4f,
+	vec2f,
+	vec2f,
+	vec3f,
+	vec4f,
+	vec4f,
+	vec4f,
+	vec4f
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sC, sR, sL, sU, sD, uv, viewportSize, color, p0, p1, p2, p3) => {
 	"use gpu";
 	const scl = p0.x;
 	const edgeSoftness = p0.y;
@@ -245,39 +247,34 @@ const hologramComposite = tgpu.fn([
 	const grain = 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 sdf = __tsover_div(sC.x, scl);
-	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 = .008;
 	const gradX = __tsover_div(__tsover_sub(sR.x, sL.x), __tsover_mul(EPS, 2));
-	const thickness = std.max(__tsover_mul(sdf, -1), 0);
-	const thin = std.exp(__tsover_mul(thickness, -5.5));
-	const nx = std.clamp(__tsover_div(__tsover_sub(sR.w, sL.w), __tsover_mul(EPS, 2)), -2, 2);
-	const ny = std.clamp(__tsover_div(__tsover_sub(sU.w, sD.w), __tsover_mul(EPS, 2)), -2, 2);
-	const nrm = std.normalize(d.vec3f(nx, ny, -1));
-	const surfFresVol = std.pow(std.clamp(__tsover_sub(1, std.abs(nrm.z)), 0, 1), d.f32(2.2));
-	const surfFres = std.select(d.f32(0), surfFresVol, volumetric > .5);
-	const depthMetric = std.select(thickness, sC.w, volumetric > .5);
-	const rimVol = __tsover_add(__tsover_mul(thin, .55), surfFres);
-	const rimBase = std.select(thin, rimVol, volumetric > .5);
+	const thickness = max(__tsover_mul(sdf, -1), 0);
+	const thin = exp(__tsover_mul(thickness, -5.5));
+	const nrm = normalize(vec3f(clamp(__tsover_div(__tsover_sub(sR.w, sL.w), __tsover_mul(EPS, 2)), -2, 2), clamp(__tsover_div(__tsover_sub(sU.w, sD.w), __tsover_mul(EPS, 2)), -2, 2), -1));
+	const surfFresVol = pow(clamp(__tsover_sub(1, abs(nrm.z)), 0, 1), f32(2.2));
+	const surfFres = select(f32(0), surfFresVol, volumetric > .5);
+	const depthMetric = select(thickness, sC.w, volumetric > .5);
+	const rimBase = select(thin, __tsover_add(__tsover_mul(thin, .55), surfFres), volumetric > .5);
 	const rim = __tsover_mul(rimBase, edgeGlow);
-	const bodyFill = __tsover_mul(__tsover_sub(1, std.exp(__tsover_mul(thickness, -5))), fill);
-	const phase = __tsover_sub(__tsover_mul(depthMetric, depthScale), __tsover_mul(animTime, 1.2));
-	const f = std.fract(phase);
-	const distI = std.min(f, __tsover_sub(1, f));
-	const contour = __tsover_mul(std.smoothstep(.06, 0, distI), depthLines);
+	const bodyFill = __tsover_mul(__tsover_sub(1, exp(__tsover_mul(thickness, -5))), fill);
+	const f = fract(__tsover_sub(__tsover_mul(depthMetric, depthScale), __tsover_mul(animTime, 1.2)));
+	const distI = min(f, __tsover_sub(1, f));
+	const contour = __tsover_mul(smoothstep(.06, 0, distI), depthLines);
 	const scanPhase = __tsover_sub(__tsover_mul(uv.y, scanlineScale), __tsover_mul(animTime, __tsover_mul(scanlineSpeed, 3)));
-	const scan = __tsover_add(__tsover_mul(std.sin(__tsover_mul(scanPhase, TWO_PI)), .5), .5);
-	const scanMask = std.mix(d.f32(1), scan, scanlines);
-	const sweepPos = std.fract(__tsover_mul(animTime, .16));
+	const scan = __tsover_add(__tsover_mul(sin(__tsover_mul(scanPhase, TWO_PI)), .5), .5);
+	const scanMask = mix(f32(1), scan, scanlines);
+	const sweepPos = fract(__tsover_mul(animTime, .16));
 	const sweepD = __tsover_sub(uv.y, sweepPos);
-	const sweepGlow = __tsover_mul(std.exp(__tsover_mul(__tsover_mul(sweepD, sweepD), -650)), sweep);
-	const shimmer = __tsover_add(__tsover_mul(std.sin(__tsover_mul(animTime, 40)), .04), __tsover_mul(std.sin(__tsover_mul(animTime, 23.3)), .03));
-	const dropNoise = __tsover_add(__tsover_mul(mxNoiseFloat2(d.vec2f(__tsover_mul(animTime, 6), 11)), .5), .5);
-	const drop = std.smoothstep(.6, .95, dropNoise);
+	const sweepGlow = __tsover_mul(exp(__tsover_mul(__tsover_mul(sweepD, sweepD), -650)), sweep);
+	const shimmer = __tsover_add(__tsover_mul(sin(__tsover_mul(animTime, 40)), .04), __tsover_mul(sin(__tsover_mul(animTime, 23.3)), .03));
+	const drop = smoothstep(.6, .95, __tsover_add(__tsover_mul(mxNoiseFloat2(vec2f(__tsover_mul(animTime, 6), 11)), .5), .5));
 	const flick = __tsover_mul(__tsover_add(1, shimmer), __tsover_sub(1, __tsover_mul(__tsover_mul(flicker, drop), .7)));
-	const gn = hologramHash21(d.vec2f(__tsover_add(__tsover_mul(uv.x, viewportSize.x), __tsover_mul(animTime, 57.3)), __tsover_mul(uv.y, viewportSize.y)));
+	const gn = hologramHash21(vec2f(__tsover_add(__tsover_mul(uv.x, viewportSize.x), __tsover_mul(animTime, 57.3)), __tsover_mul(uv.y, viewportSize.y)));
 	const grainMul = __tsover_add(1, __tsover_mul(__tsover_mul(__tsover_sub(gn, .5), grain), .6));
 	const glow = __tsover_add(__tsover_add(bodyFill, rim), contour);
 	const core = __tsover_mul(__tsover_add(__tsover_mul(__tsover_mul(__tsover_mul(glow, scanMask), flick), grainMul), __tsover_mul(sweepGlow, scanMask)), brightness);
@@ -285,13 +282,12 @@ const hologramComposite = tgpu.fn([
 	const fringe = __tsover_mul(__tsover_mul(__tsover_mul(rim, gradX), ca), .1);
 	const rCore = __tsover_add(core, fringe);
 	const bCore = __tsover_sub(core, fringe);
-	let rgb = d.vec3f(__tsover_mul(color.x, rCore), __tsover_mul(color.y, core), __tsover_mul(color.z, bCore));
-	const hot = std.clamp(__tsover_add(__tsover_mul(rim, .5), sweepGlow), 0, .8);
-	rgb = std.mix(rgb, d.vec3f(core, core, core), d.vec3f(hot));
-	const rb1 = std.clamp(__tsover_mul(__tsover_div(__tsover_mul(sdf, -1), sharp), 32), 0, 1);
-	const transition = std.smoothstep(0, 1, rb1);
-	const alpha = __tsover_mul(std.clamp(core, 0, 1), transition);
-	return d.vec4f(rgb.x, rgb.y, rgb.z, alpha);
+	let rgb = vec3f(__tsover_mul(color.x, rCore), __tsover_mul(color.y, core), __tsover_mul(color.z, bCore));
+	const hot = clamp(__tsover_add(__tsover_mul(rim, .5), sweepGlow), 0, .8);
+	rgb = mix(rgb, vec3f(core, core, core), vec3f(hot));
+	const transition = smoothstep(0, 1, clamp(__tsover_mul(__tsover_div(__tsover_mul(sdf, -1), sharp), 32), 0, 1));
+	const alpha = __tsover_mul(clamp(core, 0, 1), transition);
+	return vec4f(rgb.x, rgb.y, rgb.z, alpha);
 }), {
 	v: 1,
 	name: void 0,
@@ -1695,8 +1691,8 @@ const hologramComposite = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		std,
-		d,
+		std: std_exports,
+		d: data_exports,
 		TWO_PI,
 		noise: noise_exports,
 		hologramHash21

package/dist/core/{Holographic-D1G_Ou1y.js → Holographic-C9RzYykt.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, 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 { 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, 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 { 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 { 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;
@@ -15,12 +17,9 @@ var THIRD = 1 / 3;
 var TWOTHIRD = 2 / 3;
 var LIGHT_X = Math.cos(300 * Math.PI / 180);
 var LIGHT_Y = Math.sin(300 * Math.PI / 180);
-const holoRainbow = tgpu.fn([d.f32], d.vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((t) => {
+const holoRainbow = src_default.fn([f32], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((t) => {
 	"use gpu";
-	const r = __tsover_add(__tsover_mul(std.cos(__tsover_mul(t, TWO_PI)), .5), .5);
-	const g = __tsover_add(__tsover_mul(std.cos(__tsover_mul(__tsover_add(t, THIRD), TWO_PI)), .5), .5);
-	const b = __tsover_add(__tsover_mul(std.cos(__tsover_mul(__tsover_add(t, TWOTHIRD), TWO_PI)), .5), .5);
-	return d.vec3f(r, g, b);
+	return vec3f(__tsover_add(__tsover_mul(cos(__tsover_mul(t, TWO_PI)), .5), .5), __tsover_add(__tsover_mul(cos(__tsover_mul(__tsover_add(t, THIRD), TWO_PI)), .5), .5), __tsover_add(__tsover_mul(cos(__tsover_mul(__tsover_add(t, TWOTHIRD), TWO_PI)), .5), .5));
 }), {
 	v: 1,
 	name: void 0,
@@ -147,23 +146,23 @@ const holoRainbow = tgpu.fn([d.f32], d.vec3f)(/* @__PURE__ */ (($) => (globalThi
 		]
 	},
 	externals: () => ({
-		std,
+		std: std_exports,
 		TWO_PI,
 		THIRD,
 		TWOTHIRD,
-		d
+		d: data_exports
 	})
 }) && $.f)({}));
-const holographicComposite = tgpu.fn([
-	d.vec4f,
-	d.vec4f,
-	d.vec4f,
-	d.vec2f,
-	d.vec2f,
-	d.vec4f,
-	d.vec4f,
-	d.vec4f
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sC, sR, sU, sdfUV, viewportSize, p0, p1, p2) => {
+const holographicComposite = src_default.fn([
+	vec4f,
+	vec4f,
+	vec4f,
+	vec2f,
+	vec2f,
+	vec4f,
+	vec4f,
+	vec4f
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sC, sR, sU, sdfUV, viewportSize, p0, p1, p2) => {
 	"use gpu";
 	const scl = p0.x;
 	const edgeSoftness = p0.y;
@@ -176,68 +175,66 @@ const holographicComposite = tgpu.fn([
 	const sparkle = p2.x;
 	const animTime = p2.y;
 	const volumetric = p2.z;
-	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 = sC.x;
 	const sdf = __tsover_div(sdfRaw, scl);
-	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 = .008;
 	const gradX = __tsover_div(__tsover_sub(sR.x, sC.x), EPS);
 	const gradY = __tsover_div(__tsover_sub(sU.x, sC.x), 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), sC.y, volumetric > .5);
-	const pdy = std.select(__tsover_sub(sdfUV.y, .5), sC.z, 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), sC.y, volumetric > .5);
+	const pdy = select(__tsover_sub(sdfUV.y, .5), sC.z, volumetric > .5);
 	const qdx = __tsover_sub(sdfUV.x, .5);
 	const qdy = __tsover_sub(sdfUV.y, .5);
-	const baseNxVol = std.clamp(__tsover_div(__tsover_sub(sR.w, sC.w), EPS), -1.5, 1.5);
-	const baseNyVol = std.clamp(__tsover_div(__tsover_sub(sU.w, sC.w), EPS), -1.5, 1.5);
-	const steepnessVol = std.clamp(__tsover_add(__tsover_mul(baseNxVol, baseNxVol), __tsover_mul(baseNyVol, baseNyVol)), 0, 2);
-	const edgeT = std.clamp(__tsover_div(__tsover_mul(sdf, -1), .06), 0, 1);
+	const baseNxVol = clamp(__tsover_div(__tsover_sub(sR.w, sC.w), EPS), -1.5, 1.5);
+	const baseNyVol = clamp(__tsover_div(__tsover_sub(sU.w, sC.w), EPS), -1.5, 1.5);
+	const steepnessVol = clamp(__tsover_add(__tsover_mul(baseNxVol, baseNxVol), __tsover_mul(baseNyVol, baseNyVol)), 0, 2);
+	const edgeT = clamp(__tsover_div(__tsover_mul(sdf, -1), .06), 0, 1);
 	const domeSlope = __tsover_mul(__tsover_sub(1, edgeT), .35);
 	const baseNxFlat = __tsover_mul(gradX, domeSlope);
 	const baseNyFlat = __tsover_mul(gradY, domeSlope);
-	const baseNx = std.select(baseNxFlat, baseNxVol, volumetric > .5);
-	const baseNy = std.select(baseNyFlat, baseNyVol, volumetric > .5);
-	const steepness = std.select(d.f32(0), steepnessVol, volumetric > .5);
+	const baseNx = select(baseNxFlat, baseNxVol, volumetric > .5);
+	const baseNy = select(baseNyFlat, baseNyVol, volumetric > .5);
+	const steepness = select(f32(0), steepnessVol, volumetric > .5);
 	const crScale = __tsover_mul(crinkleScale, 1.35);
 	const steepAtten = __tsover_div(1, __tsover_add(1, __tsover_mul(steepness, 2)));
 	const crAmp = __tsover_mul(__tsover_mul(crinkle, .8), steepAtten);
 	const neps = .02;
-	const w0 = mxNoiseFloat2(d.vec2f(__tsover_add(__tsover_mul(pdx, crScale), 2.7), __tsover_add(__tsover_mul(pdy, crScale), 11.3)));
-	const wxTap = mxNoiseFloat2(d.vec2f(__tsover_add(__tsover_mul(__tsover_add(pdx, neps), crScale), 2.7), __tsover_add(__tsover_mul(pdy, crScale), 11.3)));
-	const wyTap = mxNoiseFloat2(d.vec2f(__tsover_add(__tsover_mul(pdx, crScale), 2.7), __tsover_add(__tsover_mul(__tsover_add(pdy, neps), crScale), 11.3)));
+	const w0 = mxNoiseFloat2(vec2f(__tsover_add(__tsover_mul(pdx, crScale), 2.7), __tsover_add(__tsover_mul(pdy, crScale), 11.3)));
+	const wxTap = mxNoiseFloat2(vec2f(__tsover_add(__tsover_mul(__tsover_add(pdx, neps), crScale), 2.7), __tsover_add(__tsover_mul(pdy, crScale), 11.3)));
+	const wyTap = mxNoiseFloat2(vec2f(__tsover_add(__tsover_mul(pdx, crScale), 2.7), __tsover_add(__tsover_mul(__tsover_add(pdy, neps), crScale), 11.3)));
 	const wx = __tsover_div(__tsover_sub(wxTap, w0), neps);
 	const wy = __tsover_div(__tsover_sub(wyTap, w0), neps);
-	const n = std.normalize(d.vec3f(__tsover_add(baseNx, __tsover_mul(__tsover_mul(wx, crAmp), .4)), __tsover_add(baseNy, __tsover_mul(__tsover_mul(wy, crAmp), .4)), -1));
+	const n = normalize(vec3f(__tsover_add(baseNx, __tsover_mul(__tsover_mul(wx, crAmp), .4)), __tsover_add(baseNy, __tsover_mul(__tsover_mul(wy, crAmp), .4)), -1));
 	const fScale = __tsover_mul(foilScale, 2.2);
 	const drift = __tsover_mul(animTime, .06);
-	const blotch = __tsover_add(mxNoiseFloat2(d.vec2f(__tsover_add(__tsover_mul(pdx, fScale), __tsover_mul(drift, LIGHT_X)), __tsover_add(__tsover_mul(pdy, fScale), __tsover_mul(drift, LIGHT_Y)))), __tsover_mul(mxNoiseFloat2(d.vec2f(__tsover_sub(__tsover_add(__tsover_mul(__tsover_mul(pdx, fScale), 2.1), 5.2), __tsover_mul(__tsover_mul(drift, LIGHT_X), 1.6)), __tsover_sub(__tsover_add(__tsover_mul(__tsover_mul(pdy, fScale), 2.1), 9.4), __tsover_mul(__tsover_mul(drift, LIGHT_Y), 1.6)))), .4));
+	const blotch = __tsover_add(mxNoiseFloat2(vec2f(__tsover_add(__tsover_mul(pdx, fScale), __tsover_mul(drift, LIGHT_X)), __tsover_add(__tsover_mul(pdy, fScale), __tsover_mul(drift, LIGHT_Y)))), __tsover_mul(mxNoiseFloat2(vec2f(__tsover_sub(__tsover_add(__tsover_mul(__tsover_mul(pdx, fScale), 2.1), 5.2), __tsover_mul(__tsover_mul(drift, LIGHT_X), 1.6)), __tsover_sub(__tsover_add(__tsover_mul(__tsover_mul(pdy, fScale), 2.1), 9.4), __tsover_mul(__tsover_mul(drift, LIGHT_Y), 1.6)))), .4));
 	const normalTilt = __tsover_add(__tsover_mul(n.x, LIGHT_X), __tsover_mul(n.y, LIGHT_Y));
 	const ramp = __tsover_mul(__tsover_add(__tsover_mul(pdx, LIGHT_X), __tsover_mul(pdy, LIGHT_Y)), .8);
 	const hue = __tsover_add(__tsover_add(__tsover_add(__tsover_add(__tsover_mul(blotch, .45), ramp), __tsover_mul(normalTilt, 1.4)), __tsover_mul(animTime, .18)), __tsover_div(hueShift, 360));
-	const saturationC = std.clamp(saturation, 0, 1);
+	const saturationC = clamp(saturation, 0, 1);
 	const spectral = holoRainbow(hue);
-	const silver = d.vec3f(.72, .73, .76);
-	const foilTint = std.mix(silver, spectral, d.vec3f(__tsover_mul(saturationC, .85)));
-	const roughnessC = std.clamp(roughness, 0, 1);
-	const L = std.normalize(d.vec3f(LIGHT_X, LIGHT_Y, -.9));
-	const H = std.normalize(L.add(d.vec3f(0, 0, -1)));
-	const ndl = std.clamp(__tsover_add(__tsover_mul(std.dot(n, L), .5), .5), 0, 1);
-	const ndh = std.clamp(std.dot(n, H), 0, 1);
-	const sheen = __tsover_mul(__tsover_mul(std.pow(ndh, d.f32(7)), .45), __tsover_sub(1, __tsover_mul(roughnessC, .35)));
-	const specCore = __tsover_mul(__tsover_mul(std.pow(ndh, std.mix(d.f32(42), d.f32(12), roughnessC)), .85), __tsover_sub(1, __tsover_mul(roughnessC, .55)));
-	const specRgb = foilTint.mul(sheen).add(std.mix(foilTint, d.vec3f(1, 1, 1), d.vec3f(.6)).mul(specCore));
-	const flakeN = mxNoiseFloat2(d.vec2f(__tsover_mul(pdx, 190), __tsover_mul(pdy, 190)));
-	const flakePhase = mxNoiseFloat2(d.vec2f(__tsover_add(__tsover_mul(pdx, 190), 47.3), __tsover_sub(__tsover_mul(pdy, 190), 31.1)));
-	const twinkle = __tsover_add(__tsover_mul(std.sin(__tsover_add(__tsover_mul(animTime, 2.2), __tsover_mul(flakePhase, 12.6))), .5), .5);
-	const flakeMask = __tsover_mul(__tsover_mul(std.smoothstep(.52, .62, __tsover_add(__tsover_mul(flakeN, .75), __tsover_mul(twinkle, .3))), std.clamp(sparkle, 0, 1)), steepAtten);
+	const foilTint = mix(vec3f(.72, .73, .76), spectral, vec3f(__tsover_mul(saturationC, .85)));
+	const roughnessC = clamp(roughness, 0, 1);
+	const L = normalize(vec3f(LIGHT_X, LIGHT_Y, -.9));
+	const H = normalize(L.add(vec3f(0, 0, -1)));
+	const ndl = clamp(__tsover_add(__tsover_mul(dot(n, L), .5), .5), 0, 1);
+	const ndh = clamp(dot(n, H), 0, 1);
+	const sheen = __tsover_mul(__tsover_mul(pow(ndh, f32(7)), .45), __tsover_sub(1, __tsover_mul(roughnessC, .35)));
+	const specCore = __tsover_mul(__tsover_mul(pow(ndh, mix(f32(42), f32(12), roughnessC)), .85), __tsover_sub(1, __tsover_mul(roughnessC, .55)));
+	const specRgb = foilTint.mul(sheen).add(mix(foilTint, vec3f(1, 1, 1), vec3f(.6)).mul(specCore));
+	const flakeN = mxNoiseFloat2(vec2f(__tsover_mul(pdx, 190), __tsover_mul(pdy, 190)));
+	const flakePhase = mxNoiseFloat2(vec2f(__tsover_add(__tsover_mul(pdx, 190), 47.3), __tsover_sub(__tsover_mul(pdy, 190), 31.1)));
+	const twinkle = __tsover_add(__tsover_mul(sin(__tsover_add(__tsover_mul(animTime, 2.2), __tsover_mul(flakePhase, 12.6))), .5), .5);
+	const flakeMask = __tsover_mul(__tsover_mul(smoothstep(.52, .62, __tsover_add(__tsover_mul(flakeN, .75), __tsover_mul(twinkle, .3))), clamp(sparkle, 0, 1)), steepAtten);
 	const flakeRgb = holoRainbow(__tsover_add(__tsover_add(hue, .33), __tsover_mul(flakePhase, .5))).mul(__tsover_add(.85, __tsover_mul(twinkle, .55))).mul(__tsover_add(__tsover_mul(ndl, .6), .7));
-	const grain = mxNoiseFloat2(d.vec2f(__tsover_mul(qdx, 420), __tsover_mul(qdy, 420)));
+	const grain = mxNoiseFloat2(vec2f(__tsover_mul(qdx, 420), __tsover_mul(qdy, 420)));
 	const grainMul = __tsover_add(1, __tsover_mul(__tsover_mul(grain, roughnessC), .28));
-	const foilBase = foilTint.mul(__tsover_add(__tsover_mul(ndl, .5), .62)).add(specRgb);
-	const foilRgb = std.mix(foilBase, flakeRgb, d.vec3f(flakeMask)).mul(grainMul);
-	const transition = std.smoothstep(0, 1, rb1);
-	return d.vec4f(foilRgb.x, foilRgb.y, foilRgb.z, transition);
+	const foilRgb = mix(foilTint.mul(__tsover_add(__tsover_mul(ndl, .5), .62)).add(specRgb), flakeRgb, vec3f(flakeMask)).mul(grainMul);
+	const transition = smoothstep(0, 1, rb1);
+	return vec4f(foilRgb.x, foilRgb.y, foilRgb.z, transition);
 }), {
 	v: 1,
 	name: void 0,
@@ -2189,8 +2186,8 @@ const holographicComposite = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		std,
-		d,
+		std: std_exports,
+		d: data_exports,
 		noise: noise_exports,
 		LIGHT_X,
 		LIGHT_Y,

package/dist/core/{HueShift-BCDgYfJs.js → HueShift-V3gQVuIo.js}

@@ -1,11 +1,11 @@
-import { Bt as ZERO, Ht as call, J as std, Tn as d, n as tgpu } from "./coords-BkIjixe_.js";
+import { Rt as sin, Ut as data_exports, bt as cos, d as ZERO, et as src_default, nt as std_exports, on as vec4f, p as call, sn as f32 } from "./edges-BZUKQxSE.js";
 var DEG_TO_RAD = Math.PI / 180;
 var SQRT3 = 1.7320508075688772;
-const hueShiftColor = tgpu.fn([d.vec4f, d.f32], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, shiftDeg) => {
+const hueShiftColor = src_default.fn([vec4f, f32], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, shiftDeg) => {
 	"use gpu";
 	const angle = __tsover_mul(shiftDeg, DEG_TO_RAD);
-	const cosA = std.cos(angle);
-	const sinA = std.sin(angle);
+	const cosA = cos(angle);
+	const sinA = sin(angle);
 	const k = __tsover_div(1, 3);
 	const oneMinusCos = __tsover_sub(1, cosA);
 	const kOneMinusCos = __tsover_mul(oneMinusCos, k);
@@ -22,10 +22,7 @@ const hueShiftColor = tgpu.fn([d.vec4f, d.f32], d.vec4f)(/* @__PURE__ */ (($) =>
 	const r = color.x;
 	const g = color.y;
 	const b = color.z;
-	const newR = __tsover_add(__tsover_add(__tsover_mul(r, m00), __tsover_mul(g, m01)), __tsover_mul(b, m02));
-	const newG = __tsover_add(__tsover_add(__tsover_mul(r, m10), __tsover_mul(g, m11)), __tsover_mul(b, m12));
-	const newB = __tsover_add(__tsover_add(__tsover_mul(r, m20), __tsover_mul(g, m21)), __tsover_mul(b, m22));
-	return d.vec4f(newR, newG, newB, color.w);
+	return vec4f(__tsover_add(__tsover_add(__tsover_mul(r, m00), __tsover_mul(g, m01)), __tsover_mul(b, m02)), __tsover_add(__tsover_add(__tsover_mul(r, m10), __tsover_mul(g, m11)), __tsover_mul(b, m12)), __tsover_add(__tsover_add(__tsover_mul(r, m20), __tsover_mul(g, m21)), __tsover_mul(b, m22)), color.w);
 }), {
 	v: 1,
 	name: void 0,
@@ -349,9 +346,9 @@ const hueShiftColor = tgpu.fn([d.vec4f, d.f32], d.vec4f)(/* @__PURE__ */ (($) =>
 	},
 	externals: () => ({
 		DEG_TO_RAD,
-		std,
+		std: std_exports,
 		SQRT3,
-		d
+		d: data_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {

package/dist/core/{ImageTexture-BE2Jlkg6.js → ImageTexture-DAUR2N5Q.js}

@@ -1,5 +1,6 @@
-import { Ht as call, _ as scaleScaleDown, d as alphaCutLinear, f as sampleUV, h as scaleFill, m as scaleCover, p as scaleContain } from "./coords-BkIjixe_.js";
-import { r as registerNaturalSize } from "./naturalSize-Caz3-kRv.js";
+import { p as call } from "./edges-BZUKQxSE.js";
+import { a as scaleFill, i as scaleCover, n as sampleUV, r as scaleContain, s as scaleScaleDown, t as alphaCutLinear } from "./media-Ds6MRfGR.js";
+import { r as registerNaturalSize } from "./naturalSize-B679wTgN.js";
 var OBJECT_FIT_MODES = {
 	cover: 0,
 	contain: 1,