incanto 0.15.0 → 0.16.1

package/dist/{register-Bh_3Z39N.js → register-CNvGGK2B.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
@@ -10576,6 +10690,16 @@ 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;
@@ -10668,59 +10792,67 @@ vec2 noiseGrad(vec2 p) {
 // layers sit close in weight so no single direction dominates. One coarse
 // smooth layer keeps long-swell coherence underneath. The line this walks:
 // PR-J's isotropic goop ←→ the crease field this replaces.
+// ============ the WATER-FEEL rewrite (the syrup fix) ============
+// The old detail layers had two viscosity bugs that made every surface read
+// as 꿀렁꿀렁한 gel instead of water:
+//   1. WRONG SPEED: each ripple layer drifted ~10× slower than a real wave
+//      of its wavelength. Deep-water dispersion says a λ-meter wave travels
+//      at c = sqrt(gλ/2π) — a 40 cm ripple crosses ITSELF ~2.7× per second.
+//      Slow fine ripples are exactly what honey looks like.
+//   2. PATTERN SLIDING: a translated noise field reads as one sticker being
+//      dragged (cellophane). Real ripple CHURNS — crests appear, interfere
+//      and die. The fine octaves are therefore INTERFERENCE PAIRS: the same
+//      wavelength read twice in slightly split directions and speeds; their
+//      sum morphs continuously instead of sliding.
+// Four octaves, each advected at its REAL phase speed (in noise-space,
+// phase = c/λ per second — short waves flicker fast, the tell of thin
+// mobile water):  λ 6.0 m → 0.51/s · 2.2 m → 0.84/s · 0.9 m → 1.31/s ·
+// 0.38 m → 2.02/s.
 const vec2 WIND_DIR = vec2(0.8192, 0.5735);
-const float WIND_STRETCH = 1.7;
 
-vec2 windWarp(vec2 p, vec2 dir) {
-  return vec2(dot(p, dir) / WIND_STRETCH, dot(p, vec2(-dir.y, dir.x)));
+vec2 octaveSlope(vec2 p, vec2 dir, float lambda, float t) {
+  // advect ALONG the octave's travel direction at the dispersion speed
+  float phase = sqrt(1.56 / lambda) * t; // c/λ = sqrt(g/(2πλ)) · … ≈ sqrt(1.56/λ)
+  return noiseGrad(p / lambda + dir * phase);
 }
-// map a warped-domain gradient back to world XZ (chain rule of windWarp)
-vec2 unwarp(vec2 g, vec2 dir) {
-  return (g.x / WIND_STRETCH) * dir + g.y * vec2(-dir.y, dir.x);
+// interference pair: same wavelength, directions split ±14°, speeds split
+// ±12% — the sum churns (crests are born and die) instead of sliding.
+vec2 octavePair(vec2 p, vec2 dir, float lambda, float t) {
+  vec2 dA = normalize(dir + 0.25 * vec2(-dir.y, dir.x));
+  vec2 dB = normalize(dir - 0.25 * vec2(-dir.y, dir.x));
+  float phase = sqrt(1.56 / lambda) * t;
+  return noiseGrad(p / lambda + dA * (phase * 1.12))
+       + noiseGrad(p / lambda * 1.07 + dB * (phase * 0.88) + 17.0);
 }
-float ridge(vec2 p) { return 1.0 - abs(snoise(p)); }
-vec2 ridgeGrad(vec2 p) {
-  const float e = 0.05;
-  float h = ridge(p);
-  return vec2(ridge(p + vec2(e, 0.0)) - h, ridge(p + vec2(0.0, e)) - h) / e;
-}
-// dapple pass: the softened crest — ridge folds diluted ~half toward plain
-// simplex so crests read as short glints, never continuous crease lines.
-vec2 dappleGrad(vec2 p) { return mix(noiseGrad(p), ridgeGrad(p), 0.55); }
+
 vec3 detailNormal(vec3 n, vec2 worldXZ, float strength, float camDist) {
   float fadeCoarse = 1.0 - smoothstep(90.0, 420.0, camDist);
-  float fadeMid    = 1.0 - smoothstep(40.0, 150.0, camDist);
-  float fadeFine   = 1.0 - smoothstep(14.0, 60.0, camDist);
-  vec2 dMid  = normalize(vec2(0.62, 0.78));  // ~+25° off the wind
-  vec2 dFine = normalize(vec2(0.94, 0.34));  // ~-20° — the crossing set
+  float fadeMid    = 1.0 - smoothstep(40.0, 170.0, camDist);
+  float fadeFine   = 1.0 - smoothstep(18.0, 80.0, camDist);
+  float fadeMicro  = 1.0 - smoothstep(8.0, 34.0, camDist);
+  vec2 dMid = normalize(vec2(0.62, 0.78));
   vec2 slope =
-      unwarp(noiseGrad(windWarp(worldXZ, WIND_DIR) * 1.6 + uTime * vec2(0.11, 0.05)), WIND_DIR)
-        * (0.18 * fadeCoarse)
-    + unwarp(dappleGrad(windWarp(worldXZ, dMid) * 7.6 - uTime * vec2(0.33, 0.07)), dMid)
-        * (0.27 * fadeMid)
-    + unwarp(dappleGrad(windWarp(worldXZ, dFine) * 13.5 + uTime * vec2(0.40, -0.06)), dFine)
-        * (0.25 * fadeFine);
-  slope *= strength;
+      octaveSlope(worldXZ, WIND_DIR, 6.0, uTime) * (0.085 * fadeCoarse)
+    + octaveSlope(worldXZ, dMid,     2.2, uTime) * (0.10  * fadeMid)
+    + octavePair(worldXZ, WIND_DIR,  0.9, uTime) * (0.055 * fadeFine)
+    + octavePair(worldXZ, dMid,      0.38, uTime) * (0.042 * fadeMicro);
+  slope *= strength * 3.0; // spectrum norm: default strength 0.26 ≈ calm-lively
   return normalize(vec3(n.x - slope.x, n.y, n.z - slope.y));
 }
 
-// refinement pass 3: the GLOSS normal — what fresnel and the reflection read.
-// The ridge folds in detailNormal flip the normal's sign across every crest;
-// against an HDR sky cube map each flip is a white sequin, and the pond
-// carpeted itself in speckle (verified by toggling reflection off). A mirror
-// the size of a pixel integrates the micro-ripple away, so the reflection
-// must read only the SMOOTH long-wavelength layers — the crisp ripple still
-// shows through the refraction offset and the sparse glints.
+// The GLOSS normal — what fresnel, the reflection and the refraction offset
+// read. Only the two long octaves: a mirror the size of a pixel integrates
+// micro-ripple away, so reflections stay smooth and ROUNDED (the glassy
+// pool-reference surface); the fast fine churn lives in the sun glitter and
+// the body shading, never as reflection speckle.
 vec3 glossNormal(vec3 n, vec2 worldXZ, float strength, float camDist) {
   float fadeCoarse = 1.0 - smoothstep(90.0, 420.0, camDist);
-  float fadeMid    = 1.0 - smoothstep(40.0, 150.0, camDist);
+  float fadeMid    = 1.0 - smoothstep(40.0, 170.0, camDist);
   vec2 dMid = normalize(vec2(0.62, 0.78));
   vec2 slope =
-      unwarp(noiseGrad(windWarp(worldXZ, WIND_DIR) * 1.6 + uTime * vec2(0.11, 0.05)), WIND_DIR)
-        * (0.18 * fadeCoarse)
-    + unwarp(noiseGrad(windWarp(worldXZ, dMid) * 4.2 - uTime * vec2(0.26, 0.06)), dMid)
-        * (0.16 * fadeMid);
-  slope *= strength;
+      octaveSlope(worldXZ, WIND_DIR, 6.0, uTime) * (0.085 * fadeCoarse)
+    + octaveSlope(worldXZ, dMid,     2.2, uTime) * (0.075 * fadeMid);
+  slope *= strength * 3.0;
   return normalize(vec3(n.x - slope.x, n.y, n.z - slope.y));
 }
 
@@ -11031,6 +11163,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
@@ -11071,7 +11219,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.
@@ -11098,14 +11246,13 @@ void main() {
   // grazing angles. Weight by a Schlick-like grazing term so steep views
   // stay calm, clear water instead of speckling.
   float grazing = pow(1.0 - clamp(dot(-viewDirection, vec3(0.0, 1.0, 0.0)), 0.0, 1.0), 2.0);
-  // …and SPARSE: the ridge layers align whole fold-lines of facets at once,
-  // so an ungated glint still carpets the surface in speckle. A drifting
-  // noise gate keeps ~15% of the field twinkling at any moment — isolated
-  // sparks that wander, like the reference's crest glints.
-  float glintGate = smoothstep(0.78, 0.95, noise(vWorldPosition.xz * 2.2 + uTime * vec2(0.6, 0.4)));
-  float glintFade = 1.0 - smoothstep(60.0, 220.0, camDist);
-  float glint = pow(specAngle, 1400.0) * (0.18 + 0.95 * sunPath) * glintFade
-              * (0.1 + 0.9 * grazing) * glintGate;
+  // water-feel rewrite: NO artificial gate — the micro-ripple spectrum's
+  // fast churn makes each facet align with the sun for only a flash, so the
+  // glitter is naturally granular AND flickers at ripple speed (the old
+  // slow-noise gate was another piece of the syrup feel).
+  float glintFade = 1.0 - smoothstep(60.0, 240.0, camDist);
+  float glint = pow(specAngle, 900.0) * (0.15 + 0.85 * sunPath) * glintFade
+              * (0.1 + 0.9 * grazing);
   float farAngle = max(dot(fresnelNormal, halfway), 0.0);
   float streak = pow(farAngle, 240.0) * 0.45 * sunPath * (1.0 - glintFade);
   float sheen = pow(specAngle, 64.0) * 0.05 * sunPath;
@@ -11394,6 +11541,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: .045,
+		swell: .38,
+		swellWavelength: 52,
+		whitecaps: .4,
+		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. */
@@ -11545,7 +11794,12 @@ var Water3D = class Water3D extends Node3D {
 		swell: { default: 0 },
 		swellDirectionDeg: { default: 0 },
 		swellWavelength: { default: 30 },
-		whitecaps: { default: 0 }
+		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];
@@ -11615,6 +11869,40 @@ var Water3D = class Water3D extends Node3D {
 	/** 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;
@@ -11639,6 +11927,11 @@ var Water3D = class Water3D extends Node3D {
 		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" });
@@ -11718,7 +12011,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;
@@ -11805,7 +12098,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
@@ -11851,10 +12144,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 },
@@ -11876,9 +12169,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 },
@@ -11893,11 +12186,13 @@ var Water3D = class Water3D extends Node3D {
 				uEdgeColor: { value: new Color(FOAM_LOOK.edgeColor) },
 				uEdgeIntensity: { value: FOAM_LOOK.edgeIntensity },
 				uEdgeWidth: { value: FOAM_LOOK.edgeWidth },
-				uSwellAmplitude: { value: this.swell },
+				uSwellAmplitude: { value: this.rp("swell") },
 				uSwellDir: { value: new Vector2(0, 1) },
-				uSwellWavelength: { value: this.swellWavelength },
-				uWhitecaps: { value: this.whitecaps },
-				uWaveEnvelope: { value: 0 }
+				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,
@@ -11918,14 +12213,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() },
@@ -11946,8 +12241,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();
@@ -11956,15 +12251,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.uSwellAmplitude) u.uSwellAmplitude.value = this.swell;
-		if (u.uSwellWavelength) u.uSwellWavelength.value = this.swellWavelength;
-		if (u.uWhitecaps) u.uWhitecaps.value = this.whitecaps;
+		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.waveHeight * AMPLITUDE_PER_WAVE_HEIGHT * 1.5 + this.swell * 1.03;
+		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;
@@ -11992,8 +12291,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);
@@ -12006,22 +12306,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;
@@ -12035,7 +12335,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;
@@ -12119,9 +12419,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,
@@ -12241,4 +12541,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 };