shaders 3.0.448 → 3.0.450

package/dist/core/{Water-D74wbHmn.js → Water-DfwGqSnM.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, Dt as length, Ft as refract, Mt as pow, Ot as max, Pt as reflect, Rt as sin, St as dot, Ut as data_exports, _ as floatE, bt as cos, et as src_default, ht as abs, 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 { 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,