code wiki / (root) / nx_nxa_texbake_gate.nx
`nx_nxa_texbake_gate.nx` source

↩ module page · 369 lines · 16035 B
1// nx_nxa_texbake_gate.nx -- GATE for texture-ladder rungs 2b+3+4 (debt 1786546859). Fixture ASSEMBLED AT
2// RUNTIME with joints at CONTROLLED anatomy (permil/laterality) so region classification is asserted EXACTLY.
3// Anti-vacuity: determinism vs seed-grain, palette discrimination across regions, EVENNESS (anti-blotch),
4// and seed-A-vs-seed-B textured renders must DIFFER (proves per-fragment sampling is load-bearing end-to-end).
5// Neg-control: bake without TEXC refuses named. Real asset behind gv_need writes the published artifacts.
6// license_tier: ORIGINAL  expect_exit: 0
7import "nx_syscalls.nx"
8import "nx_nxa.nx"
9import "nx_nxa_texc_lib.nx"
10import "nx_nxa_texbake_lib.nx"
11import "nx_gate_verdict.nx"
12
13const GB_NV: i64 = 6
14const GB_NJ: i64 = 5
15const GB_RES: i64 = 128
16
17func gb_wfile(path: *u8, b: *u8, n: i64) -> i64 {
  let fd: i64 = sys_openat_wr(path, 0x1a4)
  if fd < 0 { return 0 }
  sys_write(fd, b, n)
  sys_close(fd)
  return 1
23}
24// fixture: 6 verts spanning z 0..10000, 5 joints at controlled anatomy:
25// j0 root@0 (legs->LIMBS) j1 pelvis@580 mid (GENS) j2 chest@700 mid (TORSO) j3 head@950 (FACE) j4 hand@700 lateral (LIMBS)
26func gb_mkfix(path: *u8) -> i64 {
  let vwl: i64 = 1 + GB_NV*3
  let twl: i64 = 1 + 4*3
  let swl: i64 = 1 + GB_NJ*8
  let kwl: i64 = 1 + GB_NV*8
  let ns: i64 = 4
  let toclen: i64 = 32 + ns*32
  let total: i64 = toclen + vwl*8 + twl*8 + swl*8 + kwl*8
  let nb: *u8 = sys_mmap(total + 4096)
  nt_wr64(nb, 0, nxa_magic())
  nt_wr64(nb, 8, 1)
  nt_wr64(nb, 16, ns)
  let vp: *i64 = sys_mmap(vwl*8 + 64) as *i64
  vp[0] = GB_NV
  vp[1] = 0;    vp[2] = 0;     vp[3] = 0
  vp[4] = 0;    vp[5] = 0;     vp[6] = 10000
  vp[7] = 0;    vp[8] = 0-50;  vp[9] = 5800
  vp[10] = 0;   vp[11] = 0-50; vp[12] = 7000
  vp[13] = 2000; vp[14] = 0;   vp[15] = 7000
  vp[16] = 100; vp[17] = 50;   vp[18] = 7000
  let sp: *i64 = sys_mmap(swl*8 + 64) as *i64
  sp[0] = GB_NJ
  sp[1] = 0-1; sp[2] = 0;    sp[3] = 0; sp[4] = 0;     sp[5] = 0; sp[6] = 0; sp[7] = 0; sp[8] = 4096
  sp[9] = 0;   sp[10] = 0;   sp[11] = 0; sp[12] = 5800; sp[13] = 0; sp[14] = 0; sp[15] = 0; sp[16] = 4096
  sp[17] = 1;  sp[18] = 0;   sp[19] = 0; sp[20] = 7000; sp[21] = 0; sp[22] = 0; sp[23] = 0; sp[24] = 4096
  sp[25] = 2;  sp[26] = 0;   sp[27] = 0; sp[28] = 9500; sp[29] = 0; sp[30] = 0; sp[31] = 0; sp[32] = 4096
  sp[33] = 2;  sp[34] = 2000; sp[35] = 0; sp[36] = 7000; sp[37] = 0; sp[38] = 0; sp[39] = 0; sp[40] = 4096
  let tp: *i64 = sys_mmap(twl*8 + 64) as *i64
  tp[0] = 4
  tp[1] = 0; tp[2] = 2; tp[3] = 3
  tp[4] = 2; tp[5] = 3; tp[6] = 4
  tp[7] = 3; tp[8] = 4; tp[9] = 5
  tp[10] = 1; tp[11] = 3; tp[12] = 5
  let kp: *i64 = sys_mmap(kwl*8 + 64) as *i64
  kp[0] = GB_NV
  let own: *i64 = sys_mmap(8*8) as *i64
  own[0] = 0
  own[1] = 3
  own[2] = 1
  own[3] = 2
  own[4] = 4
  own[5] = 2
  var r: i64 = 0
  while r < GB_NV {
      kp[1 + r*8] = own[r]
      kp[1 + r*8 + 1] = 0
      kp[1 + r*8 + 2] = 0
      kp[1 + r*8 + 3] = 0
      kp[1 + r*8 + 4] = 4096
      kp[1 + r*8 + 5] = 0
      kp[1 + r*8 + 6] = 0
      kp[1 + r*8 + 7] = 0
      r = r + 1
  }
  var wo: i64 = toclen
  var ti: i64 = 0
  nt_wr64(nb, 32 + ti*32, nxa_tag4("VERT" as *u8))
  nt_wr64(nb, 32 + ti*32 + 8, wo)
  nt_wr64(nb, 32 + ti*32 + 16, vwl)
  var k: i64 = 0
  while k < vwl { nt_wr64(nb, wo + k*8, vp[k]); k = k + 1 }
  nt_wr64(nb, 32 + ti*32 + 24, nxa_check2(1, ((nb as i64) + wo) as *i64, vwl))
  wo = wo + vwl*8
  ti = ti + 1
  nt_wr64(nb, 32 + ti*32, nxa_tag4("TRIS" as *u8))
  nt_wr64(nb, 32 + ti*32 + 8, wo)
  nt_wr64(nb, 32 + ti*32 + 16, twl)
  k = 0
  while k < twl { nt_wr64(nb, wo + k*8, tp[k]); k = k + 1 }
  nt_wr64(nb, 32 + ti*32 + 24, nxa_check2(1, ((nb as i64) + wo) as *i64, twl))
  wo = wo + twl*8
  ti = ti + 1
  nt_wr64(nb, 32 + ti*32, nxa_tag4("SKEL" as *u8))
  nt_wr64(nb, 32 + ti*32 + 8, wo)
  nt_wr64(nb, 32 + ti*32 + 16, swl)
  k = 0
  while k < swl { nt_wr64(nb, wo + k*8, sp[k]); k = k + 1 }
  nt_wr64(nb, 32 + ti*32 + 24, nxa_check2(1, ((nb as i64) + wo) as *i64, swl))
  wo = wo + swl*8
  ti = ti + 1
  nt_wr64(nb, 32 + ti*32, nxa_tag4("SKIN" as *u8))
  nt_wr64(nb, 32 + ti*32 + 8, wo)
  nt_wr64(nb, 32 + ti*32 + 16, kwl)
  k = 0
  while k < kwl { nt_wr64(nb, wo + k*8, kp[k]); k = k + 1 }
  nt_wr64(nb, 32 + ti*32 + 24, nxa_check2(1, ((nb as i64) + wo) as *i64, kwl))
  wo = wo + kwl*8
  nt_wr64(nb, 24, nxa_check2(1, ((nb as i64) + 32) as *i64, ns*4))
  return gb_wfile(path, nb, wo)
115}
116func gb_flen(path: *u8, bout: *i64) -> i64 {
  let lp: *i64 = sys_mmap(16) as *i64
  let b: *u8 = sys_read_file(path, lp)
  bout[0] = b as i64
  return lp[0]
121}
122func gb_bytes_eq(a: *u8, b: *u8, n: i64) -> i64 {
  var i: i64 = 0
  var r: i64 = 1
  while i < n { if a[i] != b[i] { r = 0; i = n } else { i = i + 1 } }
  return r
127}
128
129func main() -> i64 {
  let ctr: *i64 = gv_ctr()
  gv_head("nx_nxa_texbake_gate -- texture ladder 2b+3+4: regions, albedo atlas, per-fragment textured render (debt 1786546859)" as *u8)
132
  let pf: *u8 = "/tmp/ntb_fix.nxa" as *u8
  let pt: *u8 = "/tmp/ntb_fixt.nxa" as *u8
  gb_mkfix(pf)
  gv_check("T1 pipeline precondition: nx_nxa_texc writes TEXC onto the fixture" as *u8, ntx_apply(pf, pt) == 0, ctr)
137
  let bo: *i64 = sys_mmap(16) as *i64
  let flen: i64 = gb_flen(pt, bo)
  let fb2: *u8 = bo[0] as *u8
  // T2 region classification EXACT on controlled anatomy
  let regs: *i64 = sys_mmap(64*8) as *i64
  let perms: *i64 = sys_mmap(64*8) as *i64
  let nj: i64 = ntb_regions(fb2, flen, regs, perms)
  gv_puts("  regions: j0=" as *u8); gv_num(regs[0])
  gv_puts(" j1=" as *u8); gv_num(regs[1])
  gv_puts(" j2=" as *u8); gv_num(regs[2])
  gv_puts(" j3=" as *u8); gv_num(regs[3])
  gv_puts(" j4=" as *u8); gv_num(regs[4])
  gv_puts("\n" as *u8)
  var t2: i64 = 0
  if nj == GB_NJ { if regs[0] == 2 { if regs[1] == 3 { if regs[2] == 1 { if regs[3] == 0 { if regs[4] == 2 { t2 = 1 } } } } } }
  gv_check("T2 joint regions EXACT: root->limbs pelvis->gens chest->torso head->face lateral->limbs" as *u8, t2, ctr)
154
  // T3-T5 bake: clean, deterministic, seed-grain live
  let a7: *u8 = sys_mmap(GB_RES*GB_RES*3 + 64)
  let a7b: *u8 = sys_mmap(GB_RES*GB_RES*3 + 64)
  let a8: *u8 = sys_mmap(GB_RES*GB_RES*3 + 64)
  let rc3: i64 = ntb_bake(fb2, flen, GB_RES, 7, a7)
  gv_check("T3 bake runs clean on the fixture" as *u8, rc3 == 0, ctr)
  ntb_bake(fb2, flen, GB_RES, 7, a7b)
  gv_check("T4 bake is DETERMINISTIC: same seed -> byte-identical atlas" as *u8, gb_bytes_eq(a7, a7b, GB_RES*GB_RES*3), ctr)
  ntb_bake(fb2, flen, GB_RES, 8, a8)
  gv_check("T5 seed grain is LIVE: different seed -> different atlas" as *u8, 1 - gb_bytes_eq(a7, a8, GB_RES*GB_RES*3), ctr)
165
  // T6 palette discrimination: face tile (j3) vs limbs tile (j4); grid(5)=3, tile=42px, centers
  let tw: i64 = GB_RES/3
  let fx: i64 = tw/2
  let fy: i64 = tw + tw/2
  let lx2: i64 = tw + tw/2
  let ly2: i64 = tw + tw/2
  let fr: i64 = a7[(fy*GB_RES + fx)*3] as i64
  let lr: i64 = a7[(ly2*GB_RES + lx2)*3] as i64
  var dd: i64 = fr - lr
  if dd < 0 { dd = 0 - dd }
  gv_puts("  face_r=" as *u8); gv_num(fr)
  gv_puts(" limb_r=" as *u8); gv_num(lr)
  gv_puts("\n" as *u8)
  gv_check("T6 regions DISCRIMINATE: face and limb tiles differ in albedo" as *u8, dd >= 6, ctr)
180
  // T7 EVENNESS (anti-blotch): 25 samples inside the chest tile (j2 -> tile x2 y0), spread max<=8
  var rmin: i64 = 255
  var rmax: i64 = 0
  var sy: i64 = 0
  while sy < 5 {
      var sx: i64 = 0
      while sx < 5 {
          let px: i64 = 2*tw + 4 + sx*7
          let py: i64 = 4 + sy*7
          let rv: i64 = a7[(py*GB_RES + px)*3] as i64
          if rv < rmin { rmin = rv }
          if rv > rmax { rmax = rv }
          sx = sx + 1
      }
      sy = sy + 1
  }
  gv_puts("  chest tile r spread=" as *u8); gv_num(rmax - rmin); gv_puts("\n" as *u8)
  gv_check("T7 skin is EVEN: within-tile spread <= 8 (whisper grain, no blotch)" as *u8, rmax - rmin <= 8, ctr)
199
  // T8 neg-control: baking the PRE-TEXC fixture refuses with the named missing-section code
  let bo2: *i64 = sys_mmap(16) as *i64
  let flen0: i64 = gb_flen(pf, bo2)
  let rc8: i64 = ntb_bake(bo2[0] as *u8, flen0, GB_RES, 7, a8)
  if rc8 != 0-4 { gv_puts("    detail: rc=" as *u8); gv_num(rc8); gv_puts("\n" as *u8) }
  gv_check("T8 neg-control-no-texc: bake refuses named (run nx_nxa_texc first)" as *u8, rc8 == 0-4, ctr)
206
  // T9 sampling is LOAD-BEARING end-to-end: seed-7 and seed-8 textured renders differ
  let pv7: *u8 = "/tmp/ntb_v7.png" as *u8
  let pv8: *u8 = "/tmp/ntb_v8.png" as *u8
  let rv7: i64 = ntb_view(fb2, flen, 64, 7, pv7)
  let rv8: i64 = ntb_view(fb2, flen, 64, 8, pv8)
  var t9: i64 = 0
  if rv7 == 0 { if rv8 == 0 {
      let l7p: *i64 = sys_mmap(16) as *i64
      let l8p: *i64 = sys_mmap(16) as *i64
      let b7: *u8 = sys_read_file(pv7, l7p)
      let b8: *u8 = sys_read_file(pv8, l8p)
      if l7p[0] > 0 { if l8p[0] > 0 {
          t9 = 1
          if l7p[0] == l8p[0] { if gb_bytes_eq(b7, b8, l7p[0]) == 1 { t9 = 0 } }
      } }
  } }
  gv_check("T9 per-fragment sampling LOAD-BEARING: seed-7 vs seed-8 renders differ" as *u8, t9, ctr)
224
  // T10 the real shipped asset (gv_need) -> published artifacts
  var haveref: i64 = 0
  let rfd: i64 = sys_openat_rd("sites/nishifamily/world/ref9d.nxa" as *u8)
  if rfd >= 0 { haveref = 1; sys_close(rfd) }
  if gv_need("sites/nishifamily/world/ref9d.nxa" as *u8, haveref, ctr) == 1 {
      let bo3: *i64 = sys_mmap(16) as *i64
      let rflen: i64 = gb_flen("sites/nishifamily/world/ref9d.nxa" as *u8, bo3)
      let rb: *u8 = bo3[0] as *u8
      let regs2: *i64 = sys_mmap(4096*8) as *i64
      let perms2: *i64 = sys_mmap(4096*8) as *i64
      let rnj: i64 = ntb_regions(rb, rflen, regs2, perms2)
      let cnt: *i64 = sys_mmap(4*8) as *i64
      var j2: i64 = 0
      while j2 < rnj { cnt[regs2[j2]] = cnt[regs2[j2]] + 1; j2 = j2 + 1 }
      gv_puts("  ref9d census: face=" as *u8); gv_num(cnt[0])
      gv_puts(" torso=" as *u8); gv_num(cnt[1])
      gv_puts(" limbs=" as *u8); gv_num(cnt[2])
      gv_puts(" gens=" as *u8); gv_num(cnt[3])
      gv_puts("\n" as *u8)
      var t10: i64 = 0
      if rnj > 0 { if cnt[0] >= 2 { if cnt[1] >= 2 { if cnt[2] >= 15 { t10 = 1 } } } }
      gv_check("T10 ref9d region census sane (face>=2 torso>=2 limbs>=15, all 104 classified)" as *u8, t10, ctr)
      let atl: *u8 = sys_mmap(1024*1024*3 + 64)
      let rca: i64 = ntb_bake(rb, rflen, 1024, 1, atl)
      var t11: i64 = 0
      if rca == 0 {
          ntb_write_atlas_png(atl, 1024, "knowledge/nx_texc_atlas.png" as *u8)
          if ntb_view(rb, rflen, 1024, 1, "knowledge/nx_texc_view.png" as *u8) == 0 { t11 = 1 }
      }
      gv_check("T11 ref9d bakes + renders TEXTURED: knowledge/nx_texc_atlas.png + nx_texc_view.png" as *u8, t11, ctr)
  }
256
  // ---- T12-T14 AXIS INVARIANCE (2026-08-23). The R22 glTF ingest emits axes AS AUTHORED
  // (y-up); the pre-fix lib normalized every asset by its z-span, so a y-up donor was scaled by
  // its body DEPTH: measured live as an 81-percent-fill mesh-interior close-up (filled3=334445
  // of 414000) versus 13.6 percent for the shipped z-up asset. The tooth: the SAME fixture,
  // re-authored y-up by swapping y/z in VERT and SKEL with checksums recomputed through the
  // format's own primitives, must render a BYTE-IDENTICAL PNG. Integer renderer, no tolerance.
  let pyu: *u8 = "/tmp/ntb_fix_yup.nxa" as *u8
  let pdg: *u8 = "/tmp/ntb_fix_deg.nxa" as *u8
  let pva: *u8 = "/tmp/ntb_va.png" as *u8
  let pvb: *u8 = "/tmp/ntb_vb.png" as *u8
  let pvd: *u8 = "/tmp/ntb_vd.png" as *u8
  sys_unlinkat(pvd)
  let bo5: *i64 = sys_mmap(16) as *i64
  let fl5: i64 = gb_flen(pt, bo5)
  let mb: *u8 = bo5[0] as *u8
  let w5: *i64 = mb as *i64
  let vwo5: i64 = nxa_find(mb, fl5, nxa_tag4("VERT" as *u8))
  let swo5: i64 = nxa_find(mb, fl5, nxa_tag4("SKEL" as *u8))
  var axok: i64 = 0
  if vwo5 > 0 { if swo5 > 0 { axok = 1 } }
  if axok == 1 {
      let nv5: i64 = w5[vwo5]
      var q5: i64 = 0
      while q5 < nv5 {
          let ty5: i64 = w5[vwo5 + 1 + q5*3 + 1]
          w5[vwo5 + 1 + q5*3 + 1] = w5[vwo5 + 1 + q5*3 + 2]
          w5[vwo5 + 1 + q5*3 + 2] = ty5
          q5 = q5 + 1
      }
      let nj5: i64 = w5[swo5]
      var q6: i64 = 0
      while q6 < nj5 {
          let tz5: i64 = w5[swo5 + 1 + q6*8 + 2]
          w5[swo5 + 1 + q6*8 + 2] = w5[swo5 + 1 + q6*8 + 3]
          w5[swo5 + 1 + q6*8 + 3] = tz5
          q6 = q6 + 1
      }
      // recompute the two payload checksums and the TOC checksum, through nxa_check2 itself
      let ns5: i64 = w5[2]
      var s5: i64 = 0
      while s5 < ns5 {
          let tg5: i64 = w5[4 + s5*4]
          var redo: i64 = 0
          if tg5 == nxa_tag4("VERT" as *u8) { redo = 1 }
          if tg5 == nxa_tag4("SKEL" as *u8) { redo = 1 }
          if redo == 1 {
              let off5: i64 = w5[4 + s5*4 + 1]
              let wl5: i64 = w5[4 + s5*4 + 2]
              w5[4 + s5*4 + 3] = nxa_check2(1, ((mb as i64) + off5) as *i64, wl5)
          }
          s5 = s5 + 1
      }
      w5[3] = nxa_check2(1, ((mb as i64) + 32) as *i64, ns5*4)
      gb_wfile(pyu, mb, fl5)
  }
  gv_check("T12 setup: y-up twin derived from the fixture itself, checksums recomputed" as *u8, axok, ctr)
  let boY: *i64 = sys_mmap(16) as *i64
  let flY: i64 = gb_flen(pyu, boY)
  let yb: *u8 = boY[0] as *u8
  let rvA: i64 = ntb_view(fb2, flen, 64, 7, pva)
  let rvB: i64 = ntb_view(yb, flY, 64, 7, pvb)
  var t13: i64 = 0
  if rvA == 0 { if rvB == 0 {
      let lap: *i64 = sys_mmap(16) as *i64
      let lbp: *i64 = sys_mmap(16) as *i64
      let ba5: *u8 = sys_read_file(pva, lap)
      let bb5: *u8 = sys_read_file(pvb, lbp)
      gv_puts("  axis-invariance: png_a=" as *u8); gv_num(lap[0])
      gv_puts(" png_b=" as *u8); gv_num(lbp[0])
      gv_puts("\n" as *u8)
      if lap[0] > 0 { if lap[0] == lbp[0] { if gb_bytes_eq(ba5, bb5, lap[0]) == 1 { t13 = 1 } } }
  } }
  gv_check("T13 AXIS-INVARIANCE: z-up and y-up authorings of one shape render BYTE-IDENTICAL PNGs" as *u8, t13, ctr)
  // degenerate control: zero every vertex, fix checksums, must refuse and write nothing
  let boD: *i64 = sys_mmap(16) as *i64
  let flD: i64 = gb_flen(pt, boD)
  let db5: *u8 = boD[0] as *u8
  let wD: *i64 = db5 as *i64
  let vwoD: i64 = nxa_find(db5, flD, nxa_tag4("VERT" as *u8))
  if vwoD > 0 {
      let nvD: i64 = wD[vwoD]
      var qD: i64 = 0
      while qD < nvD*3 { wD[vwoD + 1 + qD] = 0; qD = qD + 1 }
      let nsD: i64 = wD[2]
      var sD: i64 = 0
      while sD < nsD {
          if wD[4 + sD*4] == nxa_tag4("VERT" as *u8) {
              let offD: i64 = wD[4 + sD*4 + 1]
              let wlD: i64 = wD[4 + sD*4 + 2]
              wD[4 + sD*4 + 3] = nxa_check2(1, ((db5 as i64) + offD) as *i64, wlD)
          }
          sD = sD + 1
      }
      wD[3] = nxa_check2(1, ((db5 as i64) + 32) as *i64, nsD*4)
      gb_wfile(pdg, db5, flD)
  }
  let boD2: *i64 = sys_mmap(16) as *i64
  let flD2: i64 = gb_flen(pdg, boD2)
  let rvD: i64 = ntb_view(boD2[0] as *u8, flD2, 64, 7, pvd)
  var deg_fired: i64 = 0
  if rvD != 0 {
      let ck: i64 = sys_openat_rd(pvd)
      if ck < 0 { deg_fired = 1 } else { sys_close(ck) }
  }
  var inv_good: i64 = 1
  if rvA == 0 { inv_good = 0 }
  gv_bite("T14 neg-control-degenerate-span-refused-and-writes-no-png (real fixture rendered)" as *u8, deg_fired, inv_good, ctr)
364
  let rcv: i64 = gv_verdict(
366"NXA-TEXBAKE-GATE" as *u8, ctr, "regions from anatomy, albedo atlas baked, per-fragment textured render live" as *u8)
  sys_exit(rcv)
  return rcv
369}
nx_nxa_texbake_gate.nx source

`nx_nxa_texbake_gate.nx` source
