incanto 0.14.0 → 0.16.0

package/dist/{register-C9-16x_t.js → register-Lp2qn1Wq.js}

@@ -10269,6 +10269,120 @@ void main() {
 }
 `;
 //#endregion
+//#region src/3d/water/caustics.ts
+/**
+* Underwater caustics — the dancing refracted-light pattern the water surface
+* throws onto everything below it. The engine has no post-processing pipeline,
+* so the renderer does this as ONE depth-aware composite pass, and ONLY while
+* the camera is genuinely underwater (so normal above-water rendering — even
+* standing at the water's edge — is completely untouched):
+*
+*   1. render the scene to an offscreen target (color + depth)
+*   2. draw this fullscreen material, which reconstructs each pixel's WORLD
+*      position from the depth buffer and adds an animated caustic highlight
+*      wherever that world point sits below the water surface
+*
+* Because the pattern is keyed to reconstructed world XZ, it STICKS to the
+* floor/walls/props (it isn't a flat screen overlay) and fades with depth +
+* view distance so it melts into the underwater fog.
+*/
+/** Fullscreen triangle/quad — the vertex stage ignores the camera entirely. */
+const CAUSTICS_VERT = `
+varying vec2 vUv;
+void main() {
+  vUv = uv;
+  gl_Position = vec4(position.xy, 0.0, 1.0);
+}
+`;
+/**
+* The classic animated caustic pattern (layered moving cells), 0..1 — SHARED
+* between the underwater composite and Water3D's above-water caustics (the
+* refracted bottom shimmer), so both views of the same water agree.
+*/
+const CAUSTIC_GLSL = `
+float caustic(vec2 uv, float t) {
+  vec2 p = mod(uv * 6.28318, 6.28318) - 250.0;
+  vec2 i = p;
+  float c = 1.0;
+  float inten = 0.005;
+  for (int n = 0; n < 5; n++) {
+    float ti = t * (1.0 - (3.5 / float(n + 1)));
+    i = p + vec2(cos(ti - i.x) + sin(ti + i.y), sin(ti - i.y) + cos(ti + i.x));
+    c += 1.0 / length(vec2(p.x / (sin(i.x + ti) / inten), p.y / (cos(i.y + ti) / inten)));
+  }
+  c /= 5.0;
+  c = 1.17 - pow(c, 1.4);
+  return clamp(pow(abs(c), 8.0), 0.0, 1.0);
+}
+`;
+const CAUSTICS_FRAG = `
+precision highp float;
+varying vec2 vUv;
+uniform sampler2D tColor;
+uniform sampler2D tDepth;
+uniform mat4 uInvViewProj;
+uniform vec3 uCameraPos;
+uniform float uWaterLevel;
+uniform float uTime;
+uniform vec3 uCausticColor;
+uniform float uCausticIntensity;
+uniform float uCausticScale;
+uniform float uMaxDist;
+
+${CAUSTIC_GLSL}
+
+void main() {
+  vec4 color = texture2D(tColor, vUv);
+  float depth = texture2D(tDepth, vUv).x;
+  // depth == 1 is the far plane (sky/background) — nothing to light there
+  if (depth < 1.0) {
+    vec4 ndc = vec4(vUv * 2.0 - 1.0, depth * 2.0 - 1.0, 1.0);
+    vec4 world = uInvViewProj * ndc;
+    world.xyz /= world.w;
+    float below = uWaterLevel - world.y;
+    if (below > 0.0) {
+      float dist = distance(world.xyz, uCameraPos);
+      // caustics — fade with distance (melt into the fog) + a touch with depth
+      float distFade = 1.0 - clamp(dist / uMaxDist, 0.0, 1.0);
+      float depthFade = 1.0 - clamp(below / (uMaxDist * 0.5), 0.0, 0.6);
+      // two octaves at offset speeds = the shimmering interference of real caustics
+      float c =
+        caustic(world.xz * uCausticScale, uTime) * 0.65 +
+        caustic(world.xz * uCausticScale * 1.7 + 30.0, uTime * 0.8) * 0.35;
+      color.rgb += uCausticColor * (c * uCausticIntensity * distFade * distFade * depthFade);
+    }
+  }
+  gl_FragColor = color;
+}
+`;
+/** Build the fullscreen composite mesh (a 2×2 clip-space quad). */
+function createCausticsQuad() {
+	const material = new ShaderMaterial({
+		vertexShader: CAUSTICS_VERT,
+		fragmentShader: CAUSTICS_FRAG,
+		depthTest: false,
+		depthWrite: false,
+		uniforms: {
+			tColor: { value: null },
+			tDepth: { value: null },
+			uInvViewProj: { value: new Matrix4() },
+			uCameraPos: { value: new Vector3() },
+			uWaterLevel: { value: 0 },
+			uTime: { value: 0 },
+			uCausticColor: { value: new Color("#cdeeff") },
+			uCausticIntensity: { value: .55 },
+			uCausticScale: { value: .32 },
+			uMaxDist: { value: 22 }
+		}
+	});
+	const mesh = new Mesh(new PlaneGeometry(2, 2), material);
+	mesh.frustumCulled = false;
+	return {
+		mesh,
+		uniforms: material.uniforms
+	};
+}
+//#endregion
 //#region src/3d/water/shaders.ts
 /**
 * The Water3D 'fancy' shaders — ported VERBATIM from
@@ -10344,6 +10458,11 @@ uniform vec3 uScale;
 // incanto: world-anchor + interaction ripples (x, z, age, amplitude)
 uniform vec3 uWaterCenter;
 uniform vec4 uRipples[8];
+// incanto swell: directional traveling wave trains (0 = off — legacy look).
+// uSwellDir is a unit XZ vector; amplitude in meters; wavelength in meters.
+uniform float uSwellAmplitude;
+uniform vec2 uSwellDir;
+uniform float uSwellWavelength;
 
 varying vec3 vNormal;
 varying vec3 vWorldPosition;
@@ -10426,10 +10545,34 @@ float getRippleHeight(vec2 p) {
   return h;
 }
 
-// incanto: waves + ripples — used for displacement AND the normal samples
-// so interaction rings catch the light like real waves.
+// incanto swell: one peaked traveling wave train. Deep-water dispersion
+// (c = sqrt(g/k)) gives each wavelength its REAL speed, so short chop
+// overtakes long swell exactly like the open sea. The pow-shaped profile
+// sharpens crests and flattens troughs (a height-only Gerstner stand-in —
+// no XZ pinch, so the analytic finite-difference normals stay exact).
+float swellWave(vec2 p, vec2 dir, float lambda, float amp, float sharp) {
+  float k = 6.2831853 / max(lambda, 1.0);
+  float c = sqrt(9.8 / k);
+  float s = 0.5 + 0.5 * sin(dot(p, dir) * k - uTime * c * k);
+  return amp * (pow(s, sharp) * 2.0 - 1.0);
+}
+
+// incanto swell: three trains — the primary + two shorter crossing sets
+// (+25° / −19°) so crest lines stay broken and organic, never a zebra field.
+float getSwell(vec2 p) {
+  if (uSwellAmplitude <= 0.0) return 0.0;
+  vec2 d1 = uSwellDir;
+  vec2 d2 = normalize(vec2(d1.x * 0.906 - d1.y * 0.423, d1.x * 0.423 + d1.y * 0.906));
+  vec2 d3 = normalize(vec2(d1.x * 0.946 + d1.y * 0.326, -d1.x * 0.326 + d1.y * 0.946));
+  return swellWave(p, d1, uSwellWavelength,        uSwellAmplitude * 0.60, 2.6)
+       + swellWave(p, d2, uSwellWavelength * 0.53, uSwellAmplitude * 0.27, 2.2)
+       + swellWave(p, d3, uSwellWavelength * 0.31, uSwellAmplitude * 0.16, 1.8);
+}
+
+// incanto: waves + swell + ripples — used for displacement AND the normal
+// samples so every layer catches the light like real waves.
 float getHeight(float x, float z) {
-  return getElevation(x, z) + getRippleHeight(vec2(x, z));
+  return getElevation(x, z) + getSwell(vec2(x, z)) + getRippleHeight(vec2(x, z));
 }
 
 void main() {
@@ -10538,6 +10681,25 @@ uniform vec4 uRipples[8];
 uniform float uRippleFoam[8];
 uniform float uSplashFoam;
 
+// incanto swell: open-water WHITECAPS — foam breaking on the highest crests,
+// independent of the shoreline depth mask. uWaveEnvelope is the JS-computed
+// total wave amplitude (FBM + swell) so the crest mask normalizes by the
+// actual sea state, not the surface's extent. uSwellAmplitude gates the
+// swell-only color work (crest banding + wave-face shading).
+uniform float uWhitecaps;
+uniform float uWaveEnvelope;
+uniform float uSwellAmplitude;
+
+// incanto presets: above-water CAUSTICS — the dancing light web on the
+// submerged bottom, seen THROUGH the surface (the pool/shallow-sea look).
+// Intensity 0 = off. The pattern fn is shared with the underwater composite.
+uniform float uCausticsAbove;
+// incanto presets: per-preset reflection ceiling (the old hard 0.6) — lakes
+// push toward mirror, pools stay glassy-clear.
+uniform float uReflectivityMax;
+
+${CAUSTIC_GLSL}
+
 // 🎨 Contact surface color customization uniforms
 uniform vec3 uEdgeColor;
 uniform float uEdgeIntensity;
@@ -10924,6 +11086,24 @@ void main() {
   // Mix between surface and peak colors based on peak transition
   vec3 mixedColor2 = mix(mixedColor1, uPeakColor, peakFactor);
 
+  // incanto swell: the legacy ramp normalizes elevation by the surface's
+  // HALF-EXTENT — on a real ocean plane that's hundreds of meters, so the
+  // ramp never sees a wave. When swell is on, re-read the crest height
+  // against the actual sea state (uWaveEnvelope) and (a) lighten crest tops
+  // toward the peak color, (b) shade the wave FACES with a gentle N·L off
+  // the distance-smoothed geometry normal — the lit/shadow lanes are what
+  // make open-ocean swell READ at any distance. Both gated: swell 0 keeps
+  // the legacy look byte-identical.
+  if (uSwellAmplitude > 0.0) {
+    float crestBand = smoothstep(0.3, 0.9,
+      (vWorldPosition.y - uWaterCenter.y) / max(uWaveEnvelope, 0.001));
+    mixedColor2 = mix(mixedColor2, uPeakColor, crestBand * 0.45);
+    float faceShade = clamp(dot(normalize(mix(vec3(0.0, 1.0, 0.0), normalize(vNormal),
+      1.0 - 0.9 * smoothstep(150.0, 600.0, length(vWorldPosition - cameraPosition)))),
+      normalize(uSunDirection)), 0.0, 1.0);
+    mixedColor2 *= 0.80 + 0.32 * faceShade;
+  }
+
   // incanto v2: Beer's-law depth absorption + screen-space refraction.
   // Shallow water transmits the (refracted) scene almost untouched; depth
   // exponentially absorbs it into the ramp color — clear turquoise edges,
@@ -10975,6 +11155,22 @@ void main() {
       // underwater scene. Real water blurs what it refracts; the crisp
       // half-res grab pixel-speckled at every silhouette and ripple edge.
       vec3 sceneColor = texture2D(uSceneColor, refractedUV, 1.75).rgb;
+      // incanto presets: above-water caustics — reconstruct the sampled
+      // bottom's world position along the view ray and light it with the
+      // shared caustic web. Strongest through the first meters of water
+      // (a pool floor dances, the deep sea does not), distance-faded so far
+      // shallows never shimmer-alias.
+      if (uCausticsAbove > 0.0) {
+        vec3 bottomWorld = cameraPosition + viewDirection * refrT;
+        float below = uWaterCenter.y - bottomWorld.y;
+        if (below > 0.05) {
+          float reach = 1.0 - smoothstep(0.2, 9.0, below);
+          float causticFade = 1.0 - smoothstep(60.0, 200.0, camDist);
+          float cw = caustic(bottomWorld.xz * 0.42, uTime * 0.7) * 0.65
+                   + caustic(bottomWorld.xz * 0.72 + 30.0, uTime * 0.55) * 0.35;
+          sceneColor += vec3(0.87, 0.96, 1.0) * (cw * uCausticsAbove * reach * causticFade);
+        }
+      }
       // opacity keeps its dial under in-shader compositing: it scales how
       // strongly the water body hides the Beer-attenuated scene behind it —
       // per channel, so the shallows tint instead of fading uniformly
@@ -11015,7 +11211,7 @@ void main() {
   // mirror (dark scenes otherwise paint the near edge black). refinement
   // pass: 0.75 → 0.6 — the reference sea stays teal even at range; an HDR
   // sky at 3/4 mirror washed the whole far field toward white.
-  float reflectivity = clamp(fresnel, 0.0, 0.6) * uUseEnvironmentMap;
+  float reflectivity = clamp(fresnel, 0.0, uReflectivityMax) * uUseEnvironmentMap;
   vec3 finalColor = mix(bodyColor, reflectionColor.rgb, reflectivity);
 
   // incanto v2: sun specular off the detail-perturbed normal.
@@ -11060,6 +11256,22 @@ void main() {
   if (uEnableFoam > 0.5) {
     foamAmount = calculateFoam();
   }
+  // incanto swell: whitecaps — foam eats the TOPS of the tallest crests in
+  // open water. The crest mask normalizes elevation by the real wave envelope
+  // (uScale.y is the surface's half-extent — useless as a sea-state yardstick
+  // on a big ocean plane), and a two-octave noise breaks the caps into
+  // patches that live and die with the crests. Distance-faded: far whitecaps
+  // subtend under a pixel and would alias into horizon speckle.
+  if (uWhitecaps > 0.0 && uWaveEnvelope > 0.001) {
+    float crestN = (vWorldPosition.y - uWaterCenter.y) / uWaveEnvelope;
+    float cap = smoothstep(0.5, 0.85, crestN);
+    vec2 capUV = vWorldPosition.xz * 0.3;
+    float capNoise = noise(capUV * 2.2 + uTime * vec2(0.10, 0.06)) * 0.65
+                   + noise(capUV * 6.5 - uTime * vec2(0.05, 0.14)) * 0.35;
+    float capFade = 1.0 - smoothstep(220.0, 640.0, camDist);
+    float whitecap = uWhitecaps * cap * smoothstep(0.42, 0.78, capNoise) * capFade;
+    foamAmount = max(foamAmount, whitecap);
+  }
   // incanto: splash/wake whitewater rides the ripple buffer, INDEPENDENT of the
   // depth-foam gate so it works even on shallow ponds / before the first pre-pass
   float splashFoam = rippleFoam(vWorldPosition.xz);
@@ -11322,6 +11534,108 @@ const COLOR_KEYS = [
 	"surface",
 	"peak"
 ];
+const WATER_PRESET_NAMES = [
+	"custom",
+	"ocean",
+	"pool",
+	"lake",
+	"pond"
+];
+/**
+* The four curated water types — `preset: 'ocean' | 'pool' | 'lake' | 'pond'`
+* is THE one-choice dial: each bundle sets every wave/color/clarity/caustics
+* knob to a hand-tuned sea state. A preset value applies ONLY while the prop
+* still sits at its schema default (same convention as the env-sun handoff),
+* so any explicitly authored prop wins — pick the type, then override details
+* to taste.
+*
+* - ocean: traveling swell + whitecaps, wide turquoise→deep-blue absorption
+* - pool:  near-flat crystal water, strong above-water caustics on the floor
+* - lake:  calm mirror — high reflectivity, murkier green-teal depths
+* - pond:  still, mossy, opaque quickly — the garden pond
+*/
+const WATER_PRESETS = {
+	ocean: {
+		waveHeight: .06,
+		swell: .55,
+		swellWavelength: 42,
+		whitecaps: .45,
+		absorption: .2,
+		opacity: .85,
+		detailStrength: .3,
+		colors: {
+			trough: "#0c3d58",
+			surface: "#1a7d9c",
+			peak: "#9adfe0"
+		},
+		color: "#1a7d9c",
+		causticsAbove: .35,
+		reflectionInterval: 400
+	},
+	pool: {
+		waveHeight: .006,
+		swell: 0,
+		whitecaps: 0,
+		absorption: .3,
+		opacity: .5,
+		detailStrength: .16,
+		sunIntensity: 1.25,
+		colors: {
+			trough: "#1e8dbe",
+			surface: "#3fb6dc",
+			peak: "#bdeef7"
+		},
+		color: "#3fb6dc",
+		causticsAbove: 1,
+		reflectionInterval: 600,
+		_look: {
+			fresnelScale: .85,
+			reflectivityMax: .5
+		}
+	},
+	lake: {
+		waveHeight: .028,
+		swell: .14,
+		swellWavelength: 24,
+		whitecaps: 0,
+		absorption: .5,
+		opacity: .88,
+		detailStrength: .3,
+		colors: {
+			trough: "#12343a",
+			surface: "#25565c",
+			peak: "#7fb2ab"
+		},
+		color: "#25565c",
+		causticsAbove: .15,
+		reflectionInterval: 300,
+		_look: {
+			fresnelScale: 1.25,
+			reflectivityMax: .78
+		}
+	},
+	pond: {
+		waveHeight: .012,
+		swell: 0,
+		whitecaps: 0,
+		absorption: .55,
+		opacity: .88,
+		detailStrength: .2,
+		sunIntensity: .9,
+		colors: {
+			trough: "#24402a",
+			surface: "#436b4d",
+			peak: "#8fae8e"
+		},
+		color: "#436b4d",
+		causticsAbove: .2,
+		reflectionInterval: 800,
+		_look: {
+			fresnelScale: 1.1,
+			reflectivityMax: .68
+		}
+	}
+};
 /** Refinement-pass palette — teal-leaning sea blues sampled off the reference
 * calm sea (deep open water ≈ #2b7993, mid teal ≈ #16878a). The old ported
 * palette (#1f5b8a/#52a0d0/#aee3ff) read as saturated pool blue. */
@@ -11469,7 +11783,16 @@ var Water3D = class Water3D extends Node3D {
 		detailStrength: { default: .26 },
 		absorption: { default: .15 },
 		refraction: { default: true },
-		underwater: { default: true }
+		underwater: { default: true },
+		swell: { default: 0 },
+		swellDirectionDeg: { default: 0 },
+		swellWavelength: { default: 30 },
+		whitecaps: { default: 0 },
+		preset: {
+			default: "custom",
+			options: WATER_PRESET_NAMES
+		},
+		causticsAbove: { default: 0 }
 	};
 	/** [width, depth] in meters (the surface lies on XZ). */
 	size = [40, 40];
@@ -11524,6 +11847,55 @@ var Water3D = class Water3D extends Node3D {
 	* `{ color?, visibility? }` overrides the fog hue / view distance (meters).
 	*/
 	underwater = true;
+	/**
+	* Directional traveling SWELL amplitude in meters (fancy only; 0 = off, the
+	* legacy isotropic look). Three peaked wave trains march across the surface
+	* at real deep-water speeds — THE open-ocean dial: 0.15 = lively lake chop,
+	* 0.4 = coastal sea, 0.8 = heavy weather. Crests feed the color ramp,
+	* `whitecaps` and the shore foam automatically.
+	*/
+	swell = 0;
+	/** Compass direction the swell TRAVELS toward, degrees (0 = +z, 90 = +x). */
+	swellDirectionDeg = 0;
+	/** Primary swell wavelength in meters (the two crossing trains derive). */
+	swellWavelength = 30;
+	/** Open-water whitecap foam on the tallest crests, 0–1 (fancy only). Works
+	* best with `swell` — the caps ride the swell's crest lines. */
+	whitecaps = 0;
+	/**
+	* THE one-choice water type: 'ocean' | 'pool' | 'lake' | 'pond' bundles
+	* every wave/color/clarity/caustics knob into a hand-tuned sea state
+	* ('custom', the default, changes nothing). A preset value applies ONLY
+	* where a prop still sits at its schema default — set the type first, then
+	* override any detail prop to taste and your value wins.
+	*/
+	preset = "custom";
+	/**
+	* Above-water CAUSTICS intensity (0 = off): the dancing light web on the
+	* submerged bottom, seen THROUGH the surface — the pool / tropical-shallows
+	* look. Needs `refraction` (fancy quality). Presets set it; override freely.
+	*/
+	causticsAbove = 0;
+	/** Preset-layered prop read (see {@link WATER_PRESETS}): the preset value
+	* applies only while the prop sits at its schema default. */
+	rp(key) {
+		const bundle = WATER_PRESETS[this.preset];
+		const self = this;
+		if (bundle && key in bundle) {
+			const def = Water3D.props[key]?.default;
+			const cur = self[key];
+			if (typeof cur === "object" && cur !== null ? JSON.stringify(cur) === JSON.stringify(def) : cur === def) return bundle[key];
+		}
+		return self[key];
+	}
+	/** Per-preset internal look constants (fresnel curve, reflection ceiling). */
+	presetLook() {
+		const look = WATER_PRESETS[this.preset]?._look;
+		return {
+			fresnelScale: look?.fresnelScale ?? FANCY_LOOK.fresnelScale,
+			reflectivityMax: look?.reflectivityMax ?? .6
+		};
+	}
 	/** Loader hook: degenerate planes and bad enums fail at LOAD, not at render. */
 	static validateJson(node) {
 		const w = node;
@@ -11545,6 +11917,14 @@ var Water3D = class Water3D extends Node3D {
 		if (!(w.sunIntensity >= 0)) throw new IncantoError("BAD_FORMAT", `Water3D '${node.name}' sunIntensity must be >= 0, got ${w.sunIntensity}.`, { prop: "sunIntensity" });
 		if (!(w.detailStrength >= 0)) throw new IncantoError("BAD_FORMAT", `Water3D '${node.name}' detailStrength must be >= 0, got ${w.detailStrength}.`, { prop: "detailStrength" });
 		if (!(w.absorption >= 0)) throw new IncantoError("BAD_FORMAT", `Water3D '${node.name}' absorption must be >= 0 (per-meter Beer's-law constant), got ${w.absorption}.`, { prop: "absorption" });
+		if (!(w.swell >= 0) || !Number.isFinite(w.swell)) throw new IncantoError("BAD_FORMAT", `Water3D '${node.name}' swell must be >= 0 meters (0 = off), got ${JSON.stringify(w.swell)}.`, { prop: "swell" });
+		if (!(w.swellWavelength >= 2)) throw new IncantoError("BAD_FORMAT", `Water3D '${node.name}' swellWavelength must be >= 2 meters, got ${JSON.stringify(w.swellWavelength)}.`, { prop: "swellWavelength" });
+		if (!(w.whitecaps >= 0) || !(w.whitecaps <= 1)) throw new IncantoError("BAD_FORMAT", `Water3D '${node.name}' whitecaps must be in [0, 1], got ${JSON.stringify(w.whitecaps)}.`, { prop: "whitecaps" });
+		if (!WATER_PRESET_NAMES.includes(w.preset)) throw new IncantoError("BAD_FORMAT", `Water3D '${node.name}' preset must be one of [${WATER_PRESET_NAMES.join(", ")}], got '${w.preset}'.`, {
+			prop: "preset",
+			validOptions: WATER_PRESET_NAMES
+		});
+		if (!(w.causticsAbove >= 0) || !(w.causticsAbove <= 3)) throw new IncantoError("BAD_FORMAT", `Water3D '${node.name}' causticsAbove must be in [0, 3] (0 = off), got ${JSON.stringify(w.causticsAbove)}.`, { prop: "causticsAbove" });
 		const uw = w.underwater;
 		if (typeof uw !== "boolean") {
 			if (typeof uw !== "object" || uw === null || Array.isArray(uw)) throw new IncantoError("BAD_FORMAT", `Water3D '${node.name}' underwater must be true, false or an object ({ color?, visibility? }), got ${JSON.stringify(uw)}.`, { prop: "underwater" });
@@ -11624,7 +12004,7 @@ var Water3D = class Water3D extends Node3D {
 				this.cubeCamera = new CubeCamera(near, 1e3, this.cubeTarget);
 				this.lastReflectionAt = 0;
 			}
-			if (this.lastReflectionAt === 0 || now - this.lastReflectionAt >= this.reflectionInterval) {
+			if (this.lastReflectionAt === 0 || now - this.lastReflectionAt >= this.rp("reflectionInterval")) {
 				this.lastReflectionAt = now;
 				const center = worldTranslationOf(this);
 				const cam = this.cubeCamera;
@@ -11711,7 +12091,7 @@ var Water3D = class Water3D extends Node3D {
 			halfW: (this.size[0] ?? 1) / 2,
 			halfD: (this.size[1] ?? 1) / 2
 		}, UNDERWATER_MARGIN)) return null;
-		const cfg = resolveUnderwater(this.underwater, this.color);
+		const cfg = resolveUnderwater(this.underwater, this.rp("color"));
 		return cfg.enabled ? {
 			...cfg,
 			surfaceY: center.y
@@ -11757,10 +12137,10 @@ var Water3D = class Water3D extends Node3D {
 				fogFar: { value: 1e3 },
 				fogDensity: { value: 25e-5 },
 				uTime: { value: 0 },
-				uOpacity: { value: this.opacity },
+				uOpacity: { value: this.rp("opacity") },
 				uEnvironmentMap: { value: null },
 				uUseEnvironmentMap: { value: 0 },
-				uWavesAmplitude: { value: this.waveHeight * AMPLITUDE_PER_WAVE_HEIGHT },
+				uWavesAmplitude: { value: this.rp("waveHeight") * AMPLITUDE_PER_WAVE_HEIGHT },
 				uWavesSpeed: { value: FANCY_WAVE.speed },
 				uWavesFrequency: { value: FANCY_WAVE.frequency },
 				uWavesPersistence: { value: FANCY_WAVE.persistence },
@@ -11782,9 +12162,9 @@ var Water3D = class Water3D extends Node3D {
 				uSplashFoam: { value: this.splash ? 1 : 0 },
 				uSunDirection: { value: new Vector3(.5, .8, .3) },
 				uSunColor: { value: new Color(this.sunColor) },
-				uSunIntensity: { value: this.sunIntensity },
-				uDetailStrength: { value: this.detailStrength },
-				uAbsorption: { value: this.absorption },
+				uSunIntensity: { value: this.rp("sunIntensity") },
+				uDetailStrength: { value: this.rp("detailStrength") },
+				uAbsorption: { value: this.rp("absorption") },
 				uUseSceneDepth: { value: 0 },
 				uUseRefraction: { value: 0 },
 				uSceneColor: { value: null },
@@ -11798,7 +12178,14 @@ var Water3D = class Water3D extends Node3D {
 				uCameraFar: { value: 1e3 },
 				uEdgeColor: { value: new Color(FOAM_LOOK.edgeColor) },
 				uEdgeIntensity: { value: FOAM_LOOK.edgeIntensity },
-				uEdgeWidth: { value: FOAM_LOOK.edgeWidth }
+				uEdgeWidth: { value: FOAM_LOOK.edgeWidth },
+				uSwellAmplitude: { value: this.rp("swell") },
+				uSwellDir: { value: new Vector2(0, 1) },
+				uSwellWavelength: { value: this.rp("swellWavelength") },
+				uWhitecaps: { value: this.rp("whitecaps") },
+				uWaveEnvelope: { value: 0 },
+				uCausticsAbove: { value: this.rp("causticsAbove") },
+				uReflectivityMax: { value: .6 }
 			},
 			transparent: true,
 			depthTest: true,
@@ -11819,14 +12206,14 @@ var Water3D = class Water3D extends Node3D {
 				fogFar: { value: 1e3 },
 				fogDensity: { value: 25e-5 },
 				uTime: { value: 0 },
-				uOpacity: { value: this.opacity },
-				uColor: { value: new Color(this.color) },
-				uSurfaceColor: { value: new Color(this.color) },
-				uSkyColor: { value: new Color(this.color) },
+				uOpacity: { value: this.rp("opacity") },
+				uColor: { value: new Color(this.rp("color")) },
+				uSurfaceColor: { value: new Color(this.rp("color")) },
+				uSkyColor: { value: new Color(this.rp("color")) },
 				uSunDirection: { value: new Vector3(.5, .8, .3).normalize() },
 				uSunColor: { value: new Color(this.sunColor) },
-				uSunIntensity: { value: this.sunIntensity },
-				uDetailStrength: { value: this.detailStrength },
+				uSunIntensity: { value: this.rp("sunIntensity") },
+				uDetailStrength: { value: this.rp("detailStrength") },
 				uFresnelPower: { value: FANCY_LOOK.fresnelPower },
 				uScale: { value: new Vector3(1, 1, 1) },
 				uWaterCenter: { value: new Vector3() },
@@ -11847,8 +12234,8 @@ var Water3D = class Water3D extends Node3D {
 		const d = this.size[1] ?? 1;
 		const center = worldTranslationOf(this);
 		if (u.uTime) u.uTime.value = this.time;
-		if (u.uOpacity) u.uOpacity.value = this.opacity;
-		if (u.uWavesAmplitude) u.uWavesAmplitude.value = this.waveHeight * AMPLITUDE_PER_WAVE_HEIGHT;
+		if (u.uOpacity) u.uOpacity.value = this.rp("opacity");
+		if (u.uWavesAmplitude) u.uWavesAmplitude.value = this.rp("waveHeight") * AMPLITUDE_PER_WAVE_HEIGHT;
 		(u.uScale?.value)?.set(w / 2, d / 2, d / 2);
 		(u.uWaterCenter?.value)?.set(center.x, center.y, center.z);
 		const palette = this.resolvePalette();
@@ -11857,9 +12244,19 @@ var Water3D = class Water3D extends Node3D {
 		(u.uPeakColor?.value)?.copy(palette.peak);
 		(u.uSunDirection?.value)?.set(this.sunDirection[0] ?? 0, this.sunDirection[1] ?? 1, this.sunDirection[2] ?? 0).normalize();
 		(u.uSunColor?.value)?.set(this.sunColor);
-		if (u.uSunIntensity) u.uSunIntensity.value = this.sunIntensity;
-		if (u.uDetailStrength) u.uDetailStrength.value = this.detailStrength;
-		if (u.uAbsorption) u.uAbsorption.value = this.absorption;
+		if (u.uSunIntensity) u.uSunIntensity.value = this.rp("sunIntensity");
+		if (u.uDetailStrength) u.uDetailStrength.value = this.rp("detailStrength");
+		if (u.uAbsorption) u.uAbsorption.value = this.rp("absorption");
+		if (u.uSwellAmplitude) u.uSwellAmplitude.value = this.rp("swell");
+		if (u.uSwellWavelength) u.uSwellWavelength.value = this.rp("swellWavelength");
+		if (u.uWhitecaps) u.uWhitecaps.value = this.rp("whitecaps");
+		if (u.uCausticsAbove) u.uCausticsAbove.value = this.rp("causticsAbove");
+		const look = this.presetLook();
+		if (u.uFresnelScale) u.uFresnelScale.value = look.fresnelScale;
+		if (u.uReflectivityMax) u.uReflectivityMax.value = look.reflectivityMax;
+		const swellRad = this.swellDirectionDeg * Math.PI / 180;
+		(u.uSwellDir?.value)?.set(Math.sin(swellRad), Math.cos(swellRad));
+		if (u.uWaveEnvelope) u.uWaveEnvelope.value = this.rp("waveHeight") * AMPLITUDE_PER_WAVE_HEIGHT * 1.5 + this.rp("swell") * 1.03;
 		if (!this.reflection && u.uUseEnvironmentMap) u.uUseEnvironmentMap.value = 0;
 		if (!this.foam && u.uEnableFoam) u.uEnableFoam.value = 0;
 		if (!this.refraction && u.uUseRefraction) u.uUseRefraction.value = 0;
@@ -11887,8 +12284,9 @@ var Water3D = class Water3D extends Node3D {
 	}
 	/** The fancy three-color ramp; a customized legacy `color` tints it. */
 	resolvePalette() {
-		const overrides = this.colors;
-		const legacyTint = this.color !== Water3D.props.color?.default ? this.color : null;
+		const overrides = this.rp("colors");
+		const tint = this.rp("color");
+		const legacyTint = tint !== Water3D.props.color?.default ? tint : null;
 		const surface = overrides.surface ?? legacyTint ?? FANCY_COLORS.surface;
 		paletteScratch.surface.set(surface);
 		if (overrides.trough) paletteScratch.trough.set(overrides.trough);
@@ -11901,22 +12299,22 @@ var Water3D = class Water3D extends Node3D {
 	}
 	syncSimple(mesh) {
 		const mat = mesh.material;
-		mat.opacity = this.opacity;
+		mat.opacity = this.rp("opacity");
 		const u = mat.uniforms;
 		const w = this.size[0] ?? 1;
 		const d = this.size[1] ?? 1;
 		const center = worldTranslationOf(this, this._scratchA);
 		if (u.uTime) u.uTime.value = this.time;
-		if (u.uOpacity) u.uOpacity.value = this.opacity;
-		(u.uSurfaceColor?.value)?.set(this.color).lerp(WHITE, .12);
-		(u.uColor?.value)?.set(this.color).lerp(BLACK, .4);
-		(u.uSkyColor?.value)?.set(this.color).lerp(SKY_PALE, .82);
+		if (u.uOpacity) u.uOpacity.value = this.rp("opacity");
+		(u.uSurfaceColor?.value)?.set(this.rp("color")).lerp(WHITE, .12);
+		(u.uColor?.value)?.set(this.rp("color")).lerp(BLACK, .4);
+		(u.uSkyColor?.value)?.set(this.rp("color")).lerp(SKY_PALE, .82);
 		(u.uScale?.value)?.set(w / 2, d / 2, d / 2);
 		(u.uWaterCenter?.value)?.set(center.x, center.y, center.z);
 		(u.uSunDirection?.value)?.set(this.sunDirection[0] ?? 0, this.sunDirection[1] ?? 1, this.sunDirection[2] ?? 0).normalize();
 		(u.uSunColor?.value)?.set(this.sunColor);
-		if (u.uSunIntensity) u.uSunIntensity.value = this.sunIntensity;
-		if (u.uDetailStrength) u.uDetailStrength.value = this.detailStrength;
+		if (u.uSunIntensity) u.uSunIntensity.value = this.rp("sunIntensity");
+		if (u.uDetailStrength) u.uDetailStrength.value = this.rp("detailStrength");
 		if (u.uSplashFoam) u.uSplashFoam.value = this.splash ? 1 : 0;
 		const uRip = u.uRipples?.value;
 		const uFoam = u.uRippleFoam?.value;
@@ -11930,7 +12328,7 @@ var Water3D = class Water3D extends Node3D {
 		const pos = geo.getAttribute("position");
 		const norm = geo.getAttribute("normal");
 		const t = this.time;
-		const wh = this.waveHeight;
+		const wh = this.rp("waveHeight");
 		const cx = center.x;
 		const cz = center.z;
 		const ripples = this._ripples;
@@ -12014,9 +12412,9 @@ var Water3D = class Water3D extends Node3D {
 	/** Base wave height at world (x, z) — the CPU twin of the active shader.
 	* Ripples are excluded on purpose: a splash must not re-trigger itself. */
 	waveOffsetAt(x, z, center) {
-		if (this.quality === "simple") return simpleWaveHeight(x - center.x, z - center.z, this.time, this.waveHeight);
+		if (this.quality === "simple") return simpleWaveHeight(x - center.x, z - center.z, this.time, this.rp("waveHeight"));
 		return waveElevation(x, z, this.time, {
-			amplitude: this.waveHeight * AMPLITUDE_PER_WAVE_HEIGHT,
+			amplitude: this.rp("waveHeight") * AMPLITUDE_PER_WAVE_HEIGHT,
 			frequency: FANCY_WAVE.frequency,
 			persistence: FANCY_WAVE.persistence,
 			lacunarity: FANCY_WAVE.lacunarity,
@@ -12136,4 +12534,4 @@ function registerNodes3D() {
 	registerNode(CharacterBody3D);
 }
 //#endregion
-export { Area3D as A, movementState as B, BoneAttachment3D as C, TERRAIN_THEMES as D, DEFAULT_TERRAIN_TEXTURE_BASE as E, Node3D as F, validateCollider3D as I, QUARTER_PITCH as L, PhysicsBody3D as M, RigidBody3D as N, terrainThemeLayers as O, StaticBody3D as P, cameraRelative as R, BoneLookAt3D as S, Terrain3D as T, rigPose as V, Flowers3D as _, VoxelGrid3D as a, CharacterController3D as b, Particles3D as c, DirectionalLight3D as d, OmniLight3D as f, DENSITY_PRESETS as g, Foliage3D as h, VOXEL_PALETTE as i, CharacterBody3D as j, Joint3D as k, ModelInstance3D as l, MeshInstance3D as m, Water3D as n, Tree3D as o, InstancedMesh3D as p, WATER_MAX_RIPPLES as r, Trail3D as s, registerNodes3D as t, LoftMesh3D as u, resolveFlowerDensity as v, Billboard3D as w, Camera3D as x, FLOWER_VARIETIES as y, keyboardIntensity as z };
+export { Joint3D as A, keyboardIntensity as B, BoneLookAt3D as C, DEFAULT_TERRAIN_TEXTURE_BASE as D, Terrain3D as E, StaticBody3D as F, rigPose as H, Node3D as I, validateCollider3D as L, CharacterBody3D as M, PhysicsBody3D as N, TERRAIN_THEMES as O, RigidBody3D as P, QUARTER_PITCH as R, Camera3D as S, Billboard3D as T, movementState as V, DENSITY_PRESETS as _, VOXEL_PALETTE as a, FLOWER_VARIETIES as b, Trail3D as c, LoftMesh3D as d, DirectionalLight3D as f, Foliage3D as g, MeshInstance3D as h, WATER_MAX_RIPPLES as i, Area3D as j, terrainThemeLayers as k, Particles3D as l, InstancedMesh3D as m, Water3D as n, VoxelGrid3D as o, OmniLight3D as p, createCausticsQuad as r, Tree3D as s, registerNodes3D as t, ModelInstance3D as u, Flowers3D as v, BoneAttachment3D as w, CharacterController3D as x, resolveFlowerDensity as y, cameraRelative as z };