code wiki / _hdl_build / nx_asset_floor_gate.nx
`nx_asset_floor_gate.nx` source

↩ module page · 294 lines · 13820 B
1// nx_asset_floor_gate.nx -- THE ASSET FLOOR: measure our shipped character against a declared
2// game-ready floor, and NAME WHAT IS MISSING. Operator 2026-08-02 pointed at a commercial
3// game-ready character listing as "the floor we need to reach". That listing is behind a bot
4// challenge and could not be read, so this gate does the honest version instead: it parses OUR
5// OWN asset and reports the capability gaps a commercial game-ready character would carry.
6//
7// THE POINT IS THE GAP LIST, NOT A GREEN LIGHT. A gate that only says PASS/FAIL on triangle
8// count would call our figure "game ready" while she ships with no face geometry, no breast
9// bones and no blend shapes -- the exact defects the operator saw on screen. So every capability
10// is REPORTED, present or absent, and the absent ones are the roadmap.
11//
12// Reads the NXA container directly (the format the browser loads): magic NXANIM01, u64 version,
13// u64 section count, then 32-byte section headers {tag[4], _, off, wordlen, ck_lo, ck_hi}.
14// Sections: VERT TRIS SKEL SKIN ANIM (required) + GVRT GTRI (garment) HSTR (hair) POSE (idle).
15// license_tier: ORIGINAL   No hw writes (Rule 26).   expect_exit: 0
16import "nx_syscalls.nx"
17import "nx_gate_verdict.nx"
18
19// the SHIPPED asset: the page fetches ref9d.nxa (DYNA-bearing) first and falls back to ref9.
20// This gate once pointed at the fallback and its DYNA tooth failed against an artifact nothing
21// serves preferentially -- measure what ships, not what shipped before it.
22const AF_PATH: *u8 = "sites/nishifamily/world/ref9d.nxa"
23// midline threshold in bind-x units -- THE SAME 3000 the page's chj classifier uses (one meaning,
24// one number). The previous span/12 (~14294 here) swallowed the REAL pectoral chain (|x|~8800,
25// joints 76-79, skinned 230-428 verts each, tracked) into the "midline spine" count and reported
26// LATERAL PAIR = 0 against a rig that has carried a wired 2-bone-per-side pair all along. Months
27// of vertex-band workaround rode that false RED.
28const AF_MIDLINE: i64 = 3000
29const AF_HDR: i64 = 32
30const AF_SECHDR: i64 = 32
31// declared floor -- every bound carries its reason, and the tri ceiling comes from the measured
32// VR budget (Quest 3 1.3-1.8M tris/frame; a cast of 12 must fit inside a fraction of that)
33const AF_TRI_MIN: i64 = 8000
34const AF_TRI_MAX: i64 = 120000
35const AF_JOINT_MIN: i64 = 40
36const AF_VERT_MIN: i64 = 4000
37
38func af_rd64(b: *u8, off: i64) -> i64 {
  var v: i64 = 0
  var i: i64 = 7
  while i >= 0 { v = v*256 + ((b[off + i] & 0xff) as i64); i = i - 1 }
  return v
43}
44func af_tag(b: *u8, off: i64, t: *u8) -> i64 {
  var i: i64 = 0
  while i < 4 { if b[off + i] != t[i] { return 0 } i = i + 1 }
  return 1
48}
49// section offset by tag, or -1
50func af_find(b: *u8, nsec: i64, t: *u8) -> i64 {
  var s: i64 = 0
  while s < nsec {
      let e: i64 = AF_HDR + s*AF_SECHDR
      if af_tag(b, e, t) == 1 { return af_rd64(b, e + 8) }
      s = s + 1
  }
  return 0 - 1
58}
59func af_report(name: *u8, present: i64) -> i64 {
  gv_puts("  " as *u8)
  gv_puts(name)
  if present == 1 { gv_puts(": PRESENT\n" as *u8) } else { gv_puts(": ABSENT -- gap to the floor\n" as *u8) }
  return present
64}
65
66func main(argc: i64, argv: *i64) -> i64 {
  let ctr: *i64 = gv_ctr()
  gv_head("nx_asset_floor gate -- our shipped character measured against a game-ready floor" as *u8)
  // ★ THE ASSET UNDER TEST IS AN ARGUMENT. A gate that can only ever read ONE hardcoded path
  // cannot measure a candidate against the shipped one, so it can never PROVE an improvement --
  // it can only ever describe the status quo. Defaults to the shipped asset when given nothing.
  var apath: *u8 = AF_PATH
  if argc >= 2 { apath = argv[1] as *u8 }
  gv_puts("  asset: " as *u8); gv_puts(apath); gv_puts("\n" as *u8)
  let lp: *i64 = sys_mmap(16) as *i64
  let b: *u8 = sys_read_file(apath, lp)
  if (b as i64) == 0 {
      gv_puts("  cannot read the character asset\n" as *u8)
      gv_check("asset present" as *u8, 0, ctr)
      let rcx: i64 = gv_verdict("ASSET-FLOOR" as *u8, ctr, "no asset" as *u8)
      sys_exit(rcx)
      return rcx
  }
  let n: i64 = lp[0]
  gv_puts("  container bytes=" as *u8); gv_num(n); gv_puts("\n" as *u8)
  var magic: i64 = 1
  let mg: *u8 = "NXANIM01" as *u8
  var i: i64 = 0
  while i < 8 { if b[i] != mg[i] { magic = 0 } i = i + 1 }
  gv_check("container magic is NXANIM01" as *u8, magic, ctr)
  if magic == 0 {
      let rcm: i64 = gv_verdict("ASSET-FLOOR" as *u8, ctr, "bad container" as *u8)
      sys_exit(rcm)
      return rcm
  }
  let nsec: i64 = af_rd64(b, 16)
  gv_puts("  sections=" as *u8); gv_num(nsec); gv_puts("\n" as *u8)
  // ★A CAPABILITY REPORT THAT ONLY NAMES WHAT IT LOOKED FOR CANNOT TELL YOU WHAT YOU HAVE.
  // This gate checked 7 tags against an asset carrying 11 sections, so four were invisible to
  // its own inventory -- and the texture-capability question ("does this mesh carry UVs at all?")
  // lives in exactly that blind spot. Enumerate every tag the file declares, then answer.
  gv_puts("  declared tags:" as *u8)
  let tagbuf: *u8 = sys_mmap(8)
  var si: i64 = 0
  while si < nsec {
      let se: i64 = AF_HDR + si*AF_SECHDR
      gv_puts(" " as *u8)
      var ci: i64 = 0
      while ci < 4 { tagbuf[ci] = b[se + ci]; ci = ci + 1 }
      tagbuf[4] = 0
      gv_puts(tagbuf)
      gv_puts(":" as *u8); gv_num(af_rd64(b, se + 16))
      si = si + 1
  }
  gv_puts("\n" as *u8)
116
  // ---- geometry the floor requires ----
  let ov: i64 = af_find(b, nsec, "VERT" as *u8)
  let ot: i64 = af_find(b, nsec, "TRIS" as *u8)
  let ok9: i64 = af_find(b, nsec, "SKEL" as *u8)
  var nv: i64 = 0
  var nt: i64 = 0
  var nj: i64 = 0
  if ov >= 0 { nv = af_rd64(b, ov) }
  if ot >= 0 { nt = af_rd64(b, ot) }
  if ok9 >= 0 { nj = af_rd64(b, ok9) }
  gv_puts("  verts=" as *u8); gv_num(nv)
  gv_puts(" tris=" as *u8); gv_num(nt)
  gv_puts(" joints=" as *u8); gv_num(nj); gv_puts("\n" as *u8)
  var vok: i64 = 0
  if nv >= AF_VERT_MIN { vok = 1 }
  gv_check("vertex count clears the floor" as *u8, vok, ctr)
  var tok: i64 = 0
  if nt >= AF_TRI_MIN { if nt <= AF_TRI_MAX { tok = 1 } }
  gv_check("triangle count inside the VR-budget band" as *u8, tok, ctr)
  var jok: i64 = 0
  if nj >= AF_JOINT_MIN { jok = 1 }
  gv_check("skeleton has enough joints to deform" as *u8, jok, ctr)
139
  // ---- the capability gaps: reported whether present or not ----
  gv_puts("\n  -- capability inventory (absent rows ARE the roadmap) --\n" as *u8)
  var have: i64 = 0
  var want: i64 = 0
  let gv1: i64 = af_find(b, nsec, "GVRT" as *u8)
  var p1: i64 = 0
  if gv1 >= 0 { p1 = 1 }
  af_report("garment geometry (GVRT)" as *u8, p1)
  have = have + p1
  want = want + 1
  let hs1: i64 = af_find(b, nsec, "HSTR" as *u8)
  var p2: i64 = 0
  if hs1 >= 0 { p2 = 1 }
  af_report("hair strands (HSTR)" as *u8, p2)
  have = have + p2
  want = want + 1
  let po1: i64 = af_find(b, nsec, "POSE" as *u8)
  var p3: i64 = 0
  if po1 >= 0 { p3 = 1 }
  af_report("idle pose (POSE)" as *u8, p3)
  have = have + p3
  want = want + 1
  // a commercial game-ready character ships these; ours does not yet. Named, not hidden.
  let fa1: i64 = af_find(b, nsec, "FACE" as *u8)
  var p4: i64 = 0
  if fa1 >= 0 { p4 = 1 }
  af_report("face geometry (FACE) -- we PAINT the face from ratios instead" as *u8, p4)
  have = have + p4
  want = want + 1
  let mo1: i64 = af_find(b, nsec, "MORF" as *u8)
  var p5: i64 = 0
  if mo1 >= 0 { p5 = 1 }
  af_report("blend shapes / morph targets (MORF) -- no expressions without these" as *u8, p5)
  have = have + p5
  want = want + 1
  let tx1: i64 = af_find(b, nsec, "TEXM" as *u8)
  var p6: i64 = 0
  if tx1 >= 0 { p6 = 1 }
  af_report("PBR texture maps (TEXM) -- we shade procedurally from genome" as *u8, p6)
  have = have + p6
  want = want + 1
  let dy1: i64 = af_find(b, nsec, "DYNA" as *u8)
  var p7: i64 = 0
  if dy1 >= 0 { p7 = 1 }
  af_report("per-bone physics declarations (DYNA)" as *u8, p7)
  have = have + p7
  want = want + 1
  // ★ PRESENCE OF A SECTION IS NOT PRESENCE OF THE CAPABILITY. A DYNA section carrying two
  // midline bones would satisfy "DYNA: PRESENT" while leaving soft tissue exactly as unriggable
  // as before -- so the tooth is the LATERAL PAIR itself: one bone declared left of the midline
  // and one right of it, each with a real anchor. That is what a spine chain cannot fake.
  var latpair: i64 = 0
  if dy1 >= 0 {
      let ndb: i64 = af_rd64(b, dy1)
      let dstr: i64 = af_rd64(b, dy1 + 8)
      gv_puts("  DYNA bones=" as *u8); gv_num(ndb)
      gv_puts(" stride=" as *u8); gv_num(dstr); gv_puts("\n" as *u8)
      var sawL: i64 = 0
      var sawR: i64 = 0
      var d: i64 = 0
      while d < ndb {
          let db: i64 = dy1 + 16 + d*dstr*8
          let dside: i64 = af_rd64(b, db)
          let dx: i64 = af_rd64(b, db + 8)
          let dz: i64 = af_rd64(b, db + 24)
          let dk: i64 = af_rd64(b, db + 32)
          let dmax: i64 = af_rd64(b, db + 48)
          gv_puts("    bone side=" as *u8); gv_num(dside)
          gv_puts(" x=" as *u8); gv_num(dx)
          gv_puts(" z=" as *u8); gv_num(dz)
          gv_puts(" k=" as *u8); gv_num(dk)
          gv_puts(" travel=" as *u8); gv_num(dmax); gv_puts("\n" as *u8)
          if dside < 0 { if dx < 0 { sawL = 1 } }
          if dside > 0 { if dx > 0 { sawR = 1 } }
          d = d + 1
      }
      if sawL == 1 { if sawR == 1 { latpair = 1 } }
  }
  gv_check("DYNA declares a LATERAL soft-tissue pair (not the spine)" as *u8, latpair, ctr)
219
  // ---- SOFT-TISSUE BONES: the defect the anatomy probe already proved ----
  // a bust bone would sit near 744 permil of stature, front hemisphere. Its ABSENCE is why
  // the chest had to be driven at the vertex band instead of a joint.
  // ★NORMALIZE ON THE VERTEX SPAN, exactly as the browser-side anatomy probe does. A first
  // version normalized on the JOINT span and reported 5 bust-band joints where the browser
  // reported none -- two instruments measuring the SAME asset and CONTRADICTING each other,
  // purely because the joint ladder is shorter than the mesh (feet and crown carry no bones).
  // A shared basis is what makes two probes corroborate instead of argue.
  var bust: i64 = 0
  var central: i64 = 0
  var latL: i64 = 0
  var latR: i64 = 0
  if ok9 >= 0 { if ov >= 0 {
      var zmin: i64 = 0
      var zmax: i64 = 0
      var first: i64 = 1
      var vi: i64 = 0
      while vi < nv {
          let vz: i64 = af_rd64(b, ov + 8 + (vi*3 + 2)*8)
          if first == 1 { zmin = vz; zmax = vz; first = 0 }
          if vz < zmin { zmin = vz }
          if vz > zmax { zmax = vz }
          vi = vi + 1
      }
      let span: i64 = zmax - zmin
      if span > 0 {
          var j: i64 = 0
          while j < nj {
              let jb2: i64 = ok9 + 8 + j*64
              let bz2: i64 = af_rd64(b, jb2 + 24)
              let by2: i64 = af_rd64(b, jb2 + 16)
              let permil: i64 = (bz2 - zmin)*1000/span
              let bx2: i64 = af_rd64(b, jb2 + 8)
              var ax2: i64 = bx2
              if ax2 < 0 { ax2 = 0 - ax2 }
              // CENTRAL vs LATERAL decides usability: a sternum/chest joint sits near the
              // midline; a clavicle or shoulder sits far off it and would swing the ARM.
              // Counting them together is how "the rig has bust joints" and "the rig has
              // none" can both look true.
              if permil >= 700 { if permil <= 790 { if by2 < 0 {
                  bust = bust + 1
                  if ax2 < AF_MIDLINE { central = central + 1 }
                  if ax2 >= AF_MIDLINE { if bx2 < 0 { latL = latL + 1 } }
                  if ax2 >= AF_MIDLINE { if bx2 > 0 { latR = latR + 1 } }
              } } }
              j = j + 1
          }
      }
  } }
  gv_puts("  bust-band joints (700..790 permil, front): " as *u8); gv_num(bust)
  gv_puts(" | midline (spine/sternum chain): " as *u8); gv_num(central)
  gv_puts(" | lateral L=" as *u8); gv_num(latL)
  gv_puts(" R=" as *u8); gv_num(latR); gv_puts("\n" as *u8)
  // a PAIR means one per side -- four same-side helpers must not pass as a pair
  var skelpair: i64 = 0
  if latL >= 1 { if latR >= 1 { skelpair = 1 } }
  if skelpair == 1 {
      gv_puts("  <- THE SKELETON CARRIES THE LATERAL PAIR (wired: skinned + tracked). The vertex-band\n" as *u8)
      gv_puts("     chest workaround is now driving AROUND real bones -- route the spring onto them.\n" as *u8)
  }
  if skelpair == 0 {
      gv_puts("  <- NO LATERAL PAIR IN THE SKELETON: real breast bones come in L/R pairs OFF the\n" as *u8)
      gv_puts("     midline; midline joints at chest height are the SPINE chain. Soft tissue must\n" as *u8)
      gv_puts("     then be driven at the vertex band (and nx_nxa_dyna can declare the pair).\n" as *u8)
  }
  gv_check("SKEL carries a lateral bust pair (one bone per side, off-midline, front)" as *u8, skelpair, ctr)
286
  gv_puts("\n  capability score: " as *u8); gv_num(have); gv_puts("/" as *u8); gv_num(want)
  gv_puts(" -- every ABSENT row above is a named rung, not a hidden failure\n" as *u8)
  // the floor gate PASSES on geometry and REPORTS capability: a red here would say the asset
  // is broken, which it is not. What it lacks is coverage, and coverage is tracked as debt.
  let rc: i64 = gv_verdict("ASSET-FLOOR" as *u8, ctr, "geometry clears the floor; capability gaps enumerated" as *u8)
  sys_exit(rc)
  return rc
294}
nx_asset_floor_gate.nx source

`nx_asset_floor_gate.nx` source
