mapspinner 0.1.53 → 0.1.55

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mapspinner",
-  "version": "0.1.53",
+  "version": "0.1.55",
   "description": "WebGL2 Earth-scale terrain rendering SDK for interactive globe applications",
   "main": "src/index.js",
   "exports": {

package/src/gl-render.js

@@ -1115,11 +1115,11 @@ export async function initMapspinnerRender(gl, opts = {}) {
       // shows. Cap every visible leaf at level WCAP and DEDUP to its ancestor tile: a coarse,
       // LOD-churn-free cover of the same footprint, typically ~10-50x fewer water vertices.
       // __waterSurface=0 disables live.
-      // UNDERWATER: skip the sea-level water surface entirely (user 2026-06-14 'underwater looks weird,
-      // we cant see anything / it must draw the sea bed'). The surface mesh drawn from below was an
-      // opaque sheet that occluded the seabed; with it gone, the underwater camera sees the seabed
-      // terrain directly (with the underwater fog). Above water it draws normally.
-      if ((typeof window === 'undefined' || window.__waterSurface !== false) && !_uw) {
+      // The water surface draws in BOTH cases now (user 2026-06-14 'no water surface visible from
+      // underneath'): it's geometrically ABOVE the camera, so underwater it is the up-view CEILING
+      // (Snell's window, shaded in the uUnderwater branch) and the seabed below stays visible (the
+      // down-view ray never hits the surface). With the fog 10x lighter it no longer washes the floor.
+      if (typeof window === 'undefined' || window.__waterSurface !== false) {
         // WCAP 7 -> 9 (coast witness caught it: a level-7 tile's 16-cell mesh chord sags
         // A_cell^2/(8R) ~ 0.8m below the true sphere mid-cell -- BELOW the metres-deep shelf
         // seabed, so the depth test culled the water across entire shorelines. Level-9 cells

package/src/shaders/terrain.glsl

@@ -143,7 +143,7 @@ float snoise3(highp vec3 P){ highp vec3 i=floor(P),f=fract(P); highp vec3 u=f*f*
 // the same class as the historical snoise3-in-VS-only bug). Pure fn of world dir -> seam-safe +
 // LOD-invariant. Each has an EROSION profile: a wide graded shoulder/valley/bench that blends into
 // terrain plus a deeper core, and returns a wet/depth mask the FS colours.
-const float LAKE_CARVE_DEPTH = 90.0;   // metres of bowl depth at basin centre
+const float LAKE_CARVE_DEPTH = 220.0;   // 90->220 metres of bowl depth (user 2026-06-14 'lakes super shallow+flat'): deeper basins
 float lakeBasinField(vec3 dir){ return 0.5 + 0.5 * snoise3(dir * 55.0 + vec3(4.0, 9.0, 1.0)); }
 float lakeCarveM(vec3 dir, out float wet){
     float basin = lakeBasinField(dir);
@@ -186,7 +186,7 @@ float inciseRidgeField(vec3 d, float baseFreq, float freqMul){
     }
     return sum / norm;                                         // ->1 on the channel network
 }
-const float RIVER_INCISE_DEPTH = 120.0;   // metres at the channel thalweg
+const float RIVER_INCISE_DEPTH = 280.0;   // 120->280 metres at the channel thalweg (user 2026-06-14 'rivers/channels super shallow+flat'): deeper incision
 float riverRidgeField(vec3 dir){ return inciseRidgeField(normalize(dir), 40.0, 2.03); }
 float riverCarveM(vec3 dir, out float wet){
     float ridge = riverRidgeField(dir);
@@ -1560,6 +1560,16 @@ void main() {
             vec3 deepBlue = vec3(0.005, 0.06, 0.18);
             vec3 waveBright = vec3(0.0, 0.02, 0.06) * length(slopeW);
             vec3 wcol = deepBlue + sunUnder * 0.4 + waveBright;
+            // SNELL'S WINDOW (user 2026-06-14 'no water surface visible from underneath'): looking UP, the
+            // surface is a bright window to the sky within the critical angle (near-vertical view) and a
+            // dark total-internal-reflection mirror at grazing angles. upness = how vertical the view->
+            // surface ray is; brighten toward the refracted sky + a sun disc inside the window.
+            float upness = abs(dot(viewW, wn));
+            float snell = smoothstep(0.50, 0.82, upness);
+            vec3 skyWindow = vec3(0.40, 0.60, 0.85) * (0.5 + 0.9 * ndl);
+            wcol = mix(wcol, skyWindow, snell * 0.85);
+            float sunw = pow(max(dot(viewW, sunDir), 0.0), 180.0);   // sun seen through the window
+            wcol += vec3(1.0, 0.92, 0.70) * sunw * (0.4 + 0.6 * snell);
             float macroMuW = dot(uz, sunDir);
             float dayShadeW = mix(uNightFloor, 1.0, smoothstep(-uTermWidth, uTermWidth, macroMuW));
             vec3 cW = wcol * dayShadeW * uExposure;
@@ -2189,6 +2199,11 @@ void main() {
         vec3 absorb = vec3(0.035, 0.010, 0.005) * (1.0 + depth * 0.0001);
         vec3 uwTrans = exp(-absorb * dKm);
         vec3 uwFog = vec3(0.004, 0.09, 0.18) + vec3(0.0, 0.015, 0.03) * depth / 1000.0;
+        // SEABED LIGHTING (user 'floor too flat/dim'): the deep floor gets almost no direct sun, so it
+        // read dim+flat. Lift the brightness and add an up-facing fill (brighter where the surface faces
+        // up, darker on slopes -> 3D relief) + a touch of slope contrast keyed on the lit normal vNrm.
+        float upFill = mix(0.75, 1.35, clamp(dot(vNrm, normalize(vWorld)) * 0.5 + 0.5, 0.0, 1.0));
+        color *= upFill * 1.5;
         color = mix(color * uwTrans + uwFog * (1.0 - uwTrans), uwFog, smoothstep(100000.0, 500000.0, dKm * 1000.0));
     }
     // RIVERS post-lighting (witnessed browser-2115/2118: the river-blue in ALBEDO is multiplied
@@ -2205,8 +2220,10 @@ void main() {
     // bypasses it via vH<0). Gating on vWaterDepth (NOT the whole carve mask) makes the water LINE UP
     // with the flat carved surface -- the graded erosion banks above the waterline stay dry land.
     if (vH >= 0.0 && vWaterDepth > 0.0) {
-        // submergence 0..1 over ~0..40m -> shoreline (thin water, terrain shows through) to deep.
-        float sub = clamp(vWaterDepth / 40.0, 0.0, 1.0);
+        // submergence 0..1 over ~0..160m (40->160, user 2026-06-14 'water super shallow+flat'): the color
+        // saturated at 40m so every deeper lake/river read one flat tone; stretch it so depth shows as a
+        // shallow-edge -> deep-center gradient (thin transparent rim, deep dark center).
+        float sub = clamp(vWaterDepth / 160.0, 0.0, 1.0);
         // wave-perturbed water normal (small inland ripple), same tangent frame as the ground.
         highp vec3 wOriginL = floor(camWorld / 1024.0) * 1024.0;   // W7: ~6.4e6 m snapped anchor -> highp
         highp vec2 wpL = vec2(dot(vWorld - wOriginL, ux), dot(vWorld - wOriginL, uy));   // W7: highp camera-relative wave coord