mapspinner 0.1.56 → 0.1.57

package/package.json

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

package/src/gl-render.js

@@ -787,7 +787,7 @@ export async function initMapspinnerRender(gl, opts = {}) {
     // out fall beyond the far plane and vanish. Dropping the horizon reference radius 500m below sea level
     // extends the horizon to tens of km at low altitude so near-shore relief stays in view (negligible
     // depth-precision cost: 500m vs R~6.37e6). Both the cull and the draw use this (single source).
-    const RHORIZON = R - 500.0;
+    const RHORIZON = R - 250.0;   // far brought in 500->250 (user 2026-06-14 'bring far plane in a bit'): deck horizon ~80km->~56km = more z-precision; still clears coastal mountains
     // UNDERWATER FAR-PLANE FIX (user 2026-06-14 'at -214m visible, at -500m it disappears'): when the
     // camera is more than 500m below sea level, camDist < RHORIZON so the sea-level horizon is imaginary
     // (-> 0) and alt is negative; the old max(horizon, alt*8) then collapsed the far plane to ~0 and the
@@ -797,7 +797,7 @@ export async function initMapspinnerRender(gl, opts = {}) {
     // MATCH render()'s near exactly (2026-06-14 jank fix): the cull frustum must use the SAME near
     // as the draw frustum, else behind-limb/screen-AABB culling diverges from what is actually drawn
     // at the deck (cull near was max(*0.1,0.1) while render used the <2m 0.05 branch).
-    const near = altAboveTerrain < 2.0 ? 0.05 : Math.max(altAboveTerrain * 0.1, 0.05);
+    const near = altAboveTerrain < 2.0 ? 0.25 : Math.max(altAboveTerrain * 0.1, 0.25);   // near nudged out 0.05->0.25 (user 2026-06-14 'improve on-ground'): more z-precision on the deck
     // FAR PLANE: horizon distance tracks the visible ground edge; blends toward camDist
     // above 500km for orbital views so the full planet is visible.
     const _fBlend = Math.min(1.0, Math.max(0.0, (alt - 500000.0) / 4500000.0));
@@ -835,14 +835,14 @@ export async function initMapspinnerRender(gl, opts = {}) {
     // out fall beyond the far plane and vanish. Dropping the horizon reference radius 500m below sea level
     // extends the horizon to tens of km at low altitude so near-shore relief stays in view (negligible
     // depth-precision cost: 500m vs R~6.37e6). Both the cull and the draw use this (single source).
-    const RHORIZON = R - 500.0;
+    const RHORIZON = R - 250.0;   // far brought in 500->250 (user 2026-06-14 'bring far plane in a bit'): deck horizon ~80km->~56km = more z-precision; still clears coastal mountains
     // UNDERWATER FAR-PLANE FIX (user 2026-06-14 'at -214m visible, at -500m it disappears'): when the
     // camera is more than 500m below sea level, camDist < RHORIZON so the sea-level horizon is imaginary
     // (-> 0) and alt is negative; the old max(horizon, alt*8) then collapsed the far plane to ~0 and the
     // whole scene vanished past -500m deep (= the 'ocean looks shallow/empty' when exploring). Floor the
     // far reach to 60km when submerged so the seabed + the underwater view stay visible.
     const horizon = (camDist > RHORIZON) ? Math.sqrt(camDist*camDist - RHORIZON*RHORIZON) : 60000.0;
-    const near = altAboveTerrain < 2.0 ? 0.05 : Math.max(altAboveTerrain * 0.1, 0.05);
+    const near = altAboveTerrain < 2.0 ? 0.25 : Math.max(altAboveTerrain * 0.1, 0.25);   // near nudged out 0.05->0.25 (user 2026-06-14 'improve on-ground'): more z-precision on the deck
     const _fBlend = Math.min(1.0, Math.max(0.0, (alt - 500000.0) / 4500000.0));
     const farGround = Math.max(horizon, alt * 8.0);
     const far = farGround * (1.0 - _fBlend) + camDist * _fBlend;

package/src/shaders/terrain.glsl

@@ -1249,7 +1249,13 @@ vec3 terrainAlbedo(float h, float slope, float rockSlope, highp vec3 worldPos) {
     } else {
         c = mix(bcShore, bcLowland, smoothstep(0.0, bandEdgesLo.x, h));
         c = mix(c, bcGrass, smoothstep(bandEdgesLo.x, bandEdgesLo.y, h));
-        float bandWarp = snoise3(normalize(worldPos) * 400.0) * 500.0;
+        // BIOME-BAND WARP (user 2026-06-14 'hard bands between biomes ... make that more interesting'):
+        // the single-octave warp made smooth wavy contour lines. A 3-octave domain-warped field breaks
+        // the rock/snow boundaries into irregular fingers + patches (height-keyed band wobbles +/-~1.1km
+        // over 1-15km scales), so the biome edge reads natural, not a band. highp dir for the lattice.
+        highp vec3 bwd = normalize(worldPos);
+        highp vec3 bww = bwd + vec3(snoise3(bwd * 130.0)) * 0.004;   // domain warp -> non-parallel fingers
+        float bandWarp = (snoise3(bww * 210.0) * 1.0 + snoise3(bww * 560.0) * 0.5 + snoise3(bww * 1450.0) * 0.25) * 720.0;
         c = mix(c, bcRock, smoothstep(bandEdgesHi.x + bandWarp, bandEdgesHi.y + bandWarp, h));
         c = mix(c, bcSnow, smoothstep(snowEdges.x + bandWarp, snowEdges.y + bandWarp, h));
         c = mix(c, bcRock, smoothstep(slopeRock.x, slopeRock.y, rockSlope) * step(0.0, h));
@@ -1778,10 +1784,19 @@ void main() {
         // beach->land crossover). 2-oct world-dir noise, 1/4 freq (~13km + ~5km waves). Computed once
         // here; the snow/rock bandWarp below reuses warpN. highp dir for the lattice precision.
         highp vec3 bwDir = normalize(vWorld);
-        float warpN = snoise3(bwDir * 3325.0) + 0.5 * snoise3(bwDir * 7750.0);   // ~ +/-1.5
+        // 3-oct (added the ~1km octave, user 2026-06-14 'make biome bands more interesting') -> the
+        // texture-splat rock/snow/beach edges break into finer fingers as you approach, not a hard band.
+        float warpN = snoise3(bwDir * 3325.0) + 0.5 * snoise3(bwDir * 7750.0) + 0.35 * snoise3(bwDir * 17000.0);   // ~ +/-1.8
         // BEACH sand gate tied to uBeachTopM (so the sand TEXTURE scales with the wide beach, not a
         // hardcoded 80m strip) + the shared warp on its LAND edge so the beach->grass line is irregular.
-        float beachW = warpN * uBeachTopM * 0.30;   // warp amplitude scales with the beach band height
+        // FINE BREAK on the grass->sand line (user 2026-06-14 'still a hard straight grass-sand line up
+        // close ... it must gain detail'): warpN breaks it at the km scale; add a high-freq (~80-200m)
+        // octave so the line stays irregular/fingered when you walk right up to it instead of going
+        // straight. Faded in WITH the close-up detail (detailFade-like, via pxWorld) so it never speckles
+        // at distance where the macro band is smooth.
+        float closeBreak = (1.0 - smoothstep(2.0, 40.0, pxWorld));
+        float beachFine = (snoise3(bwDir * 42000.0) + 0.5 * snoise3(bwDir * 95000.0)) * uBeachTopM * 0.45 * closeBreak;
+        float beachW = warpN * uBeachTopM * 0.30 + beachFine;   // warp amplitude scales with the beach band height
         float beach = (1.0 - smoothstep(uBeachTopM * 0.12 + beachW, uBeachTopM + beachW, vH))
                     * (1.0 - smoothstep(0.15, 0.42, slope));
         // SAND BLEED (2026-06-13): patchy sand spills above the main beach line, modulated by VS
@@ -1885,18 +1900,22 @@ void main() {
         // 2m'): the base photo tiles at uTexTileM (~2.4km = ~2.3m/texel, smeared at the deck). Sample the
         // SAME dominant material at 4x frequency (~0.6m/texel) and overlay its luminance + normal so
         // close-up the ground gains sub-metre structure. Faded out by ~12m px so it never moires far off.
+        // LOW-FREQ = NORMALS ONLY, HIGH-FREQ = TEXTURE + STRONG NORMALS (user 2026-06-14): flatten the
+        // base (2.4km) albedo to its luminance so the MACRO biome color carries the chroma -- the base
+        // octave contributes only its NORMAL (relief), not color blotches. The 4x detail octave then
+        // provides the albedo STRUCTURE + a strong normal.
+        texAlb.rgb = vec3(dot(texAlb.rgb, vec3(0.299, 0.587, 0.114)));   // low-freq: normals only (albedo -> flat luma)
         float detailFade = (1.0 - smoothstep(1.0, 12.0, pxWorld));
         if (detailFade > 0.01) {
             vec4 dA = surfTriTap(uSurfAlb, wt * 4.0, tw, lA);
             float dl = dot(dA.rgb, vec3(0.299, 0.587, 0.114));
             float bl = dot(texAlb.rgb, vec3(0.299, 0.587, 0.114));
-            texAlb.rgb *= mix(1.0, clamp(dl / max(bl, 0.04), 0.55, 1.7), detailFade * 0.6);
-            // detail NORMAL: surfTriNrm returns a PERTURBATION vector (texNrm feeds texDn = texNrm*uTexNrmK*k
-            // at the apply site, NOT a unit normal), so the detail is simply ADDED in the same space -- no
-            // normalize (normalizing the perturbation scrambled its magnitude = the 'weird highest-octave
-            // normals'). Half-weight so the fine octave textures relief without overpowering the base.
+            texAlb.rgb *= mix(1.0, clamp(dl / max(bl, 0.04), 0.35, 2.4), detailFade * 1.3);   // HIGH-FREQ albedo structure (heavier)
+            // detail NORMAL: surfTriNrm returns a PERTURBATION vector (texNrm feeds texDn = texNrm*uTexNrmK*k,
+            // NOT a unit normal), so the detail is simply ADDED in the same space -- no normalize (that
+            // scrambled magnitudes = the 'weird highest-octave normals').
             vec3 dN = surfTriNrm(uSurfNrm, wt * 4.0, tw, lA, n);
-            texNrm = texNrm + dN * detailFade * 0.5;
+            texNrm = texNrm + dN * detailFade * 1.4;   // BIGGER normal effect for the high-freq octave (user 2026-06-14)
         }
         float k = uTexMix * texFarFade;
         // macro-tinted detail (user 2026-06-10 'the textured patch must be tinted to the same shade