`nx_worldgen.nx` source

↩ module page · 574 lines · 32155 B
1// nx_worldgen.nx -- ★SOVEREIGN INFINIGEN, RUNG 1: procedural NATURE (operator 2026-07-08, sharing princeton-vl/
2// infinigen: "build a WORLD full of living people, animals, environments, weather"). Infinigen = seed->procedural
3// photoreal 3D, NO ML, NO external assets -- EXACTLY our doctrine. This is the nature/"hello world" module: a
4// seed grows a whole LANDSCAPE -- fBm terrain (grass/rock/snow by height+slope) + water (lakes/sea) + sky gradient
5// + sun + procedural clouds + atmospheric fog. All INTEGER, sovereign, our own heightfield ray-marcher. Different
6// seed = different world; a weather param retints sun/sky/fog (clear / sunset / overcast). license_tier: ORIGINAL
7import "nx_syscalls.nx"
8import "nx_itrig.nx"
9import "nx_vecmath.nx"
10const WG_MAGIC_374761393: i64 = 374761393
11const WG_MAGIC_668265263: i64 = 668265263
12const WG_MAGIC_65536: i64 = 65536
13const WG_MAGIC_4000: i64 = 4000
14const WG_MAGIC_1024: i64 = 1024
15const WG_MAGIC_32768: i64 = 32768
16const WG_MAGIC_2900: i64 = 2900
17const WG_MAGIC_1048576: i64 = 1048576
18const WG_MAGIC_3000: i64 = 3000
19const WG_MAGIC_40000: i64 = 40000
20const WG_MAGIC_1050: i64 = 1050
21const WG_MAGIC_4096: i64 = 4096
22const WG_MAGIC_9999: i64 = 9999
23const WG_MAGIC_60000: i64 = 60000
24const WG_MAGIC_2000000000: i64 = 2000000000
25const WG_MAGIC_1800: i64 = 1800
26const WG_MAGIC_1500: i64 = 1500
27const WG_MAGIC_1350: i64 = 1350
28const WG_MAGIC_1100: i64 = 1100
29
30const WG_W: i64 = 1280              // 2x render -> the page downscales it = free anti-aliasing
31const WG_H: i64 = 768
32const WG_FOCAL: i64 = 720
33const WG_HORIZON: i64 = 92           // shifts the horizon down (look slightly over the land)
34const WATER: i64 = 0                // water level (world units)
35const HSCALE: i64 = 4600
36const SNOW: i64 = 2620
37
38// RETIRED ONTO THE SHARED OWNER 2026-08-24 (was a private Newton floor-sqrt; vm_isqrt is gate-proven exact).
39func wg_isqrt(v: i64) -> i64 { return vm_isqrt(v) }
40func wg_abs(v: i64) -> i64 { if v<0 {return 0-v} return v }
41func wg_min(a: i64, b: i64) -> i64 { if a<b {return a} return b }
42func wg_max(a: i64, b: i64) -> i64 { if a>b {return a} return b }
43func wg_clamp(v: i64, lo: i64, hi: i64) -> i64 { if v<lo {return lo} if v>hi {return hi} return v }
44
45func wg_hash(ix: i64, iz: i64, seed: i64) -> i64 {
  var h: i64 = (ix + seed*7)*WG_MAGIC_374761393 + (iz - seed*3)*WG_MAGIC_668265263 + ix*iz*97 + seed*13
  if h < 0 { h = 0 - h }
  return h % WG_MAGIC_65536
49}
50func wg_smooth(t: i64) -> i64 { return t*t*(768 - 2*t)/WG_MAGIC_65536 }   // smoothstep, t in 0..256 -> 0..256
51func wg_vnoise(x256: i64, z256: i64, seed: i64) -> i64 {
  let ix: i64 = x256 >> 8; let iz: i64 = z256 >> 8
  let fx: i64 = x256 & 255; let fz: i64 = z256 & 255
  let sx: i64 = wg_smooth(fx); let sz: i64 = wg_smooth(fz)
  let v00: i64 = wg_hash(ix,iz,seed); let v10: i64 = wg_hash(ix+1,iz,seed)
  let v01: i64 = wg_hash(ix,iz+1,seed); let v11: i64 = wg_hash(ix+1,iz+1,seed)
  let a: i64 = v00 + (v10-v00)*sx/256
  let b: i64 = v01 + (v11-v01)*sx/256
  return a + (b-a)*sz/256
60}
61// fractal Brownian motion -> 0..1024
62func wg_fbm(wx: i64, wz: i64, seed: i64) -> i64 {
  let cx: i64 = wx*256/WG_MAGIC_4000; let cz: i64 = wz*256/WG_MAGIC_4000
  var sum: i64 = 0; var amp: i64 = 512; var norm: i64 = 0; var o: i64 = 0
  while o < 5 {
      sum = sum + wg_vnoise(cx << o, cz << o, seed + o*131) * amp / WG_MAGIC_65536
      norm = norm + amp; amp = amp/2; o = o + 1
  }
  return sum*WG_MAGIC_1024/norm
70}
71func wg_terrain_h(wx: i64, wz: i64, seed: i64) -> i64 { return (wg_fbm(wx,wz,seed) - 402) * HSCALE / WG_MAGIC_1024 }
72
73// ---- PG22 (2026-09-06): THE VOLUMETRIC WEATHER FIELD -- a cloud is a 3D density, never a sheet ---------------------
74// wg_cloud_volume(wx, wy, wz, t, cover_q10, wind_dx_q10, wind_dz_q10, seed) -> density Q10 in [0, 1024]. The volume is
75// DRIVEN BY THE WEATHER FIELD THROUGH ITS OUTPUTS: cover_q10 comes from wg_cover_from_weather over the field's precip,
76// visibility and fog params (the gate composes nx_weather_pattern and proves CLEAR < OVERCAST < RAIN), and the field's
77// wind vector advects the volume in time -- no wind, no motion, which the gate holds as a neg-control. Shape is 3D
78// value-noise fBm over WG_CLOUD_CELL-unit cells, gated by a vertical envelope between WG_CLOUD_BASE and WG_CLOUD_TOP
79// and by the coverage threshold thr = 1024 - cover: density = clamp((fbm - thr) * WG_CLOUD_GAIN) * envelope. The
80// 2D sheet the CPU tier keeps drawing is wg_cloud_sheet, the incumbent sky expression BY NAME (the renderer below
81// calls it), so the fallback and the volume are one coverage law. Integer, seeded, bit-exact. This file's closure is
82// deliberately unchanged (no import): the weather field is an INPUT, so the volume compiles on every tree the field
83// does not, and a world without a weather field can still pass a constant cover.
84const WG_CLOUD_BASE: i64 = 5200          // world units; terrain tops out near HSCALE, the deck floats above it
85const WG_CLOUD_TOP: i64 = 8400
86const WG_CLOUD_RAMP_LO: i64 = 400        // density rises over this many units above the base
87const WG_CLOUD_RAMP_HI: i64 = 1200       // and falls over this many units below the top (anvils thin out)
88const WG_CLOUD_CELL: i64 = 640           // one noise cell in world units at octave 0
89const WG_CLOUD_OCTAVES: i64 = 4
90const WG_CLOUD_GAIN: i64 = 6             // slope of the coverage threshold
91const WG_CLOUD_SEED_SALT: i64 = 7        // the sheet's seed, shared so volume and sheet agree on which sky
92const WG_CLOUD_ADVECT: i64 = 12          // world units per time unit at wind Q10 = 1024
93const WG_CLOUD_ORIGIN: i64 = 1048576     // positive offset so >> and & see positive coordinates
94const WG_COVER_LOSTVIS_W: i64 = 4        // coverage weights over the Q14 field params: lost visibility dominates
95const WG_COVER_PRECIP_W: i64 = 1
96const WG_COVER_FOG_W: i64 = 1
97const WG_SHEET_THR_GAIN: i64 = 5         // the incumbent sheet threshold: 1024 - cloud*5
98func wg_hash3(ix: i64, iy: i64, iz: i64, seed: i64) -> i64 {
  var h: i64 = (ix + seed*7)*WG_MAGIC_374761393 + (iy + seed*11)*WG_MAGIC_668265263 + (iz - seed*3)*WG_MAGIC_374761393 + ix*iz*97 + iy*iz*89 + ix*iy*83 + seed*13
  if h < 0 { h = 0 - h }
  return h % WG_MAGIC_65536
102}
103func wg_vnoise3(x256: i64, y256: i64, z256: i64, seed: i64) -> i64 {
  let ix: i64 = x256 >> 8; let iy: i64 = y256 >> 8; let iz: i64 = z256 >> 8
  let sx: i64 = wg_smooth(x256 & 255); let sy: i64 = wg_smooth(y256 & 255); let sz: i64 = wg_smooth(z256 & 255)
  let v000: i64 = wg_hash3(ix,iy,iz,seed);     let v100: i64 = wg_hash3(ix+1,iy,iz,seed)
  let v010: i64 = wg_hash3(ix,iy+1,iz,seed);   let v110: i64 = wg_hash3(ix+1,iy+1,iz,seed)
  let v001: i64 = wg_hash3(ix,iy,iz+1,seed);   let v101: i64 = wg_hash3(ix+1,iy,iz+1,seed)
  let v011: i64 = wg_hash3(ix,iy+1,iz+1,seed); let v111: i64 = wg_hash3(ix+1,iy+1,iz+1,seed)
  let a0: i64 = v000 + (v100-v000)*sx/256
  let a1: i64 = v010 + (v110-v010)*sx/256
  let b0: i64 = v001 + (v101-v001)*sx/256
  let b1: i64 = v011 + (v111-v011)*sx/256
  let a: i64 = a0 + (a1-a0)*sy/256
  let b: i64 = b0 + (b1-b0)*sy/256
  return a + (b-a)*sz/256
117}
118// 3D fractal Brownian motion -> 0..1024, the shape of wg_fbm lifted one dimension
119func wg_fbm3(x256: i64, y256: i64, z256: i64, seed: i64) -> i64 {
  var sum: i64 = 0; var amp: i64 = 512; var norm: i64 = 0; var o: i64 = 0
  while o < WG_CLOUD_OCTAVES {
      sum = sum + wg_vnoise3(x256 << o, y256 << o, z256 << o, seed + o*131) * amp / WG_MAGIC_65536
      norm = norm + amp; amp = amp/2; o = o + 1
  }
  return sum*WG_MAGIC_1024/norm
126}
127// the weather field's params (Q14, q = the field's own Q) -> cloud cover Q10: lost visibility, precipitation and fog
128func wg_cover_from_weather(precip_q14: i64, visibility_q14: i64, fog_q14: i64, q: i64) -> i64 {
  if q <= 0 { return 0 }
  var lost: i64 = q - visibility_q14
  if lost < 0 { lost = 0 }
  let c14: i64 = lost*WG_COVER_LOSTVIS_W + precip_q14*WG_COVER_PRECIP_W + fog_q14*WG_COVER_FOG_W
  return wg_clamp(c14*WG_MAGIC_1024/q, 0, WG_MAGIC_1024)
134}
135// the vertical envelope Q10: 0 below the base and above the top, ramping in over RAMP_LO and out over RAMP_HI
136func wg_cloud_envelope(wy: i64) -> i64 {
  if wy <= WG_CLOUD_BASE { return 0 }
  if wy >= WG_CLOUD_TOP { return 0 }
  let up: i64 = wg_min((wy - WG_CLOUD_BASE)*WG_MAGIC_1024/WG_CLOUD_RAMP_LO, WG_MAGIC_1024)
  let dn: i64 = wg_min((WG_CLOUD_TOP - wy)*WG_MAGIC_1024/WG_CLOUD_RAMP_HI, WG_MAGIC_1024)
  return wg_min(up, dn)
142}
143func wg_cloud_volume(wx: i64, wy: i64, wz: i64, t: i64, cover_q10: i64, wind_dx_q10: i64, wind_dz_q10: i64, seed: i64) -> i64 {
  if cover_q10 <= 0 { return 0 }
  let env: i64 = wg_cloud_envelope(wy)
  if env <= 0 { return 0 }
  let ax: i64 = wx - wind_dx_q10*t*WG_CLOUD_ADVECT/WG_MAGIC_1024
  let az: i64 = wz - wind_dz_q10*t*WG_CLOUD_ADVECT/WG_MAGIC_1024
  let x256: i64 = (ax + WG_CLOUD_ORIGIN)*256/WG_CLOUD_CELL
  let y256: i64 = (wy + WG_CLOUD_ORIGIN)*256/WG_CLOUD_CELL
  let z256: i64 = (az + WG_CLOUD_ORIGIN)*256/WG_CLOUD_CELL
  let shape: i64 = wg_fbm3(x256, y256, z256, seed + WG_CLOUD_SEED_SALT)
  let thr: i64 = WG_MAGIC_1024 - cover_q10
  let d: i64 = wg_clamp((shape - thr)*WG_CLOUD_GAIN, 0, WG_MAGIC_1024)
  return d*env/WG_MAGIC_1024
156}
157// the CPU tier's sheet: the incumbent sky cloud, positive where the sheet is cloud (fbm minus the coverage threshold)
158func wg_cloud_sheet(px: i64, pz: i64, cloud: i64) -> i64 {
  let c: i64 = wg_fbm(px+WG_MAGIC_40000, pz+WG_MAGIC_40000, WG_CLOUD_SEED_SALT)
  return c - (WG_MAGIC_1024 - cloud*WG_SHEET_THR_GAIN)
161}
162
163// weather -> params array [sundx,sundy,sundz(fx1024 unit), sunr,sung,sunb, skyzr,skyzg,skyzb, skyhr,skyhg,skyhb, fog, cloud]
164func wg_weather(mode: i64, W: *i64) -> i64 {
  // default CLEAR day: sun upper-right
  W[0]=520; W[1]=620; W[2]=560; W[3]=255; W[4]=248; W[5]=228
  W[6]=64; W[7]=120; W[8]=210; W[9]=176; W[10]=205; W[11]=232; W[12]=44; W[13]=42
  if mode == 1 {  // SUNSET: low warm sun, warm sky
      W[0]=780; W[1]=180; W[2]=560; W[3]=255; W[4]=170; W[5]=96
      W[6]=40; W[7]=70; W[8]=150; W[9]=250; W[10]=150; W[11]=96; W[12]=60; W[13]=54
  }
  if mode == 2 {  // OVERCAST: high diffuse, grey sky, heavy fog+cloud
      W[0]=300; W[1]=760; W[2]=400; W[3]=210; W[4]=212; W[5]=214
      W[6]=150; W[7]=158; W[8]=168; W[9]=196; W[10]=200; W[11]=205; W[12]=90; W[13]=110
  }
  let l: i64 = wg_isqrt(W[0]*W[0]+W[1]*W[1]+W[2]*W[2])
  if l > 0 { W[0]=W[0]*WG_MAGIC_1024/l; W[1]=W[1]*WG_MAGIC_1024/l; W[2]=W[2]*WG_MAGIC_1024/l }
  return 0
179}
180
181// sun penumbra at a surface point (the soft-shadow march, shared by the pixel loop AND the GI cache): march
182// toward the sun tracking min(clearance/dist); 0 = fully shadowed .. 1024 = fully lit. Wp = weather (sun dir).
183func wg_sun_pen(seed: i64, hx: i64, hy: i64, hz: i64, Wp: *i64) -> i64 {
  var pen: i64 = WG_MAGIC_1024
  var sh2: i64 = 300
  var ss: i64 = 0
  while ss < 30 {
      let qx: i64 = hx + Wp[0]*sh2/WG_MAGIC_1024
      let qy: i64 = hy + Wp[1]*sh2/WG_MAGIC_1024
      let qz: i64 = hz + Wp[2]*sh2/WG_MAGIC_1024
      let clr: i64 = qy - wg_terrain_h(qx, qz, seed) + 10
      if clr < 0 { pen = 0; ss = 999 }
      else {
          let p2: i64 = clr*WG_MAGIC_32768/sh2
          if p2 < pen { pen = p2 }
          sh2 = sh2 + 160 + sh2/9
          if qy > WG_MAGIC_2900 { ss = 999 }
      }
      if ss != 999 { ss = ss + 1 }
  }
  if pen > WG_MAGIC_1024 { pen = WG_MAGIC_1024 }
  return pen
203}
204
205// ★R3 GI: a SINGLE-BOUNCE IRRADIANCE CACHE (the classic technique, integer): a coarse world grid stores each
206// cell's SUN-LIT outgoing radiance (albedo x direct light); pixels gather from nearby cells with cosine + falloff
207// weighting -> coloured bounce light (sunlit grass bleeds green into shade). HONEST LABEL: one bounce, no
208// bounce-visibility test, coarse cells -- an approximation, not path tracing. wg_set_gi(0) disables (byte-
209// identical off path).
210const GI_N: i64 = 96                 // cells per axis
211const GI_CS: i64 = 500               // world units per cell
212const GI_X0: i64 = 0 - 24000         // grid origin (covers the visible near field)
213const GI_Z0: i64 = 0
214static WG_GION: i64
215static WG_GIC: i64                   // cache ptr: GI_N*GI_N cells x 2 i64 {packed rgb radiance, height}
216func wg_set_gi(on: i64) -> i64 { WG_GION = on; return 0 }
217func wg_gi_build(seed: i64, biome: i64, Wp: *i64) -> i64 {
  if WG_GIC == 0 { WG_GIC = sys_mmap(GI_N*GI_N*2*8) as i64 }
  let C: *i64 = WG_GIC as *i64
  var j: i64 = 0
  while j < GI_N {
      var i: i64 = 0
      while i < GI_N {
          let wx: i64 = GI_X0 + i*GI_CS + GI_CS/2
          let wz: i64 = GI_Z0 + j*GI_CS + GI_CS/2
          let hh: i64 = wg_terrain_h(wx, wz, seed)
          // cell normal (coarse)
          let e: i64 = 120
          let hl: i64 = wg_terrain_h(wx-e, wz, seed); let hr2: i64 = wg_terrain_h(wx+e, wz, seed)
          let hd: i64 = wg_terrain_h(wx, wz-e, seed); let hu: i64 = wg_terrain_h(wx, wz+e, seed)
          var nx: i64 = (hl-hr2)*WG_MAGIC_1024/(2*e); var ny: i64 = WG_MAGIC_1024; var nz: i64 = (hd-hu)*WG_MAGIC_1024/(2*e)
          let nl: i64 = wg_isqrt(nx*nx+ny*ny+nz*nz)
          if nl > 0 { nx=nx*WG_MAGIC_1024/nl; ny=ny*WG_MAGIC_1024/nl; nz=nz*WG_MAGIC_1024/nl }
          // cell albedo (low-frequency biome palette: grass/rock/sand/snow by height+slope, no speckle)
          var cr: i64 = 70; var cg: i64 = 104; var cb: i64 = 50
          if biome == 1 { cr=196; cg=160; cb=110 }
          if biome == 2 { cr=214; cg=224; cb=236 }
          if biome == 3 { cr=150; cg=104; cb=44 }
          var snowline: i64 = SNOW
          if biome == 2 { snowline = 300 }
          if ny < 640 { cr=118; cg=104; cb=94 }
          if biome != 1 { if hh > snowline { if ny > 600 { cr=234; cg=240; cb=248 } } }
          if hh < WATER { cr=24; cg=74; cb=116 }
          // direct sun radiance at the cell (Lambert x penumbra), plus a small ambient floor
          var nd: i64 = (nx*Wp[0]+ny*Wp[1]+nz*Wp[2])/WG_MAGIC_1024
          if nd < 0 { nd = 0 }
          var pen: i64 = WG_MAGIC_1024
          if hh >= WATER { pen = wg_sun_pen(seed, wx, hh+14, wz, Wp) }
          let lit: i64 = 20 + nd*95*pen/WG_MAGIC_1048576
          var rr: i64 = cr*lit/100
          var rg: i64 = cg*lit/100
          var rb: i64 = cb*lit/100
          if rr > 255 { rr = 255 }
          if rg > 255 { rg = 255 }
          if rb > 255 { rb = 255 }
          C[(j*GI_N+i)*2] = rr + rg*256 + rb*WG_MAGIC_65536
          C[(j*GI_N+i)*2+1] = hh
          i = i + 1
      }
      j = j + 1
  }
  return 0
263}
264// gather bounce irradiance at a surface point with unit normal (nx,ny,nz fx1024). out[0..2] = rgb irradiance.
265func wg_gi_gather(hx: i64, hy: i64, hz: i64, nx: i64, ny: i64, nz: i64, out: *i64) -> i64 {
  out[0]=0; out[1]=0; out[2]=0
  if WG_GION == 0 { return 0 }
  if WG_GIC == 0 { return 0 }
  let C: *i64 = WG_GIC as *i64
  let ci: i64 = (hx - GI_X0) / GI_CS
  let cj: i64 = (hz - GI_Z0) / GI_CS
  if ci < 2 { return 0 }
  if cj < 2 { return 0 }
  if ci > GI_N-3 { return 0 }
  if cj > GI_N-3 { return 0 }
  var sr: i64 = 0
  var sg: i64 = 0
  var sb: i64 = 0
  var wsum: i64 = 0
  var oj: i64 = 0 - 2
  while oj <= 2 {
      var oi: i64 = 0 - 2
      while oi <= 2 {
          var ring: i64 = oi
          if ring < 0 { ring = 0 - ring }
          var aj: i64 = oj
          if aj < 0 { aj = 0 - aj }
          if aj > ring { ring = aj }
          if ring >= 1 {                                       // exclude the self cell; use rings 1-2
              let ii: i64 = ci + oi
              let jj: i64 = cj + oj
              let crad: i64 = C[(jj*GI_N+ii)*2]
              let chh: i64 = C[(jj*GI_N+ii)*2+1]
              let dxg: i64 = (GI_X0 + ii*GI_CS + GI_CS/2) - hx
              let dyg: i64 = chh - hy
              let dzg: i64 = (GI_Z0 + jj*GI_CS + GI_CS/2) - hz
              let dl: i64 = wg_isqrt(dxg*dxg + dyg*dyg + dzg*dzg)
              if dl > 60 {
                  var cosr: i64 = (nx*dxg + ny*dyg + nz*dzg)/dl        // fx1024 cos at the receiver
                  if cosr > 0 {
                      let fall: i64 = GI_CS*WG_MAGIC_1024/(GI_CS + dl)          // gentle distance falloff (fx1024)
                      let w: i64 = cosr*fall/WG_MAGIC_1024
                      sr = sr + (crad & 255)*w
                      sg = sg + ((crad >> 8) & 255)*w
                      sb = sb + ((crad >> 16) & 255)*w
                      wsum = wsum + WG_MAGIC_1024
                  }
              }
          }
          oi = oi + 1
      }
      oj = oj + 1
  }
  if wsum == 0 { return 0 }
  out[0] = sr/wsum
  out[1] = sg/wsum
  out[2] = sb/wsum
  return 0
319}
320
321func wg_sky(dx: i64, dy: i64, dz: i64, Wp: *i64, oc: *i64) -> i64 {
  var up: i64 = dy; if up<0 {up=0}
  let zr: i64 = Wp[6]; let zg: i64 = Wp[7]; let zb: i64 = Wp[8]
  let hr: i64 = Wp[9]; let hg: i64 = Wp[10]; let hb: i64 = Wp[11]
  var r: i64 = hr + (zr-hr)*up/WG_MAGIC_1024; var g: i64 = hg + (zg-hg)*up/WG_MAGIC_1024; var b: i64 = hb + (zb-hb)*up/WG_MAGIC_1024
  // sun glow + disk
  let sd: i64 = (dx*Wp[0]+dy*Wp[1]+dz*Wp[2])/WG_MAGIC_1024
  if sd > 800 {
      let gl: i64 = (sd-800)*100/224
      r = r + (Wp[3]-r)*gl/100; g = g + (Wp[4]-g)*gl/100; b = b + (Wp[5]-b)*gl/100
  }
  if sd > 1012 { r=Wp[3]; g=Wp[4]; b=Wp[5] }
  // procedural clouds (fBm on the ray projected to a high plane)
  if dy > 40 {
      let px: i64 = dx*WG_MAGIC_3000/dy; let pz: i64 = dz*WG_MAGIC_3000/dy
      let cs: i64 = wg_cloud_sheet(px, pz, Wp[13])   // PG22: the sheet by name, one coverage law with the volume
      if cs > 0 {
          let cf: i64 = wg_min(cs*100/200, 100) * up/WG_MAGIC_1024
          r = r + (238-r)*cf/100; g = g + (240-g)*cf/100; b = b + (242-b)*cf/100
      }
  }
  oc[0]=wg_clamp(r,0,255); oc[1]=wg_clamp(g,0,255); oc[2]=wg_clamp(b,0,255)
  return 0
344}
345
346// ★R1 DIVERSITY: BIOMES (census critic: "1 fBm biome family"). biome: 0 TEMPERATE (the original) · 1 DESERT
347// (sand/red-rock, no snow) · 2 ARCTIC (snow-dominant, ice water) · 3 AUTUMN (warm foliage). Same terrain
348// machinery; a biome = a palette + snowline row.
349// ★R2 GT ANNOTATIONS: the renderer emits CV ground truth alongside the image (their GroundTruthAnnotations
350// use-case): seg (0 sky / 1 terrain / 2 water), nrm (surface normal packed rgb: 128 + n*127/1024 per axis;
351// 0 for sky), depth (hit distance; BIG for sky). Occlusion boundaries derive from depth discontinuities.
352// ★R4 CAMERA RIG: cam = [dcamx, dcamy, dcamz, yaw] offsets/orientation over the auto terrain-following base
353// (cam 0/absent -> the original fixed +z view, byte-identical). A trajectory is a sequence of cam vectors ->
354// animation; reprojecting a pixel's world point through a second cam -> exact optical-flow GT (see wg_project).
355// render a world. Writes fb (WG_W*WG_H) + depth + seg + nrm.
356func wg_cam_base_y(seed: i64) -> i64 { return wg_max(WATER, wg_terrain_h(0,0,seed)) + WG_MAGIC_1050 }
357func worldgen_render_full(seed: i64, mode: i64, biome: i64, cam: *i64, fb: *i64, depth: *i64, seg: *i64, nrm: *i64) -> i64 {
  let Wp: *i64 = sys_mmap(32*8) as *i64
  wg_weather(mode, Wp)
  if WG_GION == 1 { wg_gi_build(seed, biome, Wp) }        // R3: refresh the bounce cache for this frame
  let gio: *i64 = sys_mmap(32) as *i64
  let oc: *i64 = sys_mmap(32) as *i64
  let camx: i64 = cam[0]
  let camy: i64 = wg_cam_base_y(seed) + cam[1]
  let camz0: i64 = cam[2]
  let yaw: i64 = cam[3]
  let sy4: i64 = it_sin4096(yaw)
  let cy4: i64 = it_cos4096(yaw)
  var py: i64 = 0
  while py < WG_H {
      var px: i64 = 0
      while px < WG_W {
          let sxo: i64 = px - WG_W/2
          let syo: i64 = (WG_H/2 - py) - WG_HORIZON
          var dx: i64 = WG_FOCAL*sy4/WG_MAGIC_4096 + sxo*cy4/WG_MAGIC_4096
          var dy: i64 = syo
          var dz: i64 = WG_FOCAL*cy4/WG_MAGIC_4096 - sxo*sy4/WG_MAGIC_4096
          let dl: i64 = wg_isqrt(dx*dx+dy*dy+dz*dz)
          dx = dx*WG_MAGIC_1024/dl; dy = dy*WG_MAGIC_1024/dl; dz = dz*WG_MAGIC_1024/dl
          // march the heightfield
          var t: i64 = 200
          var hit: i64 = 0
          var hx: i64 = 0; var hy: i64 = 0; var hz: i64 = 0; var hh: i64 = 0
          var step: i64 = 0
          while step < 220 {
              let wx: i64 = camx + dx*t/WG_MAGIC_1024
              let wy: i64 = camy + dy*t/WG_MAGIC_1024
              let wz: i64 = camz0 + dz*t/WG_MAGIC_1024
              let th: i64 = wg_terrain_h(wx, wz, seed)
              if wy < th { hit=1; hx=wx; hy=wy; hz=wz; hh=th; step=WG_MAGIC_9999 }
              else { t = t + 55 + t/48; if t > WG_MAGIC_60000 { step=WG_MAGIC_9999 } }
              if step != WG_MAGIC_9999 { step = step + 1 }
          }
          var r: i64 = 0; var g: i64 = 0; var b: i64 = 0
          // water intercept (ray crosses y=WATER going down)
          var twater: i64 = 0
          if dy < 0 { twater = (WATER - camy)*WG_MAGIC_1024/dy }
          let water_in_front: i64 = (twater > 0) & ((hit == 0) | (twater < t))
          // decide surface
          var surf: i64 = 0   // 0 sky, 1 terrain, 2 water
          if hit == 1 { if hh >= WATER { surf = 1 } }
          if (surf == 0) & (water_in_front == 1) { surf = 2 }
          if (hit == 1) & (hh < WATER) & (water_in_front == 1) { surf = 2 }
404
          var dpt: i64 = WG_MAGIC_2000000000
          if surf == 1 { dpt = t }
          if surf == 2 { dpt = twater }
          depth[py*WG_W+px] = dpt
          seg[py*WG_W+px] = surf                              // GT: 0 sky / 1 terrain / 2 water
          var nrmv: i64 = 0                                    // GT normal (sky = 0)
          if surf == 2 { nrmv = 128 + 255*256 + 128*WG_MAGIC_65536 }    // water: straight up
          nrm[py*WG_W+px] = nrmv
413
          if surf == 1 {
              // terrain normal
              let e: i64 = 24
              let hl: i64 = wg_terrain_h(hx-e, hz, seed); let hr2: i64 = wg_terrain_h(hx+e, hz, seed)
              let hd: i64 = wg_terrain_h(hx, hz-e, seed); let hu: i64 = wg_terrain_h(hx, hz+e, seed)
              var nx: i64 = (hl-hr2)*WG_MAGIC_1024/(2*e); var ny: i64 = WG_MAGIC_1024; var nz: i64 = (hd-hu)*WG_MAGIC_1024/(2*e)
              // micro-relief bump from fine noise -> surface texture caught by the lighting (not a smooth blob)
              let bb0: i64 = wg_vnoise((hx+6)*256/55, hz*256/55, seed+31) - wg_vnoise((hx-6)*256/55, hz*256/55, seed+31)
              let bb1: i64 = wg_vnoise(hx*256/55, (hz+6)*256/55, seed+31) - wg_vnoise(hx*256/55, (hz-6)*256/55, seed+31)
              nx = nx - bb0*5/100; nz = nz - bb1*5/100
              let nl: i64 = wg_isqrt(nx*nx+ny*ny+nz*nz)
              // GT normal (unit, packed rgb) -- written before shading consumes nx/ny/nz
              if nl > 0 {
                  let ux2: i64 = nx*WG_MAGIC_1024/nl
                  let uy2: i64 = ny*WG_MAGIC_1024/nl
                  let uz2: i64 = nz*WG_MAGIC_1024/nl
                  nrm[py*WG_W+px] = (128 + ux2*127/WG_MAGIC_1024) + (128 + uy2*127/WG_MAGIC_1024)*256 + (128 + uz2*127/WG_MAGIC_1024)*WG_MAGIC_65536
              }
              if nl>0 { nx=nx*WG_MAGIC_1024/nl; ny=ny*WG_MAGIC_1024/nl; nz=nz*WG_MAGIC_1024/nl }
              var nd: i64 = (nx*Wp[0]+ny*Wp[1]+nz*Wp[2])/WG_MAGIC_1024    // fx1024 Lambert (0..WG_MAGIC_1024)
              if nd<0 {nd=0}
              // ★P3 SOFT SHADOWS (penumbra): the shared sun-march helper (also feeds the GI cache) --
              // edges soften with occluder distance; only DIRECT light is occluded (ambient stays).
              let pen: i64 = wg_sun_pen(seed, hx, hy, hz, Wp)
              // ★P3 r2 SKY-VISIBILITY ambient (cheap GI): surrounding ridges block skylight -> valleys and
              // hollows receive less ambient. Horizon slope sampled 4 directions x 3 distances; sv 0..1024.
              var slmax: i64 = 0
              var sd2: i64 = 0
              while sd2 < 4 {
                  var ddx: i64 = 0
                  var ddz: i64 = 0
                  if sd2 == 0 { ddx = 1 }
                  if sd2 == 1 { ddx = 0-1 }
                  if sd2 == 2 { ddz = 1 }
                  if sd2 == 3 { ddz = 0-1 }
                  var dq: i64 = 200
                  while dq <= WG_MAGIC_1800 {
                      let th2: i64 = wg_terrain_h(hx + ddx*dq, hz + ddz*dq, seed)
                      let sl: i64 = (th2 - hy) * WG_MAGIC_1024 / dq
                      if sl > slmax { slmax = sl }
                      dq = dq * 3
                  }
                  sd2 = sd2 + 1
              }
              if slmax > WG_MAGIC_1024 { slmax = WG_MAGIC_1024 }
              var sv: i64 = WG_MAGIC_1024 - slmax*6/10
              if sv < 420 { sv = 420 }
              let lit: i64 = 42*sv/WG_MAGIC_1024 + nd*82*pen/WG_MAGIC_1048576     // sky-vis ambient + penumbra-scaled direct
              // base colour by BIOME, with per-location vegetation variation
              let nv2: i64 = wg_vnoise(hx*256/WG_MAGIC_1500, hz*256/WG_MAGIC_1500, seed+99)
              var cr: i64 = 60 + nv2*44/WG_MAGIC_65536; var cg: i64 = 94 + nv2*50/WG_MAGIC_65536; var cb: i64 = 42 + nv2*22/WG_MAGIC_65536
              var rockr: i64 = 112; var rockg: i64 = 101; var rockb: i64 = 92
              var snowline: i64 = SNOW
              var snowon: i64 = 1
              if biome == 1 {                                           // DESERT: sand base, red rock, no snow
                  cr = 188 + nv2*36/WG_MAGIC_65536; cg = 154 + nv2*30/WG_MAGIC_65536; cb = 104 + nv2*18/WG_MAGIC_65536
                  rockr = 152; rockg = 96; rockb = 66
                  snowon = 0
              }
              if biome == 2 {                                           // ARCTIC: snow base, blue-grey rock
                  cr = 212 + nv2*24/WG_MAGIC_65536; cg = 222 + nv2*20/WG_MAGIC_65536; cb = 234 + nv2*14/WG_MAGIC_65536
                  rockr = 96; rockg = 106; rockb = 120
                  snowline = 300
              }
              if biome == 3 {                                           // AUTUMN: warm mixed foliage
                  cr = 128 + nv2*70/WG_MAGIC_65536; cg = 84 + nv2*44/WG_MAGIC_65536; cb = 30 + nv2*16/WG_MAGIC_65536
                  rockr = 118; rockg = 100; rockb = 86
              }
              // alpine: higher -> browner (vegetation thins out); skip where base is already snow/sand
              if biome == 0 { if hh > WG_MAGIC_1350 { let m: i64 = wg_min((hh-WG_MAGIC_1350)*100/WG_MAGIC_1100, 100); cr=cr+(124-cr)*m/100; cg=cg+(110-cg)*m/100; cb=cb+(94-cb)*m/100 } }
              if biome == 3 { if hh > WG_MAGIC_1350 { let m: i64 = wg_min((hh-WG_MAGIC_1350)*100/WG_MAGIC_1100, 100); cr=cr+(124-cr)*m/100; cg=cg+(104-cg)*m/100; cb=cb+(88-cb)*m/100 } }
              if ny < 640 { cr=rockr; cg=rockg; cb=rockb }              // steep -> exposed rock
              if hh < WATER+130 { cr=198; cg=186; cb=152 }              // shoreline sand
              if snowon == 1 { if (hh > snowline) & (ny > 600) { cr=234; cg=240; cb=248 } }   // snow: high AND gentle
              // fine surface speckle (grass blades / dirt / rock grain)
              let tex2: i64 = wg_vnoise(hx*256/24, hz*256/24, seed+53)
              let tv: i64 = (tex2-WG_MAGIC_32768)*26/WG_MAGIC_65536
              cr = cr + tv; cg = cg + tv*11/10; cb = cb + tv*6/10
              r = cr*lit/100; g = cg*lit/100; b = cb*lit/100
              // ★R3 GI: gather single-bounce irradiance from the cache; couple through the receiver albedo
              // (green light on green grass reinforces; green light on snow shows as a green tint -- physical)
              wg_gi_gather(hx, hy, hz, nx, ny, nz, gio)
              r = r + cr*gio[0]*3/512
              g = g + cg*gio[1]*3/512
              b = b + cb*gio[2]*3/512
              b = b + (WG_MAGIC_1024-pen)*9/WG_MAGIC_1024                          // shade is sky-lit -> subtle cool tint
              // atmospheric fog toward horizon-sky by distance
              let fog: i64 = wg_min(t*Wp[12]/WG_MAGIC_60000, 100)
              r = r + (Wp[9]-r)*fog/100; g = g + (Wp[10]-g)*fog/100; b = b + (Wp[11]-b)*fog/100
          }
          if surf == 2 {
              // water: deep blue blended with sky reflection + sun glint (arctic = icy pale)
              wg_sky(dx, 0-dy, dz, Wp, oc)                              // reflected sky (mirror y)
              var dwr: i64 = 24; var dwg: i64 = 74; var dwb: i64 = 116
              if biome == 2 { dwr = 118; dwg = 160; dwb = 190 }
              if biome == 1 { dwr = 30; dwg = 96; dwb = 104 }
              r = (dwr + oc[0])/2; g = (dwg + oc[1])/2; b = (dwb + oc[2])/2
              let sd: i64 = (dx*Wp[0]-dy*Wp[1]+dz*Wp[2])/WG_MAGIC_1024
              if sd > 990 { r=wg_min(r+120,255); g=wg_min(g+110,255); b=wg_min(b+90,255) }
              let fog: i64 = wg_min(twater*Wp[12]/WG_MAGIC_60000, 100)
              r = r + (Wp[9]-r)*fog/100; g = g + (Wp[10]-g)*fog/100; b = b + (Wp[11]-b)*fog/100
          }
          if surf == 0 { wg_sky(dx, dy, dz, Wp, oc); r=oc[0]; g=oc[1]; b=oc[2] }
          fb[py*WG_W+px] = wg_clamp(r,0,255) + wg_clamp(g,0,255)*256 + wg_clamp(b,0,255)*WG_MAGIC_65536
          px = px + 1
      }
      py = py + 1
  }
  return 0
523}
524// ★R4 camera helpers (the inverse pair the flow GT reuses, so gate + renderer share exact math):
525// wg_ray = the normalized fx1024 ray direction for a pixel (depends only on pixel + yaw);
526// wg_project = screen coords of a world point through cam=[dx,dy,dz,yaw] (returns -1 in out[2] if behind).
527func wg_ray(px: i64, py: i64, yaw: i64, out: *i64) -> i64 {
  let sy4: i64 = it_sin4096(yaw)
  let cy4: i64 = it_cos4096(yaw)
  let sxo: i64 = px - WG_W/2
  let syo: i64 = (WG_H/2 - py) - WG_HORIZON
  var dx: i64 = WG_FOCAL*sy4/WG_MAGIC_4096 + sxo*cy4/WG_MAGIC_4096
  var dy: i64 = syo
  var dz: i64 = WG_FOCAL*cy4/WG_MAGIC_4096 - sxo*sy4/WG_MAGIC_4096
  let dl: i64 = wg_isqrt(dx*dx+dy*dy+dz*dz)
  if dl > 0 { dx = dx*WG_MAGIC_1024/dl; dy = dy*WG_MAGIC_1024/dl; dz = dz*WG_MAGIC_1024/dl }
  out[0]=dx; out[1]=dy; out[2]=dz
  return 0
539}
540func wg_project(seed: i64, cam: *i64, Px: i64, Py: i64, Pz: i64, out: *i64) -> i64 {
  let camx: i64 = cam[0]
  let camy: i64 = wg_cam_base_y(seed) + cam[1]
  let camz0: i64 = cam[2]
  let yaw: i64 = cam[3]
  let sy4: i64 = it_sin4096(yaw)
  let cy4: i64 = it_cos4096(yaw)
  let rx: i64 = Px - camx
  let ry: i64 = Py - camy
  let rz: i64 = Pz - camz0
  let zc: i64 = (rx*sy4 + rz*cy4)/WG_MAGIC_4096            // forward distance
  out[2] = 0 - 1
  if zc <= 16 { return 0 }                         // behind the camera
  let xc: i64 = (rx*cy4 - rz*sy4)/WG_MAGIC_4096             // right offset
  out[0] = WG_W/2 + WG_FOCAL*xc/zc
  out[1] = WG_H/2 - WG_HORIZON - WG_FOCAL*ry/zc
  out[2] = zc
  return 0
558}
559
560// back-compat wrappers: fixed camera / no annotations / temperate biome / no depth buffer
561func worldgen_render_bd(seed: i64, mode: i64, biome: i64, fb: *i64, depth: *i64) -> i64 {
  let s: *i64 = sys_mmap(WG_W*WG_H*8) as *i64
  let n: *i64 = sys_mmap(WG_W*WG_H*8) as *i64
  let cam: *i64 = sys_mmap(4*8) as *i64            // [0,0,0,0] = the original fixed +z camera (identical)
  return worldgen_render_full(seed, mode, biome, cam, fb, depth, s, n)
566}
567func worldgen_render_d(seed: i64, mode: i64, fb: *i64, depth: *i64) -> i64 { return worldgen_render_bd(seed, mode, 0, fb, depth) }
568func worldgen_render(seed: i64, mode: i64, fb: *i64) -> i64 {
  let d: *i64 = sys_mmap(WG_W*WG_H*8) as *i64
  worldgen_render_bd(seed, mode, 0, fb, d)
  return 0
572}
573func wg_w() -> i64 { return WG_W }
574func wg_h() -> i64 { return WG_H }
nx_worldgen.nx source

`nx_worldgen.nx` source
