shaders 3.0.447 → 3.0.449

package/dist/core/{Voronoi-DMYFDwIS.js → Voronoi-CRH2cGlR.js}

@@ -1,10 +1,9 @@
-import { Et as mixColorStopsRuntime, Ht as call, J as std, Jt as vec4, Tn as d, gn as mixColorsVariants, hn as mixColorsLinear, n as tgpu, qt as mixExpr } from "./coords-BkIjixe_.js";
-import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-t0d2-uSX.js";
-import { h as colorStopsPropConfig, t as animatedTime } from "./porters-BmU6G9TR.js";
-var voronoiHash = tgpu.fn([d.vec2f], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p) => {
+import { $t as vec2f, At as pow, Ct as floor, Et as max, H as mixColorsLinear, It as sin, Lt as smoothstep, Tt as length, U as mixColorsVariants, Vt as data_exports, _t as clamp, an as f32, bt as dot, et as src_default, nt as std_exports, p as call, pt as select, v as mixExpr, vt as cos, wt as fract, y as vec4 } from "./edges-BXNBKxSN.js";
+import { S as mixColorStopsRuntime, h as colorStopsPropConfig, t as animatedTime } from "./porters-DBK1Aipq.js";
+import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
+var voronoiHash = src_default.fn([vec2f], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p) => {
 	"use gpu";
-	const h = d.vec2f(std.dot(p, d.vec2f(127.1, 311.7)), std.dot(p, d.vec2f(269.5, 183.3)));
-	return std.fract(std.sin(h).mul(43758.5453));
+	return fract(sin(vec2f(dot(p, vec2f(127.1, 311.7)), dot(p, vec2f(269.5, 183.3)))).mul(43758.5453));
 }), {
 	v: 1,
 	name: void 0,
@@ -85,44 +84,41 @@ var voronoiHash = tgpu.fn([d.vec2f], d.vec2f)(/* @__PURE__ */ (($) => (globalThi
 		"externalNames": ["d", "std"]
 	},
 	externals: () => ({
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
-const voronoiField = 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, scale, animT, seed, edgeIntensity, edgeSoftness) => {
+const voronoiField = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, scale, animT, seed, edgeIntensity, edgeSoftness) => {
 	"use gpu";
 	const aspect = __tsover_div(viewport.x, viewport.y);
-	const scaledUV = d.vec2f(__tsover_mul(uv.x, aspect), uv.y).mul(scale);
-	const cell = std.floor(scaledUV);
-	const localUV = std.fract(scaledUV);
-	let d1 = d.f32(10);
-	let d2 = d.f32(10);
+	const scaledUV = vec2f(__tsover_mul(uv.x, aspect), uv.y).mul(scale);
+	const cell = floor(scaledUV);
+	const localUV = fract(scaledUV);
+	let d1 = f32(10);
+	let d2 = f32(10);
 	for (let ny = -1; ny <= 1; ny++) for (let nx = -1; nx <= 1; nx++) {
-		const offset = d.vec2f(d.f32(nx), d.f32(ny));
-		const h = voronoiHash(d.vec2f(__tsover_add(__tsover_add(cell.x, offset.x), seed), __tsover_add(__tsover_add(cell.y, offset.y), seed)));
-		const pointX = std.clamp(__tsover_add(h.x, __tsover_mul(std.sin(__tsover_add(animT, __tsover_mul(h.x, 6.28))), .15)), .05, .95);
-		const pointY = std.clamp(__tsover_add(h.y, __tsover_mul(std.cos(__tsover_add(__tsover_mul(animT, .7), __tsover_mul(h.y, 6.28))), .15)), .05, .95);
-		const dist = std.length(d.vec2f(__tsover_sub(localUV.x, __tsover_add(offset.x, pointX)), __tsover_sub(localUV.y, __tsover_add(offset.y, pointY))));
+		const offset = vec2f(f32(nx), f32(ny));
+		const h = voronoiHash(vec2f(__tsover_add(__tsover_add(cell.x, offset.x), seed), __tsover_add(__tsover_add(cell.y, offset.y), seed)));
+		const pointX = clamp(__tsover_add(h.x, __tsover_mul(sin(__tsover_add(animT, __tsover_mul(h.x, 6.28))), .15)), .05, .95);
+		const pointY = clamp(__tsover_add(h.y, __tsover_mul(cos(__tsover_add(__tsover_mul(animT, .7), __tsover_mul(h.y, 6.28))), .15)), .05, .95);
+		const dist = length(vec2f(__tsover_sub(localUV.x, __tsover_add(offset.x, pointX)), __tsover_sub(localUV.y, __tsover_add(offset.y, pointY))));
 		const isCloser = dist < d1;
-		d2 = std.select(std.select(d2, dist, dist < d2), d1, isCloser);
-		d1 = std.select(d1, dist, isCloser);
+		d2 = select(select(d2, dist, dist < d2), d1, isCloser);
+		d1 = select(d1, dist, isCloser);
 	}
-	const safeSum = std.max(__tsover_add(d1, d2), 1e-4);
-	const normalizedDist = std.clamp(__tsover_div(__tsover_mul(d1, 2), safeSum), 0, 1);
-	const gradientPower = __tsover_sub(4, __tsover_mul(edgeIntensity, 3));
-	const tColor = std.clamp(std.pow(normalizedDist, gradientPower), 0, 1);
+	const safeSum = max(__tsover_add(d1, d2), 1e-4);
+	const tColor = clamp(pow(clamp(__tsover_div(__tsover_mul(d1, 2), safeSum), 0, 1), __tsover_sub(4, __tsover_mul(edgeIntensity, 3))), 0, 1);
 	const scaledEdgeSoftness = __tsover_div(__tsover_mul(edgeSoftness, scale), 6);
 	const edgeMetric = __tsover_div(__tsover_sub(d2, d1), safeSum);
-	const edgeMask = std.smoothstep(0, __tsover_add(scaledEdgeSoftness, .001), edgeMetric);
-	return d.vec2f(tColor, edgeMask);
+	return vec2f(tColor, smoothstep(0, __tsover_add(scaledEdgeSoftness, .001), edgeMetric));
 }), {
 	v: 1,
 	name: void 0,
@@ -782,8 +778,8 @@ const voronoiField = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		d,
-		std,
+		d: data_exports,
+		std: std_exports,
 		voronoiHash
 	})
 }) && $.f)({}));

package/dist/core/{Water-D74wbHmn.js → Water-CneenzRZ.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 { $t as vec2f, At as pow, Et as max, It as sin, Lt as smoothstep, Mt as reflect, Nt as refract, Ot as mix, Tt as length, 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, mt as abs, 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 { 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,11 +13,11 @@ var DEFAULT_SHAPE_CONFIG = JSON.stringify({
 	type: "circleSDF",
 	radius: .35
 });
-const waterFbm = tgpu.fn([d.vec2f], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv) => {
+const waterFbm = src_default.fn([vec2f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv) => {
 	"use gpu";
 	const n0 = mxNoiseFloat2(uv);
-	const n1 = __tsover_mul(mxNoiseFloat2(uv.mul(2.07).add(d.vec2f(4.3, 9.1))), .5);
-	const n2 = __tsover_mul(mxNoiseFloat2(uv.mul(4.13).add(d.vec2f(1.7, 8.2))), .25);
+	const n1 = __tsover_mul(mxNoiseFloat2(uv.mul(2.07).add(vec2f(4.3, 9.1))), .5);
+	const n2 = __tsover_mul(mxNoiseFloat2(uv.mul(4.13).add(vec2f(1.7, 8.2))), .25);
 	return __tsover_mul(__tsover_add(__tsover_add(n0, n1), n2), .52);
 }), {
 	v: 1,
@@ -144,10 +146,10 @@ const waterFbm = tgpu.fn([d.vec2f], d.f32)(/* @__PURE__ */ (($) => (globalThis._
 	},
 	externals: () => ({
 		noise: noise_exports,
-		d
+		d: data_exports
 	})
 }) && $.f)({}));
-const waterNoise1 = tgpu.fn([d.vec2f], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv) => {
+const waterNoise1 = src_default.fn([vec2f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv) => {
 	"use gpu";
 	return __tsover_mul(mxNoiseFloat2(uv), .52);
 }), {
@@ -176,29 +178,27 @@ const waterNoise1 = tgpu.fn([d.vec2f], d.f32)(/* @__PURE__ */ (($) => (globalThi
 	},
 	externals: () => ({ noise: noise_exports })
 }) && $.f)({}));
-const waterSky = tgpu.fn([
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((rx, ry, lx, ly, envC, envS, sharp) => {
+const waterSky = src_default.fn([
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((rx, ry, lx, ly, envC, envS, sharp) => {
 	"use gpu";
 	const ex = __tsover_sub(__tsover_mul(rx, envC), __tsover_mul(ry, envS));
 	const ey = __tsover_add(__tsover_mul(rx, envS), __tsover_mul(ry, envC));
-	const up = std.clamp(__tsover_add(__tsover_mul(ey, .5), .5), 0, 1);
-	const horizon = d.vec3f(.9, .96, 1);
-	const zenith = d.vec3f(.2, .46, .85);
-	const below = d.vec3f(.04, .1, .16);
-	const aboveCol = std.mix(horizon, zenith, d.vec3f(std.smoothstep(.5, 1, up)));
-	let base = std.mix(below, aboveCol, d.vec3f(std.smoothstep(.4, .55, up)));
-	const sunCenter = d.vec2f(__tsover_mul(lx, .8), __tsover_add(__tsover_mul(ly, .8), .12));
-	const sunRad = std.mix(.5, .13, sharp);
-	const sd = std.length(d.vec2f(ex, ey).sub(sunCenter));
-	const sun = std.smoothstep(sunRad, __tsover_mul(sunRad, .15), sd);
-	base = base.add(d.vec3f(1, .97, .88).mul(__tsover_mul(sun, 1.5)));
+	const up = clamp(__tsover_add(__tsover_mul(ey, .5), .5), 0, 1);
+	const horizon = vec3f(.9, .96, 1);
+	const zenith = vec3f(.2, .46, .85);
+	let base = mix(vec3f(.04, .1, .16), mix(horizon, zenith, vec3f(smoothstep(.5, 1, up))), vec3f(smoothstep(.4, .55, up)));
+	const sunCenter = vec2f(__tsover_mul(lx, .8), __tsover_add(__tsover_mul(ly, .8), .12));
+	const sunRad = mix(.5, .13, sharp);
+	const sd = length(vec2f(ex, ey).sub(sunCenter));
+	const sun = smoothstep(sunRad, __tsover_mul(sunRad, .15), sd);
+	base = base.add(vec3f(1, .97, .88).mul(__tsover_mul(sun, 1.5)));
 	return base;
 }), {
 	v: 1,
@@ -567,23 +567,23 @@ const waterSky = tgpu.fn([
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
-const waterComposite = tgpu.fn([
-	d.vec4f,
-	d.vec4f,
-	d.vec4f,
-	d.vec2f,
-	d.vec2f,
-	d.vec3f,
-	d.vec4f,
-	d.vec4f,
-	d.vec4f,
-	d.vec4f,
-	d.vec4f
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((surf0, surfX, surfY, sdfUV, viewportSize, waterColor, p0, p1, p2, p3, p4) => {
+const waterComposite = src_default.fn([
+	vec4f,
+	vec4f,
+	vec4f,
+	vec2f,
+	vec2f,
+	vec3f,
+	vec4f,
+	vec4f,
+	vec4f,
+	vec4f,
+	vec4f
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((surf0, surfX, surfY, sdfUV, viewportSize, waterColor, p0, p1, p2, p3, p4) => {
 	"use gpu";
 	const scl = p0.x;
 	const edgeSoftness = p0.y;
@@ -602,94 +602,87 @@ const waterComposite = tgpu.fn([
 	const envRotation = p3.z;
 	const animTime = p3.w;
 	const volumetric = p4.x;
-	const sharpEdge = std.max(__tsover_mul(edgeSoftness, .5), .001);
+	const sharpEdge = max(__tsover_mul(edgeSoftness, .5), .001);
 	const pxH = __tsover_div(1, viewportSize.y);
 	const sdfRaw = surf0.x;
 	const sdf = __tsover_div(sdfRaw, scl);
-	if (sdf > __tsover_mul(pxH, 2)) return d.vec4f(0, 0, 0, 0);
-	const lx = std.cos(__tsover_mul(lightAngle, DEG_TO_RAD));
-	const ly = std.sin(__tsover_mul(lightAngle, DEG_TO_RAD));
-	const envC = std.cos(__tsover_mul(envRotation, DEG_TO_RAD));
-	const envS = std.sin(__tsover_mul(envRotation, DEG_TO_RAD));
+	if (sdf > __tsover_mul(pxH, 2)) return vec4f(0, 0, 0, 0);
+	const lx = cos(__tsover_mul(lightAngle, DEG_TO_RAD));
+	const ly = sin(__tsover_mul(lightAngle, DEG_TO_RAD));
+	const envC = cos(__tsover_mul(envRotation, DEG_TO_RAD));
+	const envS = sin(__tsover_mul(envRotation, DEG_TO_RAD));
 	const EPS = .01;
 	const gradX = __tsover_div(__tsover_sub(surfX.x, sdfRaw), EPS);
 	const gradY = __tsover_div(__tsover_sub(surfY.x, sdfRaw), EPS);
-	const ddx = std.clamp(__tsover_div(__tsover_sub(surfX.w, surf0.w), EPS), -5, 5);
-	const ddy = std.clamp(__tsover_div(__tsover_sub(surfY.w, surf0.w), EPS), -5, 5);
-	const nVol = std.normalize(d.vec3f(ddx, ddy, -1));
-	const rimT = std.clamp(__tsover_div(__tsover_mul(sdf, -1), .05), 0, 1);
+	const nVol = normalize(vec3f(clamp(__tsover_div(__tsover_sub(surfX.w, surf0.w), EPS), -5, 5), clamp(__tsover_div(__tsover_sub(surfY.w, surf0.w), EPS), -5, 5), -1));
+	const rimT = clamp(__tsover_div(__tsover_mul(sdf, -1), .05), 0, 1);
 	const rimBevel = __tsover_mul(__tsover_sub(1, rimT), 1.6);
-	const nFlat = std.normalize(d.vec3f(__tsover_mul(gradX, rimBevel), __tsover_mul(gradY, rimBevel), -1));
-	const nGeo = std.select(nFlat, nVol, volumetric > .5);
-	const fx = std.select(__tsover_sub(sdfUV.x, .5), surf0.y, volumetric > .5);
-	const fy = std.select(__tsover_sub(sdfUV.y, .5), surf0.z, volumetric > .5);
+	const nGeo = select(normalize(vec3f(__tsover_mul(gradX, rimBevel), __tsover_mul(gradY, rimBevel), -1)), nVol, volumetric > .5);
+	const fx = select(__tsover_sub(sdfUV.x, .5), surf0.y, volumetric > .5);
+	const fy = select(__tsover_sub(sdfUV.y, .5), surf0.z, volumetric > .5);
 	const freq = __tsover_mul(waveScale, 2.4);
 	const flowT = __tsover_mul(animTime, .2);
-	const q = d.vec2f(__tsover_mul(__tsover_mul(fx, freq), .8), __tsover_mul(__tsover_mul(fy, freq), 1.25));
+	const q = vec2f(__tsover_mul(__tsover_mul(fx, freq), .8), __tsover_mul(__tsover_mul(fy, freq), 1.25));
 	const wAmt = __tsover_mul(swirl, .9);
 	const warpInput = q.mul(.6);
-	const wx = __tsover_mul(std.sin(__tsover_add(__tsover_add(__tsover_mul(warpInput.x, 1.7), __tsover_mul(flowT, .7)), 1.7)), std.cos(__tsover_add(__tsover_add(__tsover_mul(warpInput.y, 1.3), __tsover_mul(flowT, .5)), 2.3)));
-	const wy = __tsover_mul(std.cos(__tsover_add(__tsover_add(__tsover_mul(warpInput.x, 1.4), __tsover_mul(flowT, .9)), 8.7)), std.sin(__tsover_add(__tsover_add(__tsover_mul(warpInput.y, 1.6), __tsover_mul(flowT, .6)), 5.1)));
-	const qw = q.add(d.vec2f(wx, wy).mul(wAmt)).add(d.vec2f(0, __tsover_mul(flowT, -1)));
+	const wx = __tsover_mul(sin(__tsover_add(__tsover_add(__tsover_mul(warpInput.x, 1.7), __tsover_mul(flowT, .7)), 1.7)), cos(__tsover_add(__tsover_add(__tsover_mul(warpInput.y, 1.3), __tsover_mul(flowT, .5)), 2.3)));
+	const wy = __tsover_mul(cos(__tsover_add(__tsover_add(__tsover_mul(warpInput.x, 1.4), __tsover_mul(flowT, .9)), 8.7)), sin(__tsover_add(__tsover_add(__tsover_mul(warpInput.y, 1.6), __tsover_mul(flowT, .6)), 5.1)));
+	const qw = q.add(vec2f(wx, wy).mul(wAmt)).add(vec2f(0, __tsover_mul(flowT, -1)));
 	const re = .06;
-	const gMax = d.f32(4);
+	const gMax = f32(4);
 	const h0 = waterFbm(qw);
 	const h0n1 = waterNoise1(qw);
-	const hx = std.clamp(__tsover_div(__tsover_sub(waterNoise1(qw.add(d.vec2f(re, 0))), h0n1), re), __tsover_mul(gMax, -1), gMax);
-	const hy = std.clamp(__tsover_div(__tsover_sub(waterNoise1(qw.add(d.vec2f(0, re))), h0n1), re), __tsover_mul(gMax, -1), gMax);
+	const hx = clamp(__tsover_div(__tsover_sub(waterNoise1(qw.add(vec2f(re, 0))), h0n1), re), __tsover_mul(gMax, -1), gMax);
+	const hy = clamp(__tsover_div(__tsover_sub(waterNoise1(qw.add(vec2f(0, re))), h0n1), re), __tsover_mul(gMax, -1), gMax);
 	const fineRe = .025;
-	const qf = qw.mul(3.3).add(d.vec2f(__tsover_mul(flowT, 1.7), __tsover_mul(flowT, -1.15))).add(d.vec2f(11.3, 4.7));
+	const qf = qw.mul(3.3).add(vec2f(__tsover_mul(flowT, 1.7), __tsover_mul(flowT, -1.15))).add(vec2f(11.3, 4.7));
 	const f0n1 = waterNoise1(qf);
-	const fxg = std.clamp(__tsover_div(__tsover_sub(waterNoise1(qf.add(d.vec2f(fineRe, 0))), f0n1), fineRe), __tsover_mul(gMax, -1), gMax);
-	const fyg = std.clamp(__tsover_div(__tsover_sub(waterNoise1(qf.add(d.vec2f(0, fineRe))), f0n1), fineRe), __tsover_mul(gMax, -1), gMax);
+	const fxg = clamp(__tsover_div(__tsover_sub(waterNoise1(qf.add(vec2f(fineRe, 0))), f0n1), fineRe), __tsover_mul(gMax, -1), gMax);
+	const fyg = clamp(__tsover_div(__tsover_sub(waterNoise1(qf.add(vec2f(0, fineRe))), f0n1), fineRe), __tsover_mul(gMax, -1), gMax);
 	const relief = __tsover_mul(choppiness, .5);
 	const reliefFine = __tsover_mul(choppiness, .22);
-	const n = std.normalize(d.vec3f(__tsover_sub(__tsover_sub(nGeo.x, __tsover_mul(hx, relief)), __tsover_mul(fxg, reliefFine)), __tsover_sub(__tsover_sub(nGeo.y, __tsover_mul(hy, relief)), __tsover_mul(fyg, reliefFine)), nGeo.z));
-	const sharp = std.clamp(sharpness, 0, 1);
-	const R = std.reflect(d.vec3f(0, 0, 1), n);
+	const n = normalize(vec3f(__tsover_sub(__tsover_sub(nGeo.x, __tsover_mul(hx, relief)), __tsover_mul(fxg, reliefFine)), __tsover_sub(__tsover_sub(nGeo.y, __tsover_mul(hy, relief)), __tsover_mul(fyg, reliefFine)), nGeo.z));
+	const sharp = clamp(sharpness, 0, 1);
+	const R = reflect(vec3f(0, 0, 1), n);
 	const reflCol = waterSky(R.x, R.y, lx, ly, envC, envS, sharp).mul(reflection);
-	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, depth);
-	const depthT = std.clamp(__tsover_mul(thickness, 1.3), 0, 1);
+	const depthT = clamp(__tsover_mul(thickness, 1.3), 0, 1);
 	const wc = waterColor;
-	const absorb = d.vec3f(__tsover_mul(__tsover_sub(1, wc.x), 2.2), __tsover_mul(__tsover_sub(1, wc.y), 2.2), __tsover_mul(__tsover_sub(1, wc.z), 2.2));
-	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 shallowsC = std.clamp(shallows, 0, 1);
-	const shallowCol = std.mix(wc, d.vec3f(1, 1, 1), d.vec3f(shallowsC));
-	const bodyTint = std.mix(shallowCol, wc, d.vec3f(depthT)).mul(transmit).add(wc.mul(__tsover_mul(depthT, .18)));
-	const L = std.normalize(d.vec3f(lx, ly, -.7));
-	const ndl = std.dot(n, L);
-	const diffuse = __tsover_add(__tsover_mul(std.pow(std.clamp(__tsover_add(__tsover_mul(ndl, .5), .5), 0, 1), d.f32(.8)), .5), .5);
+	const absorb = vec3f(__tsover_mul(__tsover_sub(1, wc.x), 2.2), __tsover_mul(__tsover_sub(1, wc.y), 2.2), __tsover_mul(__tsover_sub(1, wc.z), 2.2));
+	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 shallowsC = clamp(shallows, 0, 1);
+	const bodyTint = mix(mix(wc, vec3f(1, 1, 1), vec3f(shallowsC)), wc, vec3f(depthT)).mul(transmit).add(wc.mul(__tsover_mul(depthT, .18)));
+	const L = normalize(vec3f(lx, ly, -.7));
+	const ndl = dot(n, L);
+	const diffuse = __tsover_add(__tsover_mul(pow(clamp(__tsover_add(__tsover_mul(ndl, .5), .5), 0, 1), f32(.8)), .5), .5);
 	const eta = __tsover_div(1, 1.333);
-	const tDir = std.refract(d.vec3f(0, 0, 1), n, eta);
+	const tDir = refract(vec3f(0, 0, 1), n, eta);
 	const transSky = waterSky(tDir.x, tDir.y, lx, ly, envC, envS, sharp).mul(transmit);
-	const clarityT = __tsover_mul(std.clamp(clarity, 0, 1), __tsover_sub(1, __tsover_mul(depthT, .8)));
-	let body = std.mix(bodyTint, transSky.mul(.6).add(bodyTint.mul(.4)), d.vec3f(clarityT)).mul(diffuse);
+	const clarityT = __tsover_mul(clamp(clarity, 0, 1), __tsover_sub(1, __tsover_mul(depthT, .8)));
+	let body = mix(bodyTint, transSky.mul(.6).add(bodyTint.mul(.4)), vec3f(clarityT)).mul(diffuse);
 	const causFreq = causticScale;
 	const causT = __tsover_mul(animTime, 3);
-	const causP = d.vec2f(fx, fy).mul(causFreq).add(d.vec2f(__tsover_mul(std.sin(__tsover_mul(causT, .15)), .4), __tsover_mul(__tsover_mul(causT, .3), -1)));
-	const c1 = __tsover_sub(1, std.abs(waterFbm(causP)));
-	const c2 = __tsover_sub(1, std.abs(waterFbm(causP.mul(1.9).add(d.vec2f(3.7, __tsover_mul(__tsover_mul(causT, .18), -1))))));
-	const causV = std.pow(std.clamp(__tsover_add(__tsover_mul(c1, .6), __tsover_mul(c2, .4)), 0, 1), d.f32(3));
+	const causP = vec2f(fx, fy).mul(causFreq).add(vec2f(__tsover_mul(sin(__tsover_mul(causT, .15)), .4), __tsover_mul(__tsover_mul(causT, .3), -1)));
+	const c1 = __tsover_sub(1, abs(waterFbm(causP)));
+	const c2 = __tsover_sub(1, abs(waterFbm(causP.mul(1.9).add(vec2f(3.7, __tsover_mul(__tsover_mul(causT, .18), -1))))));
+	const causV = pow(clamp(__tsover_add(__tsover_mul(c1, .6), __tsover_mul(c2, .4)), 0, 1), f32(3));
 	const causMask = __tsover_mul(__tsover_add(__tsover_mul(depthT, .8), .2), caustics);
 	body = body.mul(__tsover_add(1, __tsover_mul(__tsover_mul(causV, causMask), .7)));
-	body = body.add(d.vec3f(.55, .82, 1).mul(__tsover_mul(__tsover_mul(causV, causMask), .45)));
-	const cosView = std.clamp(__tsover_mul(n.z, -1), 0, 1);
-	const fresMix = std.clamp(__tsover_add(.04, __tsover_mul(.96, std.pow(__tsover_sub(1, cosView), d.f32(5)))), 0, 1);
-	let surface = std.mix(body, reflCol, d.vec3f(fresMix));
-	const H = std.normalize(L.add(d.vec3f(0, 0, -1)));
-	const ndh = std.clamp(std.dot(n, H), 0, 1);
-	const spec = __tsover_mul(std.pow(ndh, std.mix(d.f32(40), d.f32(600), sharp)), std.mix(.3, 1.3, sharp));
-	surface = surface.add(d.vec3f(1, .98, .92).mul(spec));
-	const crestH = std.clamp(__tsover_add(__tsover_mul(h0, .5), .5), 0, 1);
-	const crest = std.smoothstep(.62, .92, crestH);
-	const shore = __tsover_sub(1, std.smoothstep(0, .045, __tsover_mul(sdf, -1)));
-	const foamMask = __tsover_mul(std.clamp(__tsover_add(crest, __tsover_mul(shore, .7)), 0, 1), foam);
-	surface = std.mix(surface, d.vec3f(1, 1, 1), d.vec3f(__tsover_mul(foamMask, .85)));
-	const transition = std.smoothstep(0, 1, std.clamp(__tsover_mul(__tsover_div(__tsover_mul(sdf, -1), sharpEdge), 32), 0, 1));
-	return d.vec4f(surface.x, surface.y, surface.z, transition);
+	body = body.add(vec3f(.55, .82, 1).mul(__tsover_mul(__tsover_mul(causV, causMask), .45)));
+	const cosView = clamp(__tsover_mul(n.z, -1), 0, 1);
+	const fresMix = clamp(__tsover_add(.04, __tsover_mul(.96, pow(__tsover_sub(1, cosView), f32(5)))), 0, 1);
+	let surface = mix(body, reflCol, vec3f(fresMix));
+	const ndh = clamp(dot(n, normalize(L.add(vec3f(0, 0, -1)))), 0, 1);
+	const spec = __tsover_mul(pow(ndh, mix(f32(40), f32(600), sharp)), mix(.3, 1.3, sharp));
+	surface = surface.add(vec3f(1, .98, .92).mul(spec));
+	const crest = smoothstep(.62, .92, clamp(__tsover_add(__tsover_mul(h0, .5), .5), 0, 1));
+	const shore = __tsover_sub(1, smoothstep(0, .045, __tsover_mul(sdf, -1)));
+	const foamMask = __tsover_mul(clamp(__tsover_add(crest, __tsover_mul(shore, .7)), 0, 1), foam);
+	surface = mix(surface, vec3f(1, 1, 1), vec3f(__tsover_mul(foamMask, .85)));
+	const transition = smoothstep(0, 1, clamp(__tsover_mul(__tsover_div(__tsover_mul(sdf, -1), sharpEdge), 32), 0, 1));
+	return vec4f(surface.x, surface.y, surface.z, transition);
 }), {
 	v: 1,
 	name: void 0,
@@ -3593,8 +3586,8 @@ const waterComposite = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		std,
-		d,
+		std: std_exports,
+		d: data_exports,
 		DEG_TO_RAD,
 		waterFbm,
 		waterNoise1,

package/dist/core/{Watercolor-zo8-4Vqx.js → Watercolor-B343pgM-.js}

@@ -1,8 +1,8 @@
-import { Bt as ZERO, Gt as expr, Ht as call, J as std, Jt as vec4, Kt as floatE, Tn as d, cn as unpremultiplyAlpha, n as tgpu } from "./coords-BkIjixe_.js";
-import { a as transformColor } from "./transformations-t0d2-uSX.js";
-var hash21 = tgpu.fn([d.vec2f], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p) => {
+import { $t as vec2f, Ct as floor, Dt as min, It as sin, N as unpremultiplyAlpha, Ot as mix, Vt as data_exports, _ as floatE, an as f32, bt as dot, d as ZERO, et as src_default, g as expr, in as vec4f, nn as vec3f, nt as std_exports, p as call, pt as select, wt as fract, y as vec4 } from "./edges-BXNBKxSN.js";
+import { a as transformColor } from "./transformations-CsPUHppB.js";
+var hash21 = 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,
@@ -52,20 +52,20 @@ var hash21 = tgpu.fn([d.vec2f], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYP
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
-var vnoise = tgpu.fn([d.vec2f], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p) => {
+var vnoise = src_default.fn([vec2f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p) => {
 	"use gpu";
-	const i = std.floor(p);
-	const f = std.fract(p);
-	const u = f.mul(f).mul(d.vec2f(3, 3).sub(f.mul(2)));
+	const i = floor(p);
+	const f = fract(p);
+	const u = f.mul(f).mul(vec2f(3, 3).sub(f.mul(2)));
 	const a = hash21(i);
-	const b = hash21(i.add(d.vec2f(1, 0)));
-	const c = hash21(i.add(d.vec2f(0, 1)));
-	const dd = hash21(i.add(d.vec2f(1, 1)));
-	return std.mix(std.mix(a, b, u.x), std.mix(c, dd, u.x), u.y);
+	const b = hash21(i.add(vec2f(1, 0)));
+	const c = hash21(i.add(vec2f(0, 1)));
+	const dd = hash21(i.add(vec2f(1, 1)));
+	return mix(mix(a, b, u.x), mix(c, dd, u.x), u.y);
 }), {
 	v: 1,
 	name: void 0,
@@ -287,21 +287,21 @@ var vnoise = tgpu.fn([d.vec2f], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYP
 		]
 	},
 	externals: () => ({
-		std,
-		d,
+		std: std_exports,
+		d: data_exports,
 		hash21
 	})
 }) && $.f)({}));
-const watercolorUvBase = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, bleed, time) => {
+const watercolorUvBase = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, bleed, time) => {
 	"use gpu";
 	const t = __tsover_mul(time, .03);
-	const wob = d.vec2f(vnoise(uv.mul(5).add(d.vec2f(t, t))), vnoise(uv.mul(5).add(d.vec2f(31.4, 31.4)).add(d.vec2f(t, t)))).sub(d.vec2f(.5, .5));
-	const texel = d.vec2f(__tsover_div(1, viewport.x), __tsover_div(1, viewport.y));
+	const wob = vec2f(vnoise(uv.mul(5).add(vec2f(t, t))), vnoise(uv.mul(5).add(vec2f(31.4, 31.4)).add(vec2f(t, t)))).sub(vec2f(.5, .5));
+	const texel = vec2f(__tsover_div(1, viewport.x), __tsover_div(1, viewport.y));
 	return uv.add(wob.mul(bleed).mul(texel).mul(8));
 }), {
 	v: 1,
@@ -505,18 +505,18 @@ const watercolorUvBase = tgpu.fn([
 		"externalNames": ["d", "vnoise"]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		vnoise
 	})
 }) && $.f)({}));
-const watercolorTapUV = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uvBase, viewport, ox, oy) => {
+const watercolorTapUV = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uvBase, viewport, ox, oy) => {
 	"use gpu";
-	return d.vec2f(__tsover_add(uvBase.x, __tsover_div(ox, viewport.x)), __tsover_add(uvBase.y, __tsover_div(oy, viewport.y)));
+	return vec2f(__tsover_add(uvBase.x, __tsover_div(ox, viewport.x)), __tsover_add(uvBase.y, __tsover_div(oy, viewport.y)));
 }), {
 	v: 1,
 	name: void 0,
@@ -586,9 +586,9 @@ const watercolorTapUV = tgpu.fn([
 		]]]],
 		"externalNames": ["d"]
 	},
-	externals: () => ({ d })
+	externals: () => ({ d: data_exports })
 }) && $.f)({}));
-const watercolorGrain = tgpu.fn([d.vec2f, d.vec2f], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport) => {
+const watercolorGrain = src_default.fn([vec2f, vec2f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport) => {
 	"use gpu";
 	return vnoise(uv.mul(viewport).mul(.5));
 }), {
@@ -627,22 +627,22 @@ const watercolorGrain = tgpu.fn([d.vec2f, d.vec2f], d.f32)(/* @__PURE__ */ (($)
 	},
 	externals: () => ({ vnoise })
 }) && $.f)({}));
-const watercolorCompose = tgpu.fn([
-	d.vec3f,
-	d.vec3f,
-	d.vec3f,
-	d.vec3f,
-	d.vec3f,
-	d.vec3f,
-	d.vec3f,
-	d.vec3f,
-	d.f32,
-	d.vec4f,
-	d.vec4f,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sum0, sum1, sum2, sum3, sq0, sq1, sq2, sq3, invN, originalBleed, paperColor, paper, strength, grain) => {
+const watercolorCompose = src_default.fn([
+	vec3f,
+	vec3f,
+	vec3f,
+	vec3f,
+	vec3f,
+	vec3f,
+	vec3f,
+	vec3f,
+	f32,
+	vec4f,
+	vec4f,
+	f32,
+	f32,
+	f32
+], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sum0, sum1, sum2, sum3, sq0, sq1, sq2, sq3, invN, originalBleed, paperColor, paper, strength, grain) => {
 	"use gpu";
 	const mean0 = sum0.mul(invN);
 	const mean1 = sum1.mul(invN);
@@ -656,19 +656,18 @@ const watercolorCompose = tgpu.fn([
 	const sigma1 = __tsover_add(__tsover_add(var1.x, var1.y), var1.z);
 	const sigma2 = __tsover_add(__tsover_add(var2.x, var2.y), var2.z);
 	const sigma3 = __tsover_add(__tsover_add(var3.x, var3.y), var3.z);
-	let result = d.vec3f(mean0.x, mean0.y, mean0.z);
+	let result = vec3f(mean0.x, mean0.y, mean0.z);
 	let best = sigma0;
-	result = std.select(result, mean1, sigma1 < best);
-	best = std.min(best, sigma1);
-	result = std.select(result, mean2, sigma2 < best);
-	best = std.min(best, sigma2);
-	result = std.select(result, mean3, sigma3 < best);
-	best = std.min(best, sigma3);
-	const paperMul = std.mix(1, grain, paper);
-	const paperTint = d.vec3f(paperColor.x, paperColor.y, paperColor.z);
-	result = std.mix(result.mul(paperMul), result.mul(paperTint), d.vec3f(__tsover_mul(paper, .4)));
-	const origRgb = d.vec3f(originalBleed.x, originalBleed.y, originalBleed.z);
-	return std.mix(origRgb, result, d.vec3f(strength));
+	result = select(result, mean1, sigma1 < best);
+	best = min(best, sigma1);
+	result = select(result, mean2, sigma2 < best);
+	best = min(best, sigma2);
+	result = select(result, mean3, sigma3 < best);
+	best = min(best, sigma3);
+	const paperMul = mix(1, grain, paper);
+	const paperTint = vec3f(paperColor.x, paperColor.y, paperColor.z);
+	result = mix(result.mul(paperMul), result.mul(paperTint), vec3f(__tsover_mul(paper, .4)));
+	return mix(vec3f(originalBleed.x, originalBleed.y, originalBleed.z), result, vec3f(strength));
 }), {
 	v: 1,
 	name: void 0,
@@ -1305,8 +1304,8 @@ const watercolorCompose = tgpu.fn([
 		"externalNames": ["d", "std"]
 	},
 	externals: () => ({
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {