`nx_anat_sov.nx` source

↩ module page · 1094 lines · 61323 B
1// nx_anat_sov.nx -- ★SOVEREIGN NishiLang render of the 8-layer anatomical being (NXMSH2), the PRODUCT half of
2// GX-11: the integer twin of the CUDA benchmark (/world/anatomy_gpu). 100% integer, own f32 decoder, own
3// barycentric z-buffer rasterizer, own PNG -- NO CUDA, NO GPU, NO 3rd-party. Measured against the CUDA
4// reference by the SAME invariants: intact occludes the interior, explode shows all 8 systems, stereo has
5// horizontal disparity. Stereo is OFF-AXIS (parallel, convergence at the model) -- an UPGRADE over the
6// benchmark's toe-in (no keystone). Reads knowledge/being_full.nxmesh; writes a PNG + a JSON stats line.
7//   nx_anat_sov <mesh> <intact|explode|skin|layerN> <C|L|R> <W> <H> <out.png>
8// license_tier: ORIGINAL  expect_exit: 0
9import "nx_syscalls.nx"
10import "nx_png.nx"
11const AS_LIGHT_FALLOFF_K: i64 = 40000
12const AS_PERFUSION_DEN: i64 = 100000
13const AS_BHASKARA_K: i64 = 40500
14const AS_F32_MANT_MASK: i64 = 8388607
15const AS_F32_MANT_SCALE: i64 = 8388608
16const AS_HASH_P1: i64 = 73856093
17const AS_HASH_P2: i64 = 19349663
18const AS_HASH_P3: i64 = 83492791
19const AS_I32_MAX: i64 = 2147483647
20const AS_NOISE_A: i64 = 15731
21const AS_NOISE_B: i64 = 789221
22const AS_NOISE_C: i64 = 1376312589
23const AS_Q16_ONE: i64 = 65536
24const AS_MAGIC_2000000000: i64 = 2000000000
25const AS_KEY_LIGHT_X: i64 = 5423
26const AS_KEY_LIGHT_Y: i64 = 9487
27const AS_KEY_LIGHT_Z: i64 = 12206
28const AS_FILL_LIGHT_X: i64 = 10160
29const AS_FILL_LIGHT_Y: i64 = 4064
30const AS_FILL_LIGHT_Z: i64 = 12190
31const AS_LIT_CEIL: i64 = 1280
32const AS_Q10_ONE: i64 = 1024
33
34// ★seq630 ROOT FIX: positions were decoded to WHOLE model units (mul=1), so any mesh authored in metres
35// rather than millimetres collapsed EVERY coordinate to 0 -> degenerate AABB -> rad=0 -> smE=0 -> integer
36// divide-by-zero -> SIGFPE. (Found on Vh-f-heart, whose coords all lie within +-0.5.) Decoding positions at
37// posq sub-units keeps sub-unit meshes alive; the renderer auto-frames, so absolute scale is irrelevant
38// and only precision matters. Texture lookups divide back to model units so texel size is unchanged.
39const AS_POSQ0: i64 = 4096
40const AS_TARGET: i64 = 200000
41const AS_ZFAR: i64 = 2000000000
42const AS_Q14: i64 = 16384
43// ★A CRASH ON NO ARGS IS INDISTINGUISHABLE FROM A BROKEN CAPABILITY. The usage line at the head of this
44// file declares six REQUIRED arguments -- <mesh> <mode> <eye> <W> <H> <out.png> -- so the highest argv
45// index main must dereference unconditionally is 6 (outp). argc counts argv[0], so the minimum admissible
46// argc is that index + 1. DERIVED from the arity above, not chosen: change the usage line and this moves.
47const AS_ARGV_LAST_REQUIRED: i64 = 6
48const AS_ARGC_MIN: i64 = AS_ARGV_LAST_REQUIRED + 1
49const AS_EXIT_USAGE: i64 = 3          // 0 ok - 2 operational (cannot read mesh) - 3 usage, the estate's usage/SKIP code
50
51// ★AROUSAL PERFUSION HOOK (permil, 0 = OFF and the renderer behaves EXACTLY as before).
52// Declared at the top because a module flag read by a function defined above it resolves to
53// GARBAGE in this compiler -- the documented forward-static-ref trap.
54//
55// Physiology, not a tint: rising perfusion raises dermal oxyhaemoglobin, which absorbs strongly in
56// BLUE (Soret ~415nm) and GREEN (542/577nm) and only weakly above 600nm. So the arousal signature
57// is G and B falling while R barely moves -- the same Beer-Lambert asymmetry nx_arousal_skin_lib
58// derives, applied here to the REAL generated body instead of a private SDF proxy.
59// Set via as_set_perfusion(); every existing caller leaves it 0 and is unaffected.
60static AS_PERF: i64
61func as_set_perfusion(p: i64) -> i64 {
  var v: i64 = p
  if v < 0 { v = 0 }
  if v > 1000 { v = 1000 }
  AS_PERF = v
  return AS_PERF
67}
68func as_get_perfusion() -> i64 { return AS_PERF }
69
70// ★THE FLUSH HAS A PROPAGATION ORDER; A GLOBAL TINT IS NOT AROUSAL. The first cut of the hook above
71// scaled every skin pixel by the same AS_PERF, which reddens the whole body at once -- exactly the
72// "visually inert" defect nx_arousal_skin_lib warns about, reproduced in the renderer. Masters &
73// Johnson flush appears in a FIXED ORDER (genital -> submammary -> breast -> torso -> face ->
74// extremities), and that order is the diagnostic signal a therapist reads. Rendering it as one
75// uniform wash throws the information away.
76//
77// ★WHY STATURE FRACTION AND NOT ANCHOR LITERALS: nx_arousal_skin_lib's sk_anchor_* are fx1024
78// literals welded to the SDF proxy, which is why that lib could never be pointed at another rig.
79// Site here is derived from NORMALISED HEIGHT over the mesh's own AABB -- the same per-mille-of-
80// stature convention the anthropometric canon already uses -- so it is subject-independent BY
81// CONSTRUCTION: any body, any stature, any species with a canon reads its own sites correctly.
82// Thresholds are the SAME numbers sk_thresh() returns, so the two cannot drift.
83static AS_YMIN: i64
84static AS_YSPAN: i64
85static AS_XCTR: i64
86static AS_XHALF: i64
87func as_set_body_span(ymin: i64, ymax: i64, xctr: i64, xhalf: i64) -> i64 {
  AS_YMIN = ymin
  AS_YSPAN = ymax - ymin
  if AS_YSPAN < 1 { AS_YSPAN = 1 }
  AS_XCTR = xctr
  AS_XHALF = xhalf
  if AS_XHALF < 1 { AS_XHALF = 1 }
  return AS_YSPAN
95}
96// M&J site thresholds (identical to sk_thresh) at their stature fractions, inverse-distance weighted
97// so boundaries are CONTINUOUS -- a hard per-site lookup paints rectangular bands on skin.
98// ★THE FLUSH-SITE CANON IS DATA (2026-08-14). These two functions were an if-ladder: a five-row lookup
99// table written as control flow. Ten anatomical numbers that could not be revised, reviewed or varied
100// without a rebuild -- and a sixth site could not be expressed at all, because the ladder ends in an
101// unconditional return. They now live in knowledge/anat_flush_sites.conf, and the site COUNT comes from
102// the file, so adding a site is a data edit.
103// ★THE WEIGHTING ARITHMETIC BELOW IS UNCHANGED TERM FOR TERM: the acceptance proof for this move is a
104// BIT-IDENTICAL render against the banked pre-refactor PNG.
105static AS_NSITE: i64
106static AS_ASF: i64
107static AS_ATH: i64
108static AS_EXTTH: i64
109static AS_FBTH: i64
110func as_rdint(b: *u8, pos: *i64, end: i64) -> i64 {
  var i: i64 = pos[0]
  var go: i64 = 1
  while go == 1 {
      if i >= end { go = 0 } else {
          let c: i64 = b[i] as i64
          if c == 45 { go = 0 } else { if c >= 48 { if c <= 57 { go = 0 } else { i = i+1 } } else { i = i+1 } }
      }
  }
  var sg: i64 = 1
  if i < end { if (b[i] as i64) == 45 { sg = 0-1; i = i+1 } }
  var v: i64 = 0
  var g2: i64 = 1
  while g2 == 1 {
      if i >= end { g2 = 0 } else {
          let c2: i64 = b[i] as i64
          if c2 >= 48 { if c2 <= 57 { v = v*10 + (c2-48); i = i+1 } else { g2 = 0 } } else { g2 = 0 }
      }
  }
  pos[0] = i
  return v*sg
131}
132func as_load_sites() -> i64 {
  if AS_NSITE > 0 { return AS_NSITE }
  let asf: *i64 = sys_mmap(64*8) as *i64
  let ath: *i64 = sys_mmap(64*8) as *i64
  AS_ASF = asf as i64
  AS_ATH = ath as i64
  let ln: *i64 = sys_mmap(16) as *i64
  let b: *u8 = sys_read_file("knowledge/anat_flush_sites.conf" as *u8, ln)
  if (b as i64) == 0 {
      as_hw("ANAT-REFUSE cannot read knowledge/anat_flush_sites.conf -- the flush-site canon is REQUIRED, refusing to render on an empty site table\n" as *u8)
      sys_exit(7)
  }
  let len: i64 = ln[0]
  let pos: *i64 = sys_mmap(16) as *i64
  var n: i64 = 0
  var i: i64 = 0
  var bol: i64 = 1
  while i < len {
      if bol == 1 {
          if (b[i] as i64) == 65 {
              pos[0] = i+1
              let idx: i64 = as_rdint(b,pos,len)
              let sfv: i64 = as_rdint(b,pos,len)
              let thv: i64 = as_rdint(b,pos,len)
              if idx >= 0 { if idx < 64 {
                  asf[idx] = sfv
                  ath[idx] = thv
                  if idx + 1 > n { n = idx + 1 }
              } }
              i = pos[0]
          }
          if (b[i] as i64) == 88 {
              pos[0] = i+1
              AS_EXTTH = as_rdint(b,pos,len)
              AS_FBTH = as_rdint(b,pos,len)
              i = pos[0]
          }
      }
      if (b[i] as i64) == 10 { bol = 1 } else { bol = 0 }
      i = i + 1
  }
  if n < 1 {
      as_hw("ANAT-REFUSE anat_flush_sites.conf declares no A rows -- refusing to render on an empty site table\n" as *u8)
      sys_exit(7)
  }
  AS_NSITE = n
  return n
179}
180func as_anchor_sf(i: i64) -> i64 { let a: *i64 = AS_ASF as *i64; return a[i] }
181func as_anchor_th(i: i64) -> i64 { let a: *i64 = AS_ATH as *i64; return a[i] }
182// sf = stature fraction permil (0 sole, 1000 crown); latp = lateral fraction permil from midline.
183// Extremities (threshold 800) flush LAST: limbs are reached by blending toward that anchor with
184// lateral distance, so an arm held away from the torso is correctly late, not painted by height.
185func as_flush_thresh(sf: i64, latp: i64) -> i64 {
  // the site COUNT is the file's, not a literal 5: a canon that declares a sixth site now gets one.
  let ns: i64 = as_load_sites()
  var num: i64 = 0
  var den: i64 = 0
  var i: i64 = 0
  while i < ns {
      let d: i64 = (sf - as_anchor_sf(i)) / 8
      let d2: i64 = d*d + 4
      let w: i64 = AS_LIGHT_FALLOFF_K / d2
      num = num + w * as_anchor_th(i)
      den = den + w
      i = i + 1
  }
  var th: i64 = AS_FBTH
  if den > 0 { th = num / den }
  // lateral blend toward the extremity threshold
  var lb: i64 = latp
  if lb > 1000 { lb = 1000 }
  if lb < 0 { lb = 0 }
  return (th * (1000 - lb) + AS_EXTTH * lb) / 1000
206}
207
208func as_streq(a: *u8, b: *u8) -> i64 {
  var i: i64 = 0
  while a[i] != (0 as u8) { if a[i] != b[i] { return 0 } i = i + 1 }
  if b[i] != (0 as u8) { return 0 }
  return 1
213}
214func as_satoi(s: *u8) -> i64 {
  var i: i64 = 0; var n: i64 = 0; var sg: i64 = 1
  if s[0] == (45 as u8) { sg = 0 - 1; i = 1 }
  while s[i] != (0 as u8) { let c: i64 = s[i] as i64; if c >= 48 { if c <= 57 { n = n*10 + (c-48) } } i = i + 1 }
  return n*sg
219}
220func as_hw(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n+1 } sys_write(1, s, n); return 0 }
221func as_pn(v: i64) -> i64 {
  let b: *u8 = sys_mmap(32); var x: i64 = v; var ng: i64 = 0
  if x < 0 { ng = 1; x = 0 - x }
  var i: i64 = 31
  if x == 0 { b[i] = 48 as u8; i = i - 1 }
  while x > 0 { b[i] = (48 + x%10) as u8; x = x/10; i = i - 1 }
  if ng == 1 { b[i] = 45 as u8; i = i - 1 }
  sys_write(1, (b as i64 + i + 1) as *u8, 31 - i); return 0
229}
230func as_rdbits(b: *u8, o: i64) -> i64 {
  return (b[o] as i64) | ((b[o+1] as i64)<<8) | ((b[o+2] as i64)<<16) | ((b[o+3] as i64)<<24)
232}
233// decode IEEE-754 float32 at byte offset o, return round(value * mul) as integer
234func as_f32mul(b: *u8, o: i64, mul: i64) -> i64 {
  let bits: i64 = as_rdbits(b, o)
  let sign: i64 = (bits>>31) & 1
  let exp: i64 = (bits>>23) & 255
  let mant: i64 = bits & AS_F32_MANT_MASK
  if exp == 0 { return 0 }
  let m: i64 = (mant | AS_F32_MANT_SCALE) * mul
  var e: i64 = exp - 127 - 23
  var v: i64 = 0
  if e >= 0 { v = m << e } else { let sh: i64 = 0 - e; v = (m + (1 << (sh-1))) >> sh }
  if sign == 1 { v = 0 - v }
  return v
246}
247func as_isqrt(v: i64) -> i64 { if v <= 0 { return 0 } var x: i64 = v; var y: i64 = (x+1)/2; while y < x { x = y; y = (x + v/x)/2 } return x }
248// ---- GX-13 integer texture engine: lattice value-noise FBM over WORLD position ----
249// The hardened grader (ns_assess2) names scale (multi-scale detail) + MSCN as our weak axes; real surfaces
250// carry detail at every octave. 4 octaves of smooth value noise = coherent (NOT white noise) so the
251// coherence gate is respected by construction.
252func tx_h3(ix: i64, iy: i64, iz: i64) -> i64 {
  var v: i64 = (ix*AS_HASH_P1) ^ (iy*AS_HASH_P2) ^ (iz*AS_HASH_P3)
  v = v & AS_I32_MAX
  v = (v * (v*v*AS_NOISE_A + AS_NOISE_B) + AS_NOISE_C) & AS_I32_MAX
  return (v >> 16) & 255
257}
258func tx_floordiv(x: i64, s: i64) -> i64 { var q: i64 = x/s; if x < 0 { if x % s != 0 { q = q - 1 } } return q }
259func tx_lerp(a: i64, b: i64, t8: i64) -> i64 { return a + (b-a)*t8/256 }
260func tx_vnoise(x: i64, y: i64, z: i64, s: i64) -> i64 {
  let lx: i64 = tx_floordiv(x,s); let ly: i64 = tx_floordiv(y,s); let lz: i64 = tx_floordiv(z,s)
  var fx: i64 = (x - lx*s)*256/s; var fy: i64 = (y - ly*s)*256/s; var fz: i64 = (z - lz*s)*256/s
  fx = fx*fx*(768 - 2*fx)/AS_Q16_ONE; fy = fy*fy*(768 - 2*fy)/AS_Q16_ONE; fz = fz*fz*(768 - 2*fz)/AS_Q16_ONE
  let c000: i64 = tx_h3(lx,ly,lz);     let c100: i64 = tx_h3(lx+1,ly,lz)
  let c010: i64 = tx_h3(lx,ly+1,lz);   let c110: i64 = tx_h3(lx+1,ly+1,lz)
  let c001: i64 = tx_h3(lx,ly,lz+1);   let c101: i64 = tx_h3(lx+1,ly,lz+1)
  let c011: i64 = tx_h3(lx,ly+1,lz+1); let c111: i64 = tx_h3(lx+1,ly+1,lz+1)
  let a0: i64 = tx_lerp(tx_lerp(c000,c100,fx), tx_lerp(c010,c110,fx), fy)
  let a1: i64 = tx_lerp(tx_lerp(c001,c101,fx), tx_lerp(c011,c111,fx), fy)
  return tx_lerp(a0, a1, fz)
271}
272func tx_fbm(x: i64, y: i64, z: i64) -> i64 {
  let n1: i64 = tx_vnoise(x,y,z,128)
  let n2: i64 = tx_vnoise(x,y,z,40)
  let n3: i64 = tx_vnoise(x,y,z,12)
  let n4: i64 = tx_vnoise(x,y,z,4)
  return (n1*3 + n2*3 + n3*2 + n4*2) / 10
278}
279// ★MULTI-VIEW judge support: Bhaskara-I degree sine, Q14, exact at 0/30/90/150/180. A single view is blind
280// to depth-axis error entirely -- body THICKNESS never appears in a front silhouette -- so the judge must be
281// able to turn the model. Our own integer trig, no float, no lookup-table literals.
282func as_sin_fill(t: *i64) -> i64 {
  var d: i64 = 0
  while d < 180 { let P: i64 = d*(180-d); t[d] = AS_Q14*4*P/AS_BHASKARA_K; t[d+180] = 0-t[d]; d = d+1 }
  return 0
286}
287func as_wrap(d: i64) -> i64 { var x: i64 = d % 360; if x < 0 { x = x + 360 } return x }
288func as_min(a: i64, b: i64) -> i64 { if a < b { return a } return b }
289func as_max(a: i64, b: i64) -> i64 { if a > b { return a } return b }
290
291// ---- GX-39 piece 2: SCREEN-SPACE AMBIENT OCCLUSION over the finished z-buffer (contact darkening) ----
292// PORTED from nx_swgpu sg_ssao (the opposite-pairs design) per the debt row -- port, not rewrite.
293// Why pairs: a naive "is my neighbour nearer" test darkens every receding plane (the classic SSAO false
294// positive that greys floors). In a genuine cavity BOTH opposite samples are nearer; on a plane or slope
295// one is nearer and the other farther, so it scores zero. No normal buffer, nothing added to the raster
296// inner loop -- a pure post-pass, so it cannot regress the rasterizer.
297// SCALE-FREE bounds (bounds are DERIVED, never taste): the bias (depth-noise floor) and far cutoff
298// (a distant surface is a DIFFERENT object, not an occluder -- this is what stops silhouettes being
299// ringed with false shadow) derive from the MEASURED body depth range of the frame (lb>=0 pixels only,
300// so the receding floor cannot inflate the windows), and the ring radii derive from H, so one code path
301// grounds any mesh scale at any render size. AO still APPLIES to floor pixels -- that is exactly what
302// plants the feet (contact darkening where body meets ground).
303// Runs ONLY on the shaded path (never nmap: the mechanistic shape-judge input stays pure geometry), so
304// the geometric bench cannot move BY CONSTRUCTION -- and it is proven anyway by byte-identical
305// nx_bodybench output before/after.
306const AS_AO_STRENGTH: i64 = 140      // occ 8/8 attenuates to (256-140)/256 before the floor below
307const AS_AO_ATT_FLOOR: i64 = 64      // never crush a cavity to black (the donor's floor, kept)
308
309// separable integer box blur over an N x N grid (edge-clamped) -- the soft-shadow field builder
310func as_boxblur(src: *i64, tmp: *i64, dst: *i64, N: i64, r: i64) -> i64 {
  let span: i64 = 2*r + 1
  var z4: i64 = 0
  while z4 < N {
      var x4: i64 = 0
      while x4 < N {
          var acc: i64 = 0
          var k4: i64 = 0 - r
          while k4 <= r {
              var xx: i64 = x4 + k4
              if xx < 0 { xx = 0 }
              if xx >= N { xx = N - 1 }
              acc = acc + src[z4*N + xx]
              k4 = k4 + 1
          }
          tmp[z4*N + x4] = acc/span
          x4 = x4 + 1
      }
      z4 = z4 + 1
  }
  z4 = 0
  while z4 < N {
      var x4: i64 = 0
      while x4 < N {
          var acc: i64 = 0
          var k4: i64 = 0 - r
          while k4 <= r {
              var zz: i64 = z4 + k4
              if zz < 0 { zz = 0 }
              if zz >= N { zz = N - 1 }
              acc = acc + tmp[zz*N + x4]
              k4 = k4 + 1
          }
          dst[z4*N + x4] = acc/span
          x4 = x4 + 1
      }
      z4 = z4 + 1
  }
  return 0
349}
350func as_ssao(fb: *i64, zb: *i64, lb: *i64, W2: i64, H2: i64) -> i64 {
  let npx2: i64 = W2*H2
  var zmn: i64 = AS_ZFAR; var zmx: i64 = 0
  var q2: i64 = 0
  while q2 < npx2 {
      if lb[q2] >= 0 {
          let d0: i64 = zb[q2]
          if d0 < zmn { zmn = d0 }
          if d0 > zmx { zmx = d0 }
      }
      q2 = q2 + 1
  }
  let rng: i64 = zmx - zmn
  if rng < 128 { return 0 }                 // degenerate/flat frame: nothing meaningful to occlude
  let bias: i64 = rng/128                   // below ~0.8pct of body depth it is depth noise, not a cavity
  let far2: i64 = rng/6                     // beyond ~17pct of body depth it is a different surface
  var r1: i64 = H2/128; if r1 < 2 { r1 = 2 }   // tight ring: contact seams
  var rw: i64 = H2/56;  if rw < 4 { rw = 4 }   // wide ring: broad cavities
  let d1r: i64 = r1*707/1000 + 1
  let dwr: i64 = rw*707/1000 + 1
  let ax: *i64 = sys_mmap(16*8) as *i64
  let ay: *i64 = sys_mmap(16*8) as *i64
  // 8 opposite pairs: entries s and s+8 are mirrors (the donor's layout, radii derived above)
  ax[0]=r1;    ay[0]=0;      ax[1]=d1r;    ay[1]=d1r;    ax[2]=0;  ay[2]=r1;     ax[3]=0-d1r;  ay[3]=d1r
  ax[4]=rw;    ay[4]=0;      ax[5]=dwr;    ay[5]=dwr;    ax[6]=0;  ay[6]=rw;     ax[7]=0-dwr;  ay[7]=dwr
  ax[8]=0-r1;  ay[8]=0;      ax[9]=0-d1r;  ay[9]=0-d1r;  ax[10]=0; ay[10]=0-r1;  ax[11]=d1r;   ay[11]=0-d1r
  ax[12]=0-rw; ay[12]=0;     ax[13]=0-dwr; ay[13]=0-dwr; ax[14]=0; ay[14]=0-rw;  ax[15]=dwr;   ay[15]=0-dwr
  var y3: i64 = 0
  while y3 < H2 {
      var x3: i64 = 0
      while x3 < W2 {
          let idx3: i64 = y3*W2 + x3
          let d: i64 = zb[idx3]
          if d < AS_ZFAR {
              var occ: i64 = 0
              var s: i64 = 0
              while s < 8 {
                  var near1: i64 = 0
                  var near2: i64 = 0
                  let x1: i64 = x3 + ax[s]
                  let y1: i64 = y3 + ay[s]
                  if x1 >= 0 { if x1 < W2 { if y1 >= 0 { if y1 < H2 {
                      let dd1: i64 = zb[y1*W2 + x1]
                      if dd1 < AS_ZFAR { let df: i64 = d - dd1; if df > bias { if df < far2 { near1 = 1 } } }
                  }}}}
                  let x2: i64 = x3 + ax[s+8]
                  let y2: i64 = y3 + ay[s+8]
                  if x2 >= 0 { if x2 < W2 { if y2 >= 0 { if y2 < H2 {
                      let dd2: i64 = zb[y2*W2 + x2]
                      if dd2 < AS_ZFAR { let df2: i64 = d - dd2; if df2 > bias { if df2 < far2 { near2 = 1 } } }
                  }}}}
                  if near1 == 1 { if near2 == 1 { occ = occ + 1 } }   // BOTH sides nearer = a real cavity
                  s = s + 1
              }
              if occ > 0 {
                  var att: i64 = 256 - occ*AS_AO_STRENGTH/8
                  if att < AS_AO_ATT_FLOOR { att = AS_AO_ATT_FLOOR }
                  let v: i64 = fb[idx3]
                  let r: i64 = (v % 256)*att/256
                  let g: i64 = ((v/256) % 256)*att/256
                  let b: i64 = ((v/AS_Q16_ONE) % 256)*att/256
                  fb[idx3] = r + g*256 + b*AS_Q16_ONE
              }
          }
          x3 = x3 + 1
      }
      y3 = y3 + 1
  }
  return 0
419}
420
421// ---- GX-39 piece 4: DEPTH OF FIELD keyed on the finished z-buffer ----
422// The last light-transport piece the debt names. Photographic focus: the BODY (the measured lb>=0
423// depth band) stays sharp; floor and backdrop blur with distance from the focus plane, radius derived
424// from H and the measured body depth range (bounds-derived, never taste). Gather guard: a sample only
425// contributes if ITS OWN circle of confusion reaches the target pixel, so the sharp subject can never
426// smear into the background (the classic DoF halo artifact, foreclosed by construction). Shaded path
427// only -- the nmap shape-judge input stays pure geometry.
428func as_dof(fb: *i64, zb: *i64, lb: *i64, W2: i64, H2: i64) -> i64 {
  let npx2: i64 = W2*H2
  var zmn: i64 = AS_ZFAR; var zmx: i64 = 0; var zsum: i64 = 0; var zn: i64 = 0
  var q2: i64 = 0
  while q2 < npx2 {
      if lb[q2] >= 0 {
          let d0: i64 = zb[q2]
          if d0 < zmn { zmn = d0 }
          if d0 > zmx { zmx = d0 }
          zsum = zsum + d0; zn = zn + 1
      }
      q2 = q2 + 1
  }
  if zn < 1 { return 0 }
  let rng: i64 = zmx - zmn
  if rng < 128 { return 0 }
  let focus: i64 = zsum/zn
  var maxr: i64 = H2/192; if maxr < 2 { maxr = 2 }
  let cocb: *i64 = sys_mmap(npx2*8) as *i64      // circle of confusion per pixel (0 = in focus)
  let srcb: *i64 = sys_mmap(npx2*8) as *i64      // blur reads the unmodified frame
  q2 = 0
  while q2 < npx2 {
      srcb[q2] = fb[q2]
      var dz: i64 = zb[q2] - focus
      if dz < 0 { dz = 0 - dz }
      var coc: i64 = 0
      if dz > rng/2 { coc = (dz - rng/2)*maxr/(rng*2) }
      if coc > maxr { coc = maxr }
      cocb[q2] = coc
      q2 = q2 + 1
  }
  var y3: i64 = 0
  while y3 < H2 {
      var x3: i64 = 0
      while x3 < W2 {
          let idx3: i64 = y3*W2 + x3
          let c0: i64 = cocb[idx3]
          if c0 >= 1 {
              var ar: i64 = 0; var ag: i64 = 0; var ab: i64 = 0; var an: i64 = 0
              var dy6: i64 = 0 - c0
              while dy6 <= c0 {
                  var dx6: i64 = 0 - c0
                  while dx6 <= c0 {
                      let x6: i64 = x3 + dx6
                      let y6: i64 = y3 + dy6
                      if x6 >= 0 { if x6 < W2 { if y6 >= 0 { if y6 < H2 {
                          let si: i64 = y6*W2 + x6
                          var rr: i64 = dx6; if rr < 0 { rr = 0 - rr }
                          var r7: i64 = dy6; if r7 < 0 { r7 = 0 - r7 }
                          if r7 > rr { rr = r7 }
                          if cocb[si] >= rr {
                              let v: i64 = srcb[si]
                              ar = ar + (v % 256)
                              ag = ag + ((v/256) % 256)
                              ab = ab + ((v/AS_Q16_ONE) % 256)
                              an = an + 1
                          }
                      }}}}
                      dx6 = dx6 + 1
                  }
                  dy6 = dy6 + 1
              }
              if an > 0 { fb[idx3] = ar/an + (ag/an)*256 + (ab/an)*AS_Q16_ONE }
          }
          x3 = x3 + 1
      }
      y3 = y3 + 1
  }
  return 0
497}
498
499func main(argc: i64, argv: *i64) -> i64 {
  // ★GUARD argc BEFORE THE FIRST argv DEREFERENCE. Without this, `nx_anat_sov` with no arguments read
  // argv[1] off the end of the vector and died with SIGSEGV -- and a registered organ that crashes on
  // its usage path reads to every caller as "this capability is broken", not as "you called it wrong".
  if argc < AS_ARGC_MIN {
      as_hw("usage: nx_anat_sov <mesh> <intact|explode|skin|layerN> <C|L|R> <W> <H> <out.png> [nmap] [yawdeg] [fit] [perfusion_permil]\n" as *u8)
      return AS_EXIT_USAGE
  }
  let meshp: *u8 = argv[1] as *u8
  let mode: *u8 = argv[2] as *u8
  // argv[7]=="nmap" -> emit a NORMAL MAP instead of a shaded image (mechanistic shape-judge input)
  var nmap: i64 = 0
  if argc > 7 { let np7: *u8 = argv[7] as *u8; if np7[0] == (110 as u8) { nmap = 1 } }
  // argv[8] = yaw degrees about the vertical axis (multi-view judge)
  var yawd: i64 = 0
  if argc > 8 { yawd = as_satoi(argv[8] as *u8) }
  // argv[9]=="fit" -> height-only framing (fair, scale-normalised comparison for the judges)
  var fith: i64 = 0
  if argc > 9 { let f9: *u8 = argv[9] as *u8; if f9[0] == (102 as u8) { fith = 1 } }
  // argv[10] = AROUSAL PERFUSION in permil (absent or 0 => renderer behaves EXACTLY as before).
  // Physiology, not a tint: added dermal oxyhaemoglobin absorbs strongly in blue (Soret ~415nm)
  // and green (542/577nm) and only weakly above 600nm, so flush is G and B FALLING rather than
  // red being added. Colour-only, so the shape and detail judges cannot move.
  if argc > 10 { as_set_perfusion(as_satoi(argv[10] as *u8)) }
  let sinT: *i64 = sys_mmap(400*8) as *i64
  as_sin_fill(sinT)
  let ysin: i64 = sinT[as_wrap(yawd)]
  let ycos: i64 = sinT[as_wrap(yawd+90)]
  let eye: *u8 = argv[3] as *u8
  let W: i64 = as_satoi(argv[4] as *u8)
  let H: i64 = as_satoi(argv[5] as *u8)
  let outp: *u8 = argv[6] as *u8
531
  let lenp: *i64 = sys_mmap(16) as *i64
  let mb: *u8 = sys_read_file(meshp, lenp)
  if (mb as i64) == 0 { as_hw("{\x22error\x22:\x22cannot read mesh\x22}\n" as *u8); return 2 }
  // header
  let nlayers: i64 = as_rdbits(mb, 8)
  let ntris: i64 = as_rdbits(mb, 12)
  // layer table: name16 off4 cnt4 ; tris base after it
  let triBase: i64 = 16 + nlayers*24
  let lidBase: i64 = triBase + ntris*84
  // per-layer visibility + explode offset (x)
  let vis: *i64 = sys_mmap(nlayers*8) as *i64
  let loffx: *i64 = sys_mmap(nlayers*8) as *i64
  var L0: i64 = 0
  while L0 < nlayers { vis[L0] = 1; loffx[L0] = 0; L0 = L0 + 1 }
  var only: i64 = 0 - 1
  if as_streq(mode, "skin" as *u8) == 1 { only = 0 }
  if mode[0] == (108 as u8) { if mode[1] == (97 as u8) { only = as_satoi((mode as i64 + 5) as *u8) } } // "layerN"
  if only >= 0 { var i: i64 = 0; while i < nlayers { vis[i] = 0; i = i + 1 } vis[only] = 1 }
550
  // ★seq630 pass 0: MEASURE the mesh at a fixed high precision, then choose the working precision so the
  // model always spans ~AS_TARGET integer units. A metre-scale mesh and a millimetre-scale mesh then get
  // the SAME effective resolution -- scale-invariant by construction instead of assuming millimetres.
  var q0mn: i64 = AS_MAGIC_2000000000
  var q0mx: i64 = 0-AS_MAGIC_2000000000
  var t0: i64 = 0
  while t0 < ntris {
      let o0: i64 = triBase + t0*84
      var c0: i64 = 0
      while c0 < 3 {
          let vq: i64 = as_f32mul(mb, o0 + c0*4, AS_POSQ0)
          if vq < q0mn { q0mn = vq }
          if vq > q0mx { q0mx = vq }
          c0 = c0 + 1
      }
      t0 = t0 + 1
  }
  var span0: i64 = q0mx - q0mn
  if span0 < 1 { span0 = 1 }
  var posq: i64 = AS_POSQ0 * AS_TARGET / span0
  if posq < 1 { posq = 1 }
572
  // pass 1: full AABB over all verts -> centroid + radius
  var mnx: i64 = AS_MAGIC_2000000000; var mny: i64 = AS_MAGIC_2000000000; var mnz: i64 = AS_MAGIC_2000000000
  var mxx: i64 = 0-AS_MAGIC_2000000000; var mxy: i64 = 0-AS_MAGIC_2000000000; var mxz: i64 = 0-AS_MAGIC_2000000000
  var t: i64 = 0
  while t < ntris {
      var v: i64 = 0
      while v < 3 {
          let o: i64 = triBase + t*84 + v*12
          let x: i64 = as_f32mul(mb, o, posq); let y: i64 = as_f32mul(mb, o+4, posq); let z: i64 = as_f32mul(mb, o+8, posq)
          if x < mnx { mnx = x } if x > mxx { mxx = x }
          if y < mny { mny = y } if y > mxy { mxy = y }
          if z < mnz { mnz = z } if z > mxz { mxz = z }
          v = v + 1
      }
      t = t + 1
  }
  let cx0: i64 = (mnx+mxx)/2; let cy0: i64 = (mny+mxy)/2; let cz0: i64 = (mnz+mxz)/2
  var rad: i64 = (mxx-mnx)/2
  if (mxy-mny)/2 > rad { rad = (mxy-mny)/2 }
  if (mxz-mnz)/2 > rad { rad = (mxz-mnz)/2 }
  if rad < 1 { rad = 1 }                    // seq630: a degenerate mesh must never reach a divisor
  // explode offsets (fan along X), step 0.62*rad, centered
  if as_streq(mode, "explode" as *u8) == 1 {
      let step: i64 = (rad*62)/100
      var i: i64 = 0
      while i < nlayers { loffx[i] = (i*2 - (nlayers-1)) * step / 2; i = i + 1 }
  }
600
  // pass 2: visible AABB (centered + offset) -> framing
  var vmnx: i64 = AS_MAGIC_2000000000; var vmny: i64 = AS_MAGIC_2000000000; var vmnz: i64 = AS_MAGIC_2000000000
  var vmxx: i64 = 0-AS_MAGIC_2000000000; var vmxy: i64 = 0-AS_MAGIC_2000000000; var vmxz: i64 = 0-AS_MAGIC_2000000000
  t = 0
  while t < ntris {
      let L: i64 = as_rdbits(mb, lidBase + t*4) & 255
      if vis[L] == 1 {
          var v: i64 = 0
          while v < 3 {
              let o: i64 = triBase + t*84 + v*12
              let x: i64 = as_f32mul(mb,o,posq) - cx0 + loffx[L]
              let y: i64 = as_f32mul(mb,o+4,posq) - cy0
              let z: i64 = as_f32mul(mb,o+8,posq) - cz0
              if x < vmnx { vmnx = x } if x > vmxx { vmxx = x }
              if y < vmny { vmny = y } if y > vmxy { vmxy = y }
              if z < vmnz { vmnz = z } if z > vmxz { vmxz = z }
              v = v + 1
          }
      }
      t = t + 1
  }
  let halfW: i64 = (vmxx-vmnx)/2; let halfH: i64 = (vmxy-vmny)/2
  let vcx: i64 = (vmnx+vmxx)/2; let vcy: i64 = (vmny+vmxy)/2
  // arousal sites are read off THIS mesh's own extent, so the field follows whatever body is loaded
  as_set_body_span(vmny, vmxy, vcx, halfW)
  let FOCAL: i64 = H                            // tan(halffov_v)=0.5
  var dist: i64 = 2*halfH
  let dw: i64 = 2*halfW*H/W
  if dw > dist { dist = dw }
  dist = dist*118/100 + (vmxz-vmnz)/2
  // ★FAIR-RULER FIX: auto-framing that depends on WIDTH or DEPTH silently rescales the render, so a change
  // to body thickness moved the camera and shrank the figure -- the front silhouette score fell 834->624 from
  // a depth edit that cannot affect a front outline. That was the RULER moving, not the shape. 'fit' frames
  // on HEIGHT ALONE, so two meshes of the same stature render at the same scale and IoU measures shape only.
  if fith == 1 { dist = 2*halfH*118/100 }
  if dist < 1 { dist = 1 }                 // seq630: never divide by a degenerate framing distance
  // off-axis (parallel) stereo eye offset in X
  var ex: i64 = 0
  if eye[0] == (76 as u8) { ex = 0 - (dist*32)/1000 }   // 'L'
  if eye[0] == (82 as u8) { ex =     (dist*32)/1000 }   // 'R'
641
  // framebuffers
  let npx: i64 = W*H
  let fb: *i64 = sys_mmap(npx*8) as *i64
  let zb: *i64 = sys_mmap(npx*8) as *i64
  let lb: *i64 = sys_mmap(npx*8) as *i64
  var p: i64 = 0
  while p < npx {
      let py: i64 = p / W
      let px1: i64 = p % W
      // smooth full-precision vertical gradient (the old 10-level g caused visible BANDING -- eyeball-found)
      // + subtle backdrop grain (paper-texture scale, +-4 levels; coherent value noise, not white noise)
      let bgt: i64 = tx_vnoise(px1*4, py*4, 17, 24) / 32 - 4
      var br: i64 = 34 + (56*(H-py))/H + bgt
      var bgc: i64 = 41 + (69*(H-py))/H + bgt
      var bbl: i64 = 56 + (94*(H-py))/H + bgt
      if br<0 {br=0} if bgc<0 {bgc=0} if bbl<0 {bbl=0}
      fb[p] = br + bgc*256 + bbl*AS_Q16_ONE
      zb[p] = AS_ZFAR; lb[p] = 0 - 1; p = p + 1
  }
661
  // lights (Q14 unit)
  let l1x: i64 = 0-AS_KEY_LIGHT_X; let l1y: i64 = AS_KEY_LIGHT_Y; let l1z: i64 = AS_KEY_LIGHT_Z
  let l2x: i64 = AS_FILL_LIGHT_X; let l2y: i64 = 0-AS_FILL_LIGHT_Y; let l2z: i64 = AS_FILL_LIGHT_Z
  let cxh: i64 = W/2; let cyh: i64 = H/2
  // half-vector for specular (headlight view (0,0,1)), computed ONCE
  var hx: i64 = l1x; var hy: i64 = l1y; var hz: i64 = l1z + AS_Q14
  let hl: i64 = as_isqrt(hx*hx + hy*hy + hz*hz)
  hx = hx*AS_Q14/hl; hy = hy*AS_Q14/hl; hz = hz*AS_Q14/hl
670
  // ---- GX-15 rung A: GROUND PLANE + PROJECTED CONTACT SHADOW (the floating-figure fix) ----
  // Real geometry-derived shadow: every visible triangle is projected along light L1 onto the floor
  // plane y=floorY and splatted into a floor-space mask; floor pixels darken where masked.
  let floorY: i64 = vmny
  let smN: i64 = 192
  var smE: i64 = rad*3
  if smE < 1 { smE = 1 }                    // seq630: fail-safe -- the shadow grid divides by 2*smE
  let sm: *i64 = sys_mmap(smN*smN*8) as *i64
  let qgx: *i64 = sys_mmap(64) as *i64
  let qgz: *i64 = sys_mmap(64) as *i64
  let qgy: *i64 = sys_mmap(64) as *i64
  t = 0
  while t < ntris {
      let L: i64 = as_rdbits(mb, lidBase + t*4) & 255
      if vis[L] == 1 {
          let ob: i64 = triBase + t*84
          var v: i64 = 0
          while v < 3 {
              let o: i64 = ob + v*12
              let px3: i64 = as_f32mul(mb,o,posq) - cx0 + loffx[L]
              let py3: i64 = as_f32mul(mb,o+4,posq) - cy0
              let pz3: i64 = as_f32mul(mb,o+8,posq) - cz0
              let sx3: i64 = px3 - (py3 - floorY)*l1x/l1y
              let sz3: i64 = pz3 - (py3 - floorY)*l1z/l1y
              qgx[v] = (sx3 + smE)*smN/(2*smE)
              qgz[v] = (sz3 + smE)*smN/(2*smE)
              qgy[v] = py3 - floorY
              v = v + 1
          }
          var a2: i64 = (qgx[1]-qgx[0])*(qgz[2]-qgz[0]) - (qgx[2]-qgx[0])*(qgz[1]-qgz[0])
          var sg2: i64 = 1
          if a2 < 0 { sg2 = 0 - 1 }
          if a2 != 0 {
              var gxmn: i64 = as_max(0, as_min(qgx[0], as_min(qgx[1], qgx[2])))
              var gxmx: i64 = as_min(smN-1, as_max(qgx[0], as_max(qgx[1], qgx[2])))
              var gzmn: i64 = as_max(0, as_min(qgz[0], as_min(qgz[1], qgz[2])))
              var gzmx: i64 = as_min(smN-1, as_max(qgz[0], as_max(qgz[1], qgz[2])))
              var gz: i64 = gzmn
              while gz <= gzmx {
                  var gx: i64 = gxmn
                  while gx <= gxmx {
                      let f0: i64 = ((qgx[2]-qgx[1])*(gz-qgz[1]) - (qgz[2]-qgz[1])*(gx-qgx[1]))*sg2
                      let f1: i64 = ((qgx[0]-qgx[2])*(gz-qgz[2]) - (qgz[0]-qgz[2])*(gx-qgx[2]))*sg2
                      let f2: i64 = ((qgx[1]-qgx[0])*(gz-qgz[0]) - (qgz[1]-qgz[0])*(gx-qgx[0]))*sg2
                      if f0 >= 0 { if f1 >= 0 { if f2 >= 0 {
                          // GX-39 piece 3: store MAX OCCLUDER HEIGHT per cell (was a 1-bit mask) so
                          // the penumbra can grow with height like a real area light
                          var hrel: i64 = qgy[0]
                          if qgy[1] > hrel { hrel = qgy[1] }
                          if qgy[2] > hrel { hrel = qgy[2] }
                          if hrel < 1 { hrel = 1 }
                          if hrel > sm[gz*smN+gx] { sm[gz*smN+gx] = hrel }
                      }}}
                      gx = gx + 1
                  }
                  gz = gz + 1
              }
          }
      }
      t = t + 1
  }
  // ---- GX-39 piece 3: SOFT AREA SHADOW fields ----
  // sm now stores MAX OCCLUDER HEIGHT per cell (0 = unshadowed). Two separable integer box blurs of
  // the coverage build a SHARP field (kills grid-cell blockiness only) and a WIDE field (the
  // penumbra); each floor pixel blends between them by the LOCAL occluder height -- feet stay crisply
  // planted while the head's shadow feathers wide, the real area-light signature. nmap renders keep
  // the legacy hard 4-tap lookup so the mechanistic shape-judge input stays bit-stable.
  let smc: i64 = smN*smN
  let cov: *i64 = sys_mmap(smc*8) as *i64
  let bt1: *i64 = sys_mmap(smc*8) as *i64
  let bs1: *i64 = sys_mmap(smc*8) as *i64
  let bs2: *i64 = sys_mmap(smc*8) as *i64
  var ci: i64 = 0
  while ci < smc { if sm[ci] > 0 { cov[ci] = AS_Q10_ONE } ci = ci + 1 }
  as_boxblur(cov, bt1, bs1, smN, 1)
  as_boxblur(cov, bt1, bs2, smN, 4)
747
  // analytic floor pass: per-pixel ray/plane, textured, shadow-masked, distance-faded to bg
  var fp: i64 = 0
  while fp < npx {
      let py2: i64 = fp / W
      let px2: i64 = fp % W
      let rdy: i64 = cyh - py2
      if rdy < 0 {
          let t16: i64 = floorY*AS_Q16_ONE/rdy
          let wx: i64 = ex + t16*(px2-cxh)/AS_Q16_ONE
          let wz: i64 = dist + t16*(0-FOCAL)/AS_Q16_ONE
          if wx > 0-smE { if wx < smE { if wz > 0-smE { if wz < smE {
              let depth: i64 = dist - wz
              if depth > 0 {
                  let tv: i64 = tx_fbm(wx/posq, floorY/posq, wz/posq)
                  let f: i64 = 928 + tv/2
                  var fr: i64 = 118*f/AS_Q10_ONE; var fg: i64 = 110*f/AS_Q10_ONE; var fbv: i64 = 101*f/AS_Q10_ONE
                  let gx: i64 = (wx + smE)*smN/(2*smE)
                  let gz: i64 = (wz + smE)*smN/(2*smE)
                  var dk: i64 = AS_Q10_ONE
                  if nmap == 0 {
                      // soft area shadow: blend sharp->wide by local occluder height (3x3 max so the
                      // penumbra field has no holes), then darken by the blended coverage
                      var hL: i64 = 0
                      var dz5: i64 = 0 - 1
                      while dz5 <= 1 {
                          var dx5: i64 = 0 - 1
                          while dx5 <= 1 {
                              let gx5: i64 = gx + dx5
                              let gz5: i64 = gz + dz5
                              if gx5 >= 0 { if gx5 < smN { if gz5 >= 0 { if gz5 < smN {
                                  if sm[gz5*smN+gx5] > hL { hL = sm[gz5*smN+gx5] }
                              }}}}
                              dx5 = dx5 + 1
                          }
                          dz5 = dz5 + 1
                      }
                      // a shadow cast from a third of stature up is fully soft (height-derived, not taste)
                      var hpen: i64 = (vmxy - vmny)/3
                      if hpen < 1 { hpen = 1 }
                      var wgt: i64 = hL*AS_Q10_ONE/hpen
                      if wgt > AS_Q10_ONE { wgt = AS_Q10_ONE }
                      let sv: i64 = (bs1[gz*smN+gx]*(AS_Q10_ONE-wgt) + bs2[gz*smN+gx]*wgt)/AS_Q10_ONE
                      dk = AS_Q10_ONE - sv*44/100
                  } else {
                      // legacy hard 4-tap, bit-stable for the shape-judge floor (sm holds heights now,
                      // so count occupied cells rather than summing raw values)
                      var sh: i64 = 0
                      if sm[gz*smN+gx] > 0 { sh = sh + 1 }
                      if gx+1 < smN { if sm[gz*smN+gx+1] > 0 { sh = sh + 1 } }
                      if gz+1 < smN { if sm[(gz+1)*smN+gx] > 0 { sh = sh + 1 } }
                      if gx > 0 { if sm[gz*smN+gx-1] > 0 { sh = sh + 1 } }
                      dk = AS_Q10_ONE - sh*110
                  }
                  fr = fr*dk/AS_Q10_ONE; fg = fg*dk/AS_Q10_ONE; fbv = fbv*dk/AS_Q10_ONE
                  // distance fade toward the backdrop colour
                  let dxtra: i64 = t16/AS_Q16_ONE
                  let ff: i64 = smE*AS_Q10_ONE/(smE + dxtra*3)
                  let obr: i64 = 34 + (56*(H-py2))/H
                  let obg: i64 = 41 + (69*(H-py2))/H
                  let obb: i64 = 56 + (94*(H-py2))/H
                  fr = (fr*ff + obr*(AS_Q10_ONE-ff))/AS_Q10_ONE
                  fg = (fg*ff + obg*(AS_Q10_ONE-ff))/AS_Q10_ONE
                  fbv = (fbv*ff + obb*(AS_Q10_ONE-ff))/AS_Q10_ONE
                  if fr>255 {fr=255} if fg>255 {fg=255} if fbv>255 {fbv=255}
                  fb[fp] = fr + fg*256 + fbv*AS_Q16_ONE
                  zb[fp] = depth
              }
          }}}}
      }
      fp = fp + 1
  }
819
  // pass 3: rasterize
  t = 0
  while t < ntris {
      let L: i64 = as_rdbits(mb, lidBase + t*4) & 255
      if vis[L] == 1 {
          let ob: i64 = triBase + t*84
          // 3 verts: centered pos + offset ; normal Q14 ; color 0..255 (per-vertex, we use v0's colour = flat)
          let rx0v: i64 = as_f32mul(mb,ob,posq)   - cx0 + loffx[L]; let y0: i64 = as_f32mul(mb,ob+4,posq) - cy0; let rz0v: i64 = as_f32mul(mb,ob+8,posq) - cz0
          let rx1v: i64 = as_f32mul(mb,ob+12,posq)- cx0 + loffx[L]; let y1: i64 = as_f32mul(mb,ob+16,posq)- cy0; let rz1v: i64 = as_f32mul(mb,ob+20,posq)- cz0
          let rx2v: i64 = as_f32mul(mb,ob+24,posq)- cx0 + loffx[L]; let y2: i64 = as_f32mul(mb,ob+28,posq)- cy0; let rz2v: i64 = as_f32mul(mb,ob+32,posq)- cz0
          // multi-view: yaw about the vertical axis so the judge can inspect the depth axis a front view hides
          let x0: i64 = (rx0v*ycos + rz0v*ysin)/AS_Q14; let z0: i64 = (rz0v*ycos - rx0v*ysin)/AS_Q14
          let x1: i64 = (rx1v*ycos + rz1v*ysin)/AS_Q14; let z1: i64 = (rz1v*ycos - rx1v*ysin)/AS_Q14
          let x2: i64 = (rx2v*ycos + rz2v*ysin)/AS_Q14; let z2: i64 = (rz2v*ycos - rx2v*ysin)/AS_Q14
          // depths from camera (looking -z, camera at +z=dist)
          let d0: i64 = dist - z0; let d1: i64 = dist - z1; let d2: i64 = dist - z2
          if d0 > 0 { if d1 > 0 { if d2 > 0 {
              // project (off-axis stereo)
              let conv: i64 = ex*FOCAL/dist
              let sx0: i64 = cxh + ((x0-ex)*FOCAL)/d0 + conv; let sy0: i64 = cyh - (y0*FOCAL)/d0
              let sx1: i64 = cxh + ((x1-ex)*FOCAL)/d1 + conv; let sy1: i64 = cyh - (y1*FOCAL)/d1
              let sx2: i64 = cxh + ((x2-ex)*FOCAL)/d2 + conv; let sy2: i64 = cyh - (y2*FOCAL)/d2
              var area: i64 = (sx1-sx0)*(sy2-sy0) - (sx2-sx0)*(sy1-sy0)
              if area != 0 {
                  // GX-15 rung B: per-VERTEX normals decoded once per tri, interpolated per PIXEL (kills faceting)
                  let q0x: i64 = as_f32mul(mb,ob+36,AS_Q14); let n0y: i64 = as_f32mul(mb,ob+40,AS_Q14); let q0z: i64 = as_f32mul(mb,ob+44,AS_Q14)
                  let q1x: i64 = as_f32mul(mb,ob+48,AS_Q14); let n1y: i64 = as_f32mul(mb,ob+52,AS_Q14); let q1z: i64 = as_f32mul(mb,ob+56,AS_Q14)
                  let q2x: i64 = as_f32mul(mb,ob+60,AS_Q14); let n2y: i64 = as_f32mul(mb,ob+64,AS_Q14); let q2z: i64 = as_f32mul(mb,ob+68,AS_Q14)
                  // normals must yaw with the geometry, or lighting/normal-maps detach from the surface
                  let n0x: i64 = (q0x*ycos + q0z*ysin)/AS_Q14; let n0z: i64 = (q0z*ycos - q0x*ysin)/AS_Q14
                  let n1x: i64 = (q1x*ycos + q1z*ysin)/AS_Q14; let n1z: i64 = (q1z*ycos - q1x*ysin)/AS_Q14
                  let n2x: i64 = (q2x*ycos + q2z*ysin)/AS_Q14; let n2z: i64 = (q2z*ycos - q2x*ysin)/AS_Q14
                  let cr: i64 = as_f32mul(mb,ob+72,255); let cg: i64 = as_f32mul(mb,ob+76,255); let cbb: i64 = as_f32mul(mb,ob+80,255)
                  // bbox
                  var bxmn: i64 = as_max(0, as_min(sx0, as_min(sx1,sx2)))
                  var bxmx: i64 = as_min(W-1, as_max(sx0, as_max(sx1,sx2)))
                  var bymn: i64 = as_max(0, as_min(sy0, as_min(sy1,sy2)))
                  var bymx: i64 = as_min(H-1, as_max(sy0, as_max(sy1,sy2)))
                  var sgn: i64 = 1
                  if area < 0 { sgn = 0 - 1 }
                  let aabs: i64 = area*sgn
                  var py2: i64 = bymn
                  while py2 <= bymx {
                      var px2: i64 = bxmn
                      while px2 <= bxmx {
                          let e0: i64 = ((sx2-sx1)*(py2-sy1) - (sy2-sy1)*(px2-sx1))*sgn
                          let e1: i64 = ((sx0-sx2)*(py2-sy2) - (sy0-sy2)*(px2-sx2))*sgn
                          let e2: i64 = ((sx1-sx0)*(py2-sy0) - (sy1-sy0)*(px2-sx0))*sgn
                          if e0 >= 0 { if e1 >= 0 { if e2 >= 0 {
                              let depth: i64 = (e0*d0 + e1*d1 + e2*d2)/aabs
                              let idx: i64 = py2*W + px2
                              if depth < zb[idx] {
                                  // per-pixel WORLD position -> multi-octave texture (GX-13)
                                  let wx: i64 = (e0*x0 + e1*x1 + e2*x2)/aabs
                                  let wy: i64 = (e0*y0 + e1*y1 + e2*y2)/aabs
                                  let wz: i64 = (e0*z0 + e1*z1 + e2*z2)/aabs
                                  let tv: i64 = tx_fbm(wx/posq, wy/posq, wz/posq)
                                  let f: i64 = 896 + tv
                                  // GX-15 rung B: smooth interpolated normal per pixel
                                  var nx: i64 = (e0*n0x + e1*n1x + e2*n2x)/aabs
                                  var ny: i64 = (e0*n0y + e1*n1y + e2*n2y)/aabs
                                  var nz: i64 = (e0*n0z + e1*n1z + e2*n2z)/aabs
                                  var nl: i64 = as_isqrt(nx*nx + ny*ny + nz*nz)
                                  if nl < 1 { nl = 1 }
                                  nx = nx*AS_Q14/nl; ny = ny*AS_Q14/nl; nz = nz*AS_Q14/nl
                                  if nz < 0 { nx = 0-nx; ny = 0-ny; nz = 0-nz }
                                  // ★SKIN MICRO-BUMP: perturb the shading normal by a high-frequency noise
                                  // gradient over world position -- pore/wrinkle-scale relief that catches
                                  // light, so skin stops reading as smooth plastic. Renderer-only (the mesh
                                  // and the bench are untouched); two octaves for skin, coarser everywhere.
                                  if L == 0 {
                                      let mx: i64 = wx/posq; let my: i64 = wy/posq; let mz: i64 = wz/posq
                                      let gx1: i64 = tx_vnoise(mx+1,my,mz,3) - tx_vnoise(mx-1,my,mz,3)
                                      let gy1: i64 = tx_vnoise(mx,my+1,mz,3) - tx_vnoise(mx,my-1,mz,3)
                                      let gx2: i64 = tx_vnoise(mx+2,my,mz,7) - tx_vnoise(mx-2,my,mz,7)
                                      let gy2: i64 = tx_vnoise(mx,my+2,mz,7) - tx_vnoise(mx,my-2,mz,7)
                                      nx = nx + (gx1*16 + gx2*10)/10        // fine micro-relief only -- subtle, not mottled
                                      ny = ny + (gy1*16 + gy2*10)/10
                                      var nl2: i64 = as_isqrt(nx*nx + ny*ny + nz*nz)
                                      if nl2 < 1 { nl2 = 1 }
                                      nx = nx*AS_Q14/nl2; ny = ny*AS_Q14/nl2; nz = nz*AS_Q14/nl2
                                  }
                                  let dot1: i64 = (nx*l1x + ny*l1y + nz*l1z)/AS_Q14
                                  var d1l: i64 = as_max(0, dot1)
                                  // GX-15 rung C: SKIN responds like flesh -- wrap diffuse (SSS signature, proven Gx rung)
                                  if L == 0 {
                                      d1l = (dot1 + 4*AS_Q14/10)*717/AS_Q10_ONE
                                      if d1l < 0 { d1l = 0 }
                                  }
                                  let d2l: i64 = as_max(0, (nx*l2x + ny*l2y + nz*l2z)/AS_Q14)
                                  // ★ENVIRONMENT AMBIENT (GX-38). The ambient term was the CONSTANT 225 --
                                  // every surface got the same fill regardless of which way it faced, which
                                  // is the single strongest reason these renders read as CG on a backdrop.
                                  // Real ambient is a hemisphere: a surface facing up sees sky, one facing
                                  // down sees only the dim bounce off the ground. This is the cosine-weighted
                                  // sky-visibility term of an environment light, integer and sovereign --
                                  // shading only, so it cannot move the geometric bench by construction.
                                  let skyw: i64 = (AS_Q14 + ny)/2
                                  let ambi: i64 = 96 + 258*skyw/AS_Q14
                                  var lit: i64 = ambi + 676*d1l/AS_Q14 + 256*d2l/AS_Q14
                                  // soft FRONT FILL for skin: camera-facing surfaces get a gentle lift so
                                  // downward/shadowed features (the mouth, under-chin) don't crush to black.
                                  if L == 0 { lit = lit + 210*nz/AS_Q14 }
                                  if lit > AS_LIT_CEIL { lit = AS_LIT_CEIL }
                                  var r2: i64 = cr*lit*f/(AS_Q10_ONE*AS_Q10_ONE)
                                  var g2: i64 = cg*lit*f/(AS_Q10_ONE*AS_Q10_ONE)
                                  var b2: i64 = cbb*lit*f/(AS_Q10_ONE*AS_Q10_ONE)
                                  // PER-CHANNEL ENVIRONMENT (GX-39). The hemisphere above is a SCALAR, so it
                                  // brightens up-facing surfaces but cannot carry what actually reads as real
                                  // light: sky is COOL and ground bounce is WARM, so a real body is subtly blue
                                  // toward the top and orange underneath. Applied as a fraction of the surface
                                  // colour itself, so it is scale-free and tints rather than washes out.
                                  // Shading only, so the geometric bench must not move.
                                  let gndw: i64 = AS_Q14 - skyw
                                  let warm: i64 = (gndw*90 - skyw*25)/AS_Q14
                                  let cool: i64 = (skyw*95 - gndw*30)/AS_Q14
                                  r2 = r2 + r2*warm/1000
                                  g2 = g2 + g2*(warm/3 + cool/4)/1000
                                  b2 = b2 + b2*cool/1000
                                  // ★SUBSURFACE SCATTERING (skin=layer0): light scatters INSIDE flesh and red
                                  // penetrates deepest, so the terminator and the shadowed side glow warm/red
                                  // instead of going dead-grey -- the single biggest "skin not clay" signature.
                                  // sss rises smoothly as the surface turns away from the key light.
                                  if L == 0 {
                                      var sss: i64 = AS_Q14*55/100 - dot1
                                      if sss < 0 { sss = 0 }
                                      if sss > AS_Q14 { sss = AS_Q14 }
                                      r2 = r2 + cr*sss*46/(AS_Q14*100)          // red bleed (deepest) -- strong
                                      g2 = g2 + cg*sss*14/(AS_Q14*100)          // a little green
                                      b2 = b2 - cbb*sss*10/(AS_Q14*100)         // pull blue -> warmer shadows
                                      // ★AROUSAL PERFUSION: added haemoglobin absorbs G and B far
                                      // more than R, so flush is G/B FALLING, not red being added.
                                      // AS_PERF defaults 0 -> this block is a no-op for every
                                      // existing caller and the geometric bench cannot move.
                                      // ★GATED BY THE PROPAGATION FIELD, not applied flat: local flush is how
                                      // far systemic perfusion EXCEEDS this site's threshold, so at low drive
                                      // only genital/submammary tissue colours and the face/limbs stay clear,
                                      // and the order emerges instead of the whole body reddening at once.
                                      if AS_PERF > 0 {
                                          let sfr: i64 = (wy - AS_YMIN)*1000/AS_YSPAN
                                          var lxd: i64 = wx - AS_XCTR
                                          if lxd < 0 { lxd = 0 - lxd }
                                          let latf: i64 = lxd*1000/AS_XHALF
                                          let thr: i64 = as_flush_thresh(sfr, latf)
                                          var fl: i64 = 0
                                          if AS_PERF > thr { fl = (AS_PERF - thr)*1000/(1000 - thr) }
                                          if fl > 1000 { fl = 1000 }
                                          r2 = r2 - r2*fl*4/AS_PERFUSION_DEN
                                          g2 = g2 - g2*fl*30/AS_PERFUSION_DEN
                                          b2 = b2 - b2*fl*40/AS_PERFUSION_DEN
                                      }
                                      // ★real skin is EVEN, not blotchy: only a whisper of fine grain (the coarse
                                      // blotch variation read as diseased mottling at body scale = a regression, removed)
                                      let cf: i64 = tx_vnoise(wx*3/posq, wy*3/posq, wz*3/posq, 5)
                                      r2 = r2 + (cf-128)*4/255
                                      g2 = g2 + (cf-128)*2/255
                                      // ★SUBCUTANEOUS VEINS shown THROUGH skin translucency (blue-green: flesh
                                      // absorbs red). A domain-warped LEVEL-SET = branching wavy lines, gated by
                                      // a low-freq THIN-SKIN mask so veins only surface in patches (forearms/
                                      // chest/hands), not everywhere. Inside-out -- real vasculature under the
                                      // skin, which Infinigen's single-surface creatures cannot show.
                                      let vmx: i64 = wx/posq; let vmy: i64 = wy/posq; let vmz: i64 = wz/posq
                                      // coarse + x-COMPRESSED (vein LINES run lengthwise along the limb/torso) +
                                      // strong domain warp so the contour meanders -> long thin veins, not speckle
                                      let warp: i64 = (tx_vnoise(vmx, vmy, vmz, 26) - 128)*3
                                      let vf: i64 = tx_vnoise(vmx*3 + warp, vmy + warp/3, vmz, 40)
                                      var ridge: i64 = vf - 128; if ridge < 0 { ridge = 0-ridge }
                                      let thin: i64 = tx_vnoise(vmx, vmy, vmz, 80)
                                      if ridge < 10 { if thin > 140 {
                                          let vein: i64 = (10 - ridge)*(thin - 140)/10
                                          r2 = r2 - vein*20/100
                                          g2 = g2 - vein*4/100
                                          b2 = b2 + vein*15/100
                                      }}
                                  }
                                  // ★BONE MATERIAL (layer 2), colour-only, same doctrine as the skin stack
                                  // (sec27/30): the geometric bench cannot move. Operator 2026-08-10: "it looks
                                  // like a cartoon" -- root cause was that the ENTIRE material stack applied only
                                  // to skin, so the skull rendered flat diffuse + weak sheen = toon shading.
                                  if L == 2 {
                                      // (1) porosity/trabecular grain at two scales; blue dampened so the
                                      //     grain reads mineral, not noise
                                      let bng1: i64 = tx_vnoise(wx*5/posq, wy*5/posq, wz*5/posq, 11)
                                      let bng2: i64 = tx_vnoise(wx*13/posq, wy*13/posq, wz*13/posq, 7)
                                      let bgrain: i64 = (bng1-128)*10/255 + (bng2-128)*6/255
                                      r2 = r2 + bgrain; g2 = g2 + bgrain; b2 = b2 + bgrain*2/3
                                      // (2) shallow subsurface warmth at the terminator: bone is translucent
                                      //     too, far shallower than flesh -- a faint warm lift, no red flood
                                      var bss: i64 = AS_Q14*45/100 - dot1
                                      if bss < 0 { bss = 0 }
                                      if bss > AS_Q14 { bss = AS_Q14 }
                                      r2 = r2 + cr*bss*18/(AS_Q14*100)
                                      g2 = g2 + cg*bss*9/(AS_Q14*100)
                                      b2 = b2 - cbb*bss*6/(AS_Q14*100)
                                      // (3) matte mineral, not plastic: desaturate toward grey where the sky
                                      //     light dies instead of holding a uniform ivory
                                      let bdk: i64 = AS_Q14 - skyw
                                      g2 = g2 - g2*bdk*4/(AS_Q14*100)
                                      b2 = b2 - b2*bdk*8/(AS_Q14*100)
                                  }
                                  // subtle Blinn specular sheen (half-vector precomputed)
                                  let ndh: i64 = as_max(0, (nx*hx + ny*hy + nz*hz)/AS_Q14)
                                  let s2s: i64 = ndh*ndh/AS_Q14
                                  let s4s: i64 = s2s*s2s/AS_Q14
                                  let s8s: i64 = s4s*s4s/AS_Q14
                                  var spq: i64 = s8s*52/AS_Q14
                                  if L == 0 { spq = s8s*80/AS_Q14 }
                                  // bone: wider satin lobe at lower energy -- mineral sheen, not plastic gloss
                                  if L == 2 { spq = s4s*38/AS_Q14 }
                                  r2 = r2 + spq; g2 = g2 + spq; b2 = b2 + spq
                                  if r2>255 {r2=255} if g2>255 {g2=255} if b2>255 {b2=255}
                                  if r2<0 {r2=0} if g2<0 {g2=0} if b2<0 {b2=0}
                                  // ★MECHANISTIC SHAPE JUDGE (no VLM): 'nmap' writes the surface NORMAL as
                                  // colour instead of shading it. Silhouette IoU is provably blind to depth
                                  // and to surface shape -- two bodies with identical outlines can have
                                  // completely different surfaces. Comparing normal FIELDS measures the shape
                                  // itself, mechanically, with no learned model anywhere in the loop.
                                  if nmap == 1 {
                                      r2 = (nx + AS_Q14)*255/(2*AS_Q14)
                                      g2 = (ny + AS_Q14)*255/(2*AS_Q14)
                                      b2 = (nz + AS_Q14)*255/(2*AS_Q14)
                                  }
                                  zb[idx] = depth; fb[idx] = r2 + g2*256 + b2*AS_Q16_ONE; lb[idx] = L
                              }
                          }}}
                          px2 = px2 + 1
                      }
                      py2 = py2 + 1
                  }
              }
          }}}
      }
      t = t + 1
  }
1054
  // GX-39 piece 2: contact-darkening AO post-pass -- shaded path ONLY (the nmap shape-judge input
  // must stay pure geometry, which is also why the geometric bench cannot move)
  if nmap == 0 { as_ssao(fb, zb, lb, W, H) }
  // GX-39 piece 4: depth of field -- photographic focus on the body; floor/backdrop blur by distance
  if nmap == 0 { as_dof(fb, zb, lb, W, H) }
1060
  write_png(fb, W, H, outp)
1062
  // stats
  let lpx: *i64 = sys_mmap(nlayers*8) as *i64
  var i2: i64 = 0
  while i2 < nlayers { lpx[i2] = 0; i2 = i2 + 1 }
  var bg: i64 = 0; var fg: i64 = 0; var cxs: i64 = 0
  var dmn: i64 = AS_ZFAR; var dmx: i64 = 0; var dsm: i64 = 0
  var q: i64 = 0
  while q < npx {
      let L: i64 = lb[q]
      if L < 0 { bg = bg + 1 } else {
          lpx[L] = lpx[L] + 1; fg = fg + 1; cxs = cxs + (q % W)
          let d: i64 = zb[q]
          if d < dmn { dmn = d } if d > dmx { dmx = d } dsm = dsm + d
      }
      q = q + 1
  }
  var cxv: i64 = 0 - 1; var dmean: i64 = 0 - 1
  if fg > 0 { cxv = cxs/fg; dmean = dsm/fg }
  as_hw("{\x22impl\x22:\x22sovereign-nishilang-integer\x22,\x22mode\x22:\x22" as *u8); as_hw(mode)
  as_hw("\x22,\x22eye\x22:\x22" as *u8); as_hw(eye)
  as_hw("\x22,\x22W\x22:" as *u8); as_pn(W); as_hw(",\x22H\x22:" as *u8); as_pn(H)
  as_hw(",\x22ntris\x22:" as *u8); as_pn(ntris)
  as_hw(",\x22bg_frac_permil\x22:" as *u8); as_pn(bg*1000/npx)
  as_hw(",\x22fg_pix\x22:" as *u8); as_pn(fg)
  as_hw(",\x22centroid_x\x22:" as *u8); as_pn(cxv)
  as_hw(",\x22depth_min\x22:" as *u8); as_pn(dmn); as_hw(",\x22depth_mean\x22:" as *u8); as_pn(dmean); as_hw(",\x22depth_max\x22:" as *u8); as_pn(dmx)
  as_hw(",\x22layer_pix\x22:[" as *u8)
  var k: i64 = 0
  while k < nlayers { if k > 0 { as_hw("," as *u8) } as_pn(lpx[k]); k = k + 1 }
  as_hw("]}\n" as *u8)
  return 0
1094}
nx_anat_sov.nx source

`nx_anat_sov.nx` source
