`nx_nxa_pose.nx` source

↩ module page · 379 lines · 13621 B
1// nx_nxa_pose.nx -- POSE section compiler: freezes ANIM channel-2 keyframes into the NXA
2// pose library (spec: knowledge/nxa_format_spec.md POSE). A pose entry is one frozen
3// channel-2 keyframe per joint -- [joint][qx qy qz qw q12][dtx dty dtz mm], world-delta
4// about bind, root horizontal motion removed -- so a player applies it with the exact LBS
5// the ANIM path already proves (M x = D(x-b)+b+dt), no FK reconstruction (which would
6// re-introduce the dead-chain-adoption shard class: adopted joints' dt is donor-relative,
7// not parent-relative).
8// freeze picks its frame BY MEASUREMENT when t=-1: the sample minimizing horizontal foot
9// separation (feet passing = legs together = reads as standing), never by taste.
10// usage: nx_nxa_pose freeze <in.nxa> <out.nxa> <pose_id> <t_ms|-1>
11//        nx_nxa_pose list <in.nxa>
12// rc: 0 ok, 2 usage, 4 missing SKEL/ANIM/tracks, 5 corrupt, 6 future-version, 9 io
13// license_tier: ORIGINAL
14import "nx_syscalls.nx"
15import "nx_nxa.nx"
16import "nx_nxa_fk.nx"
17
18const NP_MAGIC_65535: i64 = 65535
19const NP_MAGIC_32767: i64 = 32767
20const NP_MAGIC_65536: i64 = 65536
21const NP_MAGIC_4096: i64 = 4096
22const NP_MAGIC_1000: i64 = 1000
23const NP_MAGIC_33: i64 = 33
24const NP_MAGIC_52: i64 = 52
25const NP_MAGIC_100: i64 = 100
26const NP_MAGIC_256: i64 = 256
27const NP_MAGIC_1000000000: i64 = 1000000000
28
29func npw(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
30func npn(v: i64) -> i64 {
  let t: *u8 = sys_mmap(32) as *u8
  var m: i64 = v; var w: i64 = 0
  if m<0 { t[w]=45 as u8; w=w+1; m=0-m }
  if m==0 { t[w]=48 as u8; sys_write(1,t,w+1); return 0 }
  let d: *u8 = sys_mmap(32) as *u8
  var k: i64=0
  while m>0 { d[k]=(48+(m%10)) as u8; m=m/10; k=k+1 }
  var j: i64=0
  while j<k { t[w]=d[k-1-j]; w=w+1; j=j+1 }
  sys_write(1,t,w); return 0
41}
42func np_atoi(s: *u8) -> i64 {
  var v: i64 = 0
  var i: i64 = 0
  var neg: i64 = 0
  if s[0]==(45 as u8) { neg=1; i=1 }
  while s[i]>=(48 as u8) {
      if s[i]>(57 as u8) { return v }
      v = v*10 + ((s[i] as i64) - 48)
      i = i + 1
  }
  if neg==1 { v = 0-v }
  return v
54}
55func np_seq(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
63}
64// sign-extend a 16-bit lane out of an i64 word (channel-2 packed keys)
65func np_i16(w: i64, sh: i64) -> i64 {
  var v: i64 = (w >> sh) & NP_MAGIC_65535
  if v > NP_MAGIC_32767 { v = v - NP_MAGIC_65536 }
  return v
69}
70// sample one channel-2 track at t ms: shortest-path integer nlerp dq + lerp dt.
71// out7 = [qx qy qz qw dtx dty dtz]; koff = word offset of first key in h
72func np_sample(h: *i64, koff: i64, nk: i64, t: i64, out7: *i64) -> i64 {
  var k: i64 = 0
  var scan: i64 = 1
  while scan == 1 {
      scan = 0
      if k+1 < nk {
          let tn: i64 = h[koff+(k+1)*2] & NP_MAGIC_65535
          if tn <= t { k = k + 1; scan = 1 }
      }
  }
  var k1: i64 = k + 1
  if k1 >= nk { k1 = k }
  let w0a: i64 = h[koff+k*2]
  let w1a: i64 = h[koff+k*2+1]
  let w0b: i64 = h[koff+k1*2]
  let w1b: i64 = h[koff+k1*2+1]
  let t0: i64 = w0a & NP_MAGIC_65535
  let t1: i64 = w0b & NP_MAGIC_65535
  var u: i64 = 0
  if t1 > t0 { u = (t - t0)*NP_MAGIC_1000/(t1 - t0) }
  if u < 0 { u = 0 }
  if u > NP_MAGIC_1000 { u = NP_MAGIC_1000 }
  let ax: i64 = np_i16(w0a,16)
  let ay: i64 = np_i16(w0a,32)
  let az: i64 = np_i16(w0a,48)
  let aq: i64 = np_i16(w1a,0)
  var bx: i64 = np_i16(w0b,16)
  var by: i64 = np_i16(w0b,32)
  var bz: i64 = np_i16(w0b,48)
  var bq: i64 = np_i16(w1b,0)
  if ax*bx + ay*by + az*bz + aq*bq < 0 { bx=0-bx; by=0-by; bz=0-bz; bq=0-bq }
  out7[0] = ax + (bx-ax)*u/NP_MAGIC_1000
  out7[1] = ay + (by-ay)*u/NP_MAGIC_1000
  out7[2] = az + (bz-az)*u/NP_MAGIC_1000
  out7[3] = aq + (bq-aq)*u/NP_MAGIC_1000
  nf_qnorm(out7)
  let dxa: i64 = np_i16(w1a,16)
  let dya: i64 = np_i16(w1a,32)
  let dza: i64 = np_i16(w1a,48)
  let dxb: i64 = np_i16(w1b,16)
  let dyb: i64 = np_i16(w1b,32)
  let dzb: i64 = np_i16(w1b,48)
  out7[4] = dxa + (dxb-dxa)*u/NP_MAGIC_1000
  out7[5] = dya + (dyb-dya)*u/NP_MAGIC_1000
  out7[6] = dza + (dzb-dza)*u/NP_MAGIC_1000
  return 0
118}
119
120func main(argc: i64, argv: *i64) -> i64 {
  if argc < 3 { npw("usage: nx_nxa_pose freeze <in.nxa> <out.nxa> <pose_id> <t_ms|-1> | list <in.nxa>\n" as *u8); return 2 }
  let verb: *u8 = argv[1] as *u8
  let lp: *i64 = sys_mmap(16) as *i64
  let b: *u8 = sys_map_file(argv[2] as *u8, lp)
  let flen: i64 = lp[0]
  if flen < 96 { npw("unreadable\n" as *u8); return 5 }
  let h: *i64 = b as *i64
  let swo: i64 = nxa_find(b, flen, nxa_tag4("SKEL" as *u8))
  if swo == 0 - 2 { npw("NXA-FUTURE-VERSION\n" as *u8); return 6 }
  if swo == 0 - 3 { npw("NXA-CORRUPT skel\n" as *u8); return 5 }
  if swo < 0 { npw("no SKEL\n" as *u8); return 4 }
  let nj: i64 = h[swo]
  let sk: *i64 = ((b as i64) + swo*8 + 8) as *i64
  let awo: i64 = nxa_find(b, flen, nxa_tag4("ANIM" as *u8))
  if awo == 0 - 3 { npw("NXA-CORRUPT anim\n" as *u8); return 5 }
  let pwo: i64 = nxa_find(b, flen, nxa_tag4("POSE" as *u8))
  if pwo == 0 - 3 { npw("NXA-CORRUPT pose\n" as *u8); return 5 }
138
  if np_seq(verb, "list" as *u8) == 1 {
      if pwo < 0 { npw("poses=0\n" as *u8); return 0 }
      let npz: i64 = h[pwo]
      npw("poses=" as *u8); npn(npz); npw("\n" as *u8)
      var rp: i64 = pwo + 1
      var pi: i64 = 0
      while pi < npz {
          npw("  pose id=" as *u8); npn(h[rp])
          npw(" entries=" as *u8); npn(h[rp+1]); npw("\n" as *u8)
          rp = rp + 2 + h[rp+1]*8
          pi = pi + 1
      }
      return 0
  }
  if np_seq(verb, "freeze" as *u8) == 0 { npw("unknown verb\n" as *u8); return 2 }
  if argc < 6 { npw("usage: nx_nxa_pose freeze <in.nxa> <out.nxa> <pose_id> <t_ms|-1>\n" as *u8); return 2 }
  if awo < 0 { npw("no ANIM\n" as *u8); return 4 }
  let a4: *u8 = argv[4] as *u8
  let a5: *u8 = argv[5] as *u8
  let pid: i64 = np_atoi(a4)
  var targ: i64 = np_atoi(a5)
160
  // index channel-2 tracks by joint: koff/nk per joint (-1 = untracked)
  let tko: *i64 = sys_mmap(nj*8 + 64) as *i64
  let tkn: *i64 = sys_mmap(nj*8 + 64) as *i64
  var j0: i64 = 0
  while j0 < nj { tko[j0] = 0 - 1; tkn[j0] = 0; j0 = j0 + 1 }
  let ntr: i64 = h[awo]
  var rp2: i64 = awo + 1
  var dur: i64 = 0
  var ti: i64 = 0
  var tracked: i64 = 0
  while ti < ntr {
      let jt: i64 = h[rp2]
      let ch: i64 = h[rp2+1]
      let nk: i64 = h[rp2+2]
      if ch == 2 {
          if jt >= 0 { if jt < nj { if nk > 0 {
              tko[jt] = rp2 + 3
              tkn[jt] = nk
              tracked = tracked + 1
              let lastt: i64 = h[rp2+3+(nk-1)*2] & NP_MAGIC_65535
              if lastt > dur { dur = lastt }
          } } }
          rp2 = rp2 + 3 + nk*2
      }
      if ch == 0 { rp2 = rp2 + 3 + nk*4 }
      if ch == 1 { rp2 = rp2 + 3 + nk*5 }
      ti = ti + 1
  }
  if tracked == 0 { npw("no channel-2 tracks\n" as *u8); return 4 }
190
  // structural picks from binds (no names in NXA): H = max bind z;
  // root = nearest (0,0,.52H); feet = per side (bind x sign) the lowest-z TRACKED joint
  var hmax: i64 = 0
  var j1: i64 = 0
  while j1 < nj { if sk[j1*8+3] > hmax { hmax = sk[j1*8+3] } j1 = j1 + 1 }
  var rj: i64 = 0 - 1
  var rsc: i64 = NP_MAGIC_1000000000
  var fl: i64 = 0 - 1
  var flz: i64 = NP_MAGIC_1000000000
  var fr: i64 = 0 - 1
  var frz: i64 = NP_MAGIC_1000000000
  var j2: i64 = 0
  while j2 < nj {
      let bxj: i64 = sk[j2*8+1]
      let bzj: i64 = sk[j2*8+3]
      var ds: i64 = bzj - hmax*NP_MAGIC_52/NP_MAGIC_100
      if ds < 0 { ds = 0-ds }
      var axj: i64 = bxj
      if axj < 0 { axj = 0-axj }
      let sc: i64 = ds + 2*axj
      if sc < rsc { rsc = sc; rj = j2 }
      if tko[j2] >= 0 {
          if bxj < 0-NP_MAGIC_1000 { if bzj < flz { flz = bzj; fl = j2 } }
          if bxj > NP_MAGIC_1000 { if bzj < frz { frz = bzj; fr = j2 } }
      }
      j2 = j2 + 1
  }
218
  let ev: *i64 = sys_mmap(64) as *i64
  let ev2: *i64 = sys_mmap(64) as *i64
  // auto frame pick: minimize horizontal foot separation across the clip (33ms grid).
  // dt lanes are MILLIMETERS (the bake divides by 100 to fit i16); binds are 0.01mm
  // units -- scale dt x100 before mixing (the unit-mismatch class MEASURED 2026-07-29:
  // consumers applying raw lanes rendered every baked translation at 1%)
  if targ < 0 {
      if fl < 0 { npw("no left foot track\n" as *u8); return 4 }
      if fr < 0 { npw("no right foot track\n" as *u8); return 4 }
      var bt: i64 = 0
      var bsep: i64 = NP_MAGIC_1000000000*NP_MAGIC_1000
      var t: i64 = 0
      while t <= dur {
          np_sample(h, tko[fl], tkn[fl], t, ev)
          np_sample(h, tko[fr], tkn[fr], t, ev2)
          let px: i64 = (sk[fl*8+1] + ev[4]*NP_MAGIC_100) - (sk[fr*8+1] + ev2[4]*NP_MAGIC_100)
          let py: i64 = (sk[fl*8+2] + ev[5]*NP_MAGIC_100) - (sk[fr*8+2] + ev2[5]*NP_MAGIC_100)
          let sep: i64 = px*px + py*py
          if sep < bsep { bsep = sep; bt = t }
          t = t + NP_MAGIC_33
      }
      targ = bt
      npw("auto t_ms=" as *u8); npn(bt)
      npw(" footsep_units=" as *u8); npn(nf_isqrt(bsep)); npw("\n" as *u8)
  }
244
  // sample every tracked joint at targ; POSE entries store dt in VERT units (mm lanes
  // x100) so players compose them with binds directly, no scale knowledge needed
  let pq: *i64 = sys_mmap(nj*32 + 64) as *i64
  let pd: *i64 = sys_mmap(nj*24 + 64) as *i64
  var j3: i64 = 0
  while j3 < nj {
      if tko[j3] >= 0 {
          np_sample(h, tko[j3], tkn[j3], targ, ev)
          pq[j3*4] = ev[0]
          pq[j3*4+1] = ev[1]
          pq[j3*4+2] = ev[2]
          pq[j3*4+3] = ev[3]
          pd[j3*3] = ev[4]*NP_MAGIC_100
          pd[j3*3+1] = ev[5]*NP_MAGIC_100
          pd[j3*3+2] = ev[6]*NP_MAGIC_100
      }
      j3 = j3 + 1
  }
  // root horizontal motion removal (same convention the runtime applies to the clip)
  var rdx: i64 = 0
  var rdy: i64 = 0
  if rj >= 0 { if tko[rj] >= 0 { rdx = pd[rj*3]; rdy = pd[rj*3+1] } }
  var j4: i64 = 0
  while j4 < nj {
      if tko[j4] >= 0 { pd[j4*3] = pd[j4*3] - rdx; pd[j4*3+1] = pd[j4*3+1] - rdy }
      j4 = j4 + 1
  }
272
  // build the new POSE payload: kept old poses (id != pid) + the frozen one
  var keptw: i64 = 0
  var keptn: i64 = 0
  if pwo >= 0 {
      let npz0: i64 = h[pwo]
      var rp3: i64 = pwo + 1
      var pi2: i64 = 0
      while pi2 < npz0 {
          let sz: i64 = 2 + h[rp3+1]*8
          if h[rp3] != pid { keptw = keptw + sz; keptn = keptn + 1 }
          rp3 = rp3 + sz
          pi2 = pi2 + 1
      }
  }
  let newpw: i64 = 2 + tracked*8
  let plen: i64 = 1 + keptw + newpw
  let pp: *i64 = sys_mmap(plen*8 + 64) as *i64
  pp[0] = keptn + 1
  var wp: i64 = 1
  if pwo >= 0 {
      let npz1: i64 = h[pwo]
      var rp4: i64 = pwo + 1
      var pi3: i64 = 0
      while pi3 < npz1 {
          let sz2: i64 = 2 + h[rp4+1]*8
          if h[rp4] != pid {
              var cw: i64 = 0
              while cw < sz2 { pp[wp+cw] = h[rp4+cw]; cw = cw + 1 }
              wp = wp + sz2
          }
          rp4 = rp4 + sz2
          pi3 = pi3 + 1
      }
  }
  pp[wp] = pid
  pp[wp+1] = tracked
  wp = wp + 2
  var j5: i64 = 0
  while j5 < nj {
      if tko[j5] >= 0 {
          pp[wp] = j5
          pp[wp+1] = pq[j5*4]
          pp[wp+2] = pq[j5*4+1]
          pp[wp+3] = pq[j5*4+2]
          pp[wp+4] = pq[j5*4+3]
          pp[wp+5] = pd[j5*3]
          pp[wp+6] = pd[j5*3+1]
          pp[wp+7] = pd[j5*3+2]
          wp = wp + 8
      }
      j5 = j5 + 1
  }
325
  // write out: copy every section except any old POSE, append the new POSE
  let ptag: i64 = nxa_tag4("POSE" as *u8)
  let ons: i64 = h[2]
  let otoc: *i64 = ((b as i64) + 32) as *i64
  var keep: i64 = 0
  var ci: i64 = 0
  while ci < ons {
      if otoc[ci*4] != ptag { keep = keep + 1 }
      ci = ci + 1
  }
  let ns2: i64 = keep + 1
  let hdr: *i64 = sys_mmap(64) as *i64
  let toc: *i64 = sys_mmap(ns2*32 + 64) as *i64
  var o: i64 = 32 + ns2*32
  var wi: i64 = 0
  var ci2: i64 = 0
  while ci2 < ons {
      if otoc[ci2*4] != ptag {
          toc[wi*4] = otoc[ci2*4]
          toc[wi*4+1] = o
          toc[wi*4+2] = otoc[ci2*4+2]
          toc[wi*4+3] = otoc[ci2*4+3]
          o = o + otoc[ci2*4+2]*8
          wi = wi + 1
      }
      ci2 = ci2 + 1
  }
  toc[wi*4] = ptag
  toc[wi*4+1] = o
  toc[wi*4+2] = plen
  toc[wi*4+3] = nxa_check2(1, pp, plen)
  hdr[0] = nxa_magic()
  hdr[1] = NXA_VER
  hdr[2] = ns2
  hdr[3] = nxa_check2(1, toc, ns2*4)
  let fd: i64 = sys_openat_wr(argv[3] as *u8, 0x1a4)
  if fd < 0 { npw("open out failed\n" as *u8); return 9 }
  sys_write(fd, hdr as *u8, 32)
  sys_write(fd, toc as *u8, ns2*32)
  var ci3: i64 = 0
  while ci3 < ons {
      if otoc[ci3*4] != ptag {
          sys_write(fd, ((b as i64) + otoc[ci3*4+1]) as *u8, otoc[ci3*4+2]*8)
      }
      ci3 = ci3 + 1
  }
  sys_write(fd, pp as *u8, plen*8)
  sys_close(fd)
  npw("POSE written id=" as *u8); npn(pid)
  npw(" t_ms=" as *u8); npn(targ)
  npw(" entries=" as *u8); npn(tracked)
  npw(" sections=" as *u8); npn(ns2); npw("\n" as *u8)
  return 0
379}
nx_nxa_pose.nx source

`nx_nxa_pose.nx` source
