Upload index.html

index.html

@@ -119,9 +119,8 @@ function frac(v){ return v - Math.floor(v); }
 // on is the ground it is drawn on to within about a millionth of a metre.
 const F32 = v => Math.fround(v);
 function lhash(x, z){ return (ihash((Math.imul(x, 3419) + Math.imul(z, 2147483647)) >>> 0) & 1023) / 1023; }
-function lnoise(x, z){
-  const px = F32(x*0.08), pz = F32(z*0.08);
-  const ix = Math.floor(px), iz = Math.floor(pz), fx = px - ix, fz = pz - iz;
+function lnoise(px, pz){            // takes lattice coordinates, so the caller sets the scale
+  const ix = Math.floor(px), iz = Math.floor(pz), fx = px-ix, fz = pz-iz;
   const sx = fx*fx*(3 - 2*fx), sz = fz*fz*(3 - 2*fz);
   const a = lhash(ix, iz), b = lhash(ix+1, iz), c = lhash(ix, iz+1), d = lhash(ix+1, iz+1);
   const u = a + (b-a)*sx, v = c + (d-c)*sx;
@@ -143,10 +142,12 @@ function islandAt(cx, cz){
   else if(low >= 96) return null;                       // most of the world is open sea
   const s = ihash(h) & 0xFFFFFF;
   const rb = s & 63, pk = (s >> 6) & 15, sh = (s >> 10) & 15, rg = (s >> 14) & 15;
-  const r = type === 1 ? 50 + rb*0.31 : type === 2 ? 9 + rb*0.14 : 14 + rb*0.25;
+  const r = F32(type === 1 ? 50 + rb*0.31 : type === 2 ? 9 + rb*0.14 : 14 + rb*0.25);
   return {
-    x: (cx + 0.5 + ((h >>> 8 & 255) - 127.5)/256) * ICELL,
-    z: (cz + 0.5 + ((h >>> 16 & 255) - 127.5)/256) * ICELL,
+    // x, z and r are stored as float32 values because that is what the shader receives. Otherwise
+    // the two sides can land on different lattice cells and disagree about the island's shape.
+    x: F32((cx + 0.5 + ((h >>> 8 & 255) - 127.5)/256) * ICELL),
+    z: F32((cz + 0.5 + ((h >>> 16 & 255) - 127.5)/256) * ICELL),
     r, code: pk + sh*16 + rg*256 + type*4096
   };
 }
@@ -158,7 +159,7 @@ function decode(code){
   // straight fall over the last fraction of it, which is the beach the boat can actually sit on.
   if(type === 1){ peak = 2.0 + pk*0.35; ramp = 0.10 + sh*0.04; }
   else if(type === 2){ peak = 14.0 + pk*1.6; shape = 0.04 + sh*0.012; }
-  return { peak, shape, rough: rg/15, type, ramp };
+  return { peak, shape, rough: F32(rg/15), type, ramp, pk, sh, rg };
 }
 
 function landH(x, z){
@@ -172,11 +173,23 @@ function landH(x, z){
   for(let j=-span;j<=span;j++) for(let i=-span;i<=span;i++){
     const isl = islandAt(cx+i, cz+j);
     if(!isl) continue;
-    const d = Math.hypot(x - isl.x, z - isl.z);
-    if(d > isl.r) continue;
     const p = decode(isl.code);
-    const k = 1 - d/isl.r;                  // monotone: downhill always leads back to the sea
-    const nz = 0.55 + 0.45*p.rough*lnoise(x, z);
+    // Nothing here is a circle. Two noise lattices are sized to the island itself: one gives the
+    // outline its lobes, the other the surface its hollows and peaks. Both are sampled relative to
+    // the island centre so the lattice coordinates stay small, every step is rounded to float32,
+    // and the offsets are small integers - otherwise the two sides pick different lattice cells and
+    // disagree about the shape, which is what would put the boat on a different height than the
+    // ground it is being drawn on.
+    const gx = F32(x), gz = F32(z);
+    const f1 = F32(F32(2 + Math.floor(p.rg/4)) / isl.r);
+    const f2 = F32(F32(6 + p.rg) / isl.r);
+    const dx = F32(gx - isl.x), dz = F32(gz - isl.z);
+    const d = F32(Math.sqrt(F32(F32(dx)*F32(dx)) + F32(F32(dz)*F32(dz))));   // what length() does in the shader
+    const wob = lnoise(F32(F32(dx*f1) + F32(p.pk)), F32(F32(dz*f1) + F32(p.sh)));
+    const rr = F32(isl.r * F32(F32(0.55) + F32(F32(0.45)*F32(wob))));
+    if(d > rr) continue;
+    const k = F32(F32(1.0) - F32(F32(d)/F32(rr)));
+    const nz = F32(F32(0.55) + F32(F32(0.45)*F32(p.rough)*lnoise(F32(F32(dx*f2) + F32((p.pk+p.sh+1)%16)), F32(F32(dz*f2) + F32((p.pk+p.sh+7)%16)))));
     const terr = (p.ramp > 0 ? Math.min(1, k/p.ramp) : Math.pow(k, p.shape)) * nz;
     h = Math.max(h, p.peak*terr - LAND.shelf);   // the shelf is the shallow ring around an island
   }
@@ -218,15 +231,14 @@ float fbm(vec2 p, int oct){
 `;
 
 const ISLANDS_GLSL = `
-uniform vec4 uIsl[25];
+uniform vec4 uIsl[48];   // must match MAX_ISLANDS, otherwise islands past 25 are silently dropped
 uniform int uCount;
 uint ihash(uint n){
   n ^= n >> 15; n *= 0x2c1b3c9du; n ^= n >> 12; n *= 0x297a2d39u; n ^= n >> 15;
   return n;
 }
 float lhash(int x, int y){ return float(ihash(uint(x)*3419u + uint(y)*2147483647u) & 1023u) / 1023.0; }
-float lnoise(vec2 p){
-  p = p * 0.08;                                  // same lattice scale as the JS copy
+float lnoise(vec2 p){              // takes lattice coordinates, so the caller sets the scale
   ivec2 i = ivec2(floor(p));
   vec2 f = p - vec2(float(i.x), float(i.y));
   f = f*f*(3.0-2.0*f);
@@ -237,18 +249,23 @@ float landH(vec2 p){
   float h = -6.0;          // no land in range: open water, deep enough that depth reads as deep
   for(int i=0;i<uCount;i++){
     vec4 isl = uIsl[i];
-    float d = length(p - isl.xy);
-    if(d > isl.z) continue;
+    vec2 r = p - isl.xy;                       // island-relative, exactly like the JS copy
+    float d = length(r);
     float code = isl.w;
     float pk = mod(code, 16.0), sh = floor(mod(code/16.0, 16.0)), rg = floor(mod(code/256.0, 16.0));
     float type = floor(code/4096.0);
-    float peak = 1.2 + pk*0.22, shape = 1.2 + sh*0.03;
+    float f1 = (2.0 + floor(rg/4.0)) / isl.z;
+    float f2 = (6.0 + rg) / isl.z;
+    float wob = lnoise(r*f1 + vec2(pk, sh));
+    float rr = isl.z * (0.55 + 0.45*wob);
+    if(d > rr) continue;
+    float peak = 1.2 + pk*0.22, shape = 1.2 + sh*0.03, ramp = 0.0;
     if(type == 1.0){ peak = 2.0 + pk*0.35; }
     else if(type == 2.0){ peak = 14.0 + pk*1.6; shape = 0.04 + sh*0.012; }
     float rough = rg/15.0;
-    float k = 1.0 - d/isl.z;
-    float nz = 0.55 + 0.45*rough*lnoise(p);
-    float terr = (type == 1.0) ? min(1.0, k/(0.10 + sh*0.04)) * nz : pow(k, shape) * nz;
+    float k = 1.0 - d/rr;
+    float nz = 0.55 + 0.45*rough*lnoise(r*f2 + vec2(mod(pk+sh+1.0, 16.0), mod(pk+sh+7.0, 16.0)));
+    float terr = (ramp > 0.0) ? min(1.0, k/ramp) * nz : pow(k, shape) * nz;
     h = max(h, peak*terr - 1.2);
   }
   return h;