`nx_nxa_anim.nx` source

↩ module page · 1519 lines · 67919 B
1// nx_nxa_anim.nx -- ANIMATION IMPORTER v2: extracts the FBX's authored animation and BAKES it
2// to the NXA's normative delta-LBS convention. v1 wrote raw Lcl-space Euler quats (channel 1)
3// which are NOT drivable without the FBX local hierarchy (pre-rotations, parent chain); v2
4// evaluates full integer FK per 30Hz sample -- local = PreRotation x LclRotation(t) chained
5// down the joint parents -- and emits per-joint WORLD-SPACE deltas about the bind pose
6// (channel 2, packed 2-word keys), the exact form the LBS viewer consumes: M x = D(x-b)+b+dt.
7// SELF-VALIDATING: the static FK must reproduce the SKEL bind translations (TransformLink
8// ground truth) or the tool REFUSES (exit 7) -- pre-rotation/hierarchy math is proven against
9// data already trusted, never assumed.
10// usage: nx_nxa_anim <in.fbx> <in.nxa5> <out.nxa>
11// rc: 0 ok, 2 usage, 3 fbx unreadable, 4 no animation, 5 in.nxa bad, 7 rig-mismatch, 9 io
12// license_tier: ORIGINAL
13import "nx_syscalls.nx"
14import "nx_zlib_wrap.nx"
15import "nx_nxa.nx"
16import "nx_itrig.nx"
17import "nx_nxa_fk.nx"
18import "nx_fbx_clip.nx"
19const A_MAGIC_1500: i64 = 1500
20const A_MAGIC_2047: i64 = 2047
21const A_MAGIC_1048575: i64 = 1048575
22const A_MAGIC_4503599627370496: i64 = 4503599627370496
23const A_MAGIC_8388607: i64 = 8388607
24const A_MAGIC_8388608: i64 = 8388608
25const A_MAGIC_4090: i64 = 4090
26const A_MAGIC_2040: i64 = 2040
27const A_MAGIC_119990: i64 = 119990
28const A_MAGIC_4096: i64 = 4096
29const A_MAGIC_46186158: i64 = 46186158
30const A_MAGIC_180000: i64 = 180000
31const A_MAGIC_360000: i64 = 360000
32const A_MAGIC_7500: i64 = 7500
33const A_MAGIC_500000: i64 = 500000
34const A_MAGIC_60000: i64 = 60000
35const A_MAGIC_20000: i64 = 20000
36const A_MAGIC_4611686018427387903: i64 = 4611686018427387903
37const A_MAGIC_2000: i64 = 2000
38const A_MAGIC_200000: i64 = 200000
39const A_MAGIC_32767: i64 = 32767
40const A_MAGIC_65535: i64 = 65535
41const A_MAGIC_1024: i64 = 1024
42
43// G layout: 0=mcount 1=curvecount 2=conncount 3=anodecount
44const A_MO: i64 = 16          // model ids x4096
45const A_LO: i64 = 4112        // limb flags x4096
46const A_AN: i64 = 8208        // AnimationCurveNode ids x2048
47const A_CID: i64 = 10256      // curve ids x2048
48const A_CKT: i64 = 12304     // curve KeyTime meta (off,alen,enc,clen) x2048x4
49const A_CKV: i64 = 20496     // curve KeyValueFloat meta               x2048x4
50const A_CONN: i64 = 28688    // conns (src,dst,ptag) x120000x3
51const A_PR: i64 = 388688     // per-model PreRotation millideg x3
52const A_LR: i64 = 400976     // per-model Lcl Rotation default millideg x3
53const A_LT: i64 = 413264     // per-model Lcl Translation default units x3
54const A_PF: i64 = 425552     // per-model flags: 1=pre 2=lclrot 4=lclt
55const A_NO: i64 = 430000     // per-model name byte offset (into the mapped fbx)
56const A_NL: i64 = 434096     // per-model name length
57const A_WORDS: i64 = 440000
58
59func aw(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
60func an(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[0]=48 as u8; sys_write(1,t,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
71}
72func a_u32(b: *u8, o: i64) -> i64 {
  return ((b[o] & 0xff) as i64) | (((b[o+1] & 0xff) as i64) << 8)
       | (((b[o+2] & 0xff) as i64) << 16) | (((b[o+3] & 0xff) as i64) << 24)
75}
76func a_u64(b: *u8, o: i64) -> i64 { return a_u32(b, o) | (a_u32(b, o + 4) << 32) }
77// f64 -> value x scale (DRY debt: shared nx_f64.nx when the next user appears)
78func a_f64(b: *u8, o: i64, scale: i64) -> i64 {
  let lo: i64 = a_u32(b, o)
  let hi: i64 = a_u32(b, o + 4)
  let sign: i64 = (hi >> 31) & 1
  let expo: i64 = (hi >> 20) & A_MAGIC_2047
  if expo == 0 { return 0 }
  var mant: i64 = ((hi & A_MAGIC_1048575) << 32) | lo
  mant = mant | A_MAGIC_4503599627370496
  let sh: i64 = expo - 1023
  var v: i64 = 0
  if sh >= 52 { v = mant * scale * (1 << (sh - 52)) }
  if sh < 52 {
      let rs: i64 = 52 - sh
      if rs > 62 { return 0 }
      v = (mant * scale) >> rs
  }
  if sign == 1 { return 0 - v }
  return v
96}
97func a_f32(b: *u8, o: i64, scale: i64) -> i64 {
  let w: i64 = a_u32(b, o)
  let sign: i64 = (w >> 31) & 1
  let expo: i64 = (w >> 23) & 255
  if expo == 0 { return 0 }
  var mant: i64 = (w & A_MAGIC_8388607) | A_MAGIC_8388608
  let sh: i64 = expo - 127
  var v: i64 = 0
  if sh >= 23 { v = mant * scale * (1 << (sh - 23)) }
  if sh < 23 { v = (mant * scale) >> (23 - sh) }
  if sign == 1 { return 0 - v }
  return v
109}
110
111// walk capturing Models(+limb), AnimationCurveNodes, AnimationCurves(+KeyTime/KeyValueFloat
112// children), C connections WITH a property tag, and Properties70 P entries under Models
113// (PreRotation / Lcl Rotation / Lcl Translation defaults -- the FK inputs)
114func a_walk(b: *u8, flen: i64, off0: i64, big: i64, G: *i64, cctx: i64, mctx: i64) -> i64 {
  let off: i64 = off0
  var endo: i64 = 0
  var nprops: i64 = 0
  var plen: i64 = 0
  var nlen: i64 = 0
  var p: i64 = 0
  if big == 1 {
      endo = a_u64(b, off)
      nprops = a_u64(b, off + 8)
      plen = a_u64(b, off + 16)
      nlen = (b[off + 24] & 0xff) as i64
      p = off + 25
  }
  if big == 0 {
      endo = a_u32(b, off)
      nprops = a_u32(b, off + 4)
      plen = a_u32(b, off + 8)
      nlen = (b[off + 12] & 0xff) as i64
      p = off + 13
  }
  if endo == 0 { return off }
  if endo > flen { return flen }
  var kind: i64 = 0
  if nlen == 5 { if (b[p]&0xff)==77 { if (b[p+4]&0xff)==108 { kind = 1 } } }              // Model
  if nlen == 18 { if (b[p]&0xff)==65 { if (b[p+17]&0xff)==101 { kind = 2 } } }            // AnimationCurveNode
  if nlen == 14 { if (b[p]&0xff)==65 { if (b[p+13]&0xff)==101 { kind = 3 } } }            // AnimationCurve
  if nlen == 7 { if (b[p]&0xff)==75 { if (b[p+6]&0xff)==101 { kind = 4 } } }              // KeyTime
  if nlen == 13 { if (b[p]&0xff)==75 { if (b[p+12]&0xff)==116 { kind = 5 } } }            // KeyValueFloat
  if nlen == 1 { if (b[p]&0xff)==67 { kind = 6 } }                                        // C
  if nlen == 1 { if (b[p]&0xff)==80 { kind = 7 } }                                        // P (Properties70)
  p = p + nlen
  let pstart: i64 = p
  var id1: i64 = 0
  var id2: i64 = 0
  var lseen: i64 = 0
  var s1l: i64 = 0
  var s1o: i64 = 0
  var s2l: i64 = 0
  var s2o: i64 = 0
  var sseen: i64 = 0
  var arro: i64 = 0
  var arrl: i64 = 0
  var arre: i64 = 0
  var arrc: i64 = 0
  var dseen: i64 = 0
  var dv1: i64 = 0
  var dv2: i64 = 0
  var dv3: i64 = 0
  var pi: i64 = 0
  var stop: i64 = 0
  while pi < nprops {
      if stop == 0 {
          let t: i64 = (b[p] & 0xff) as i64
          p = p + 1
          var adv: i64 = 0 - 1
          if t == 83 {
              let l: i64 = a_u32(b, p)
              sseen = sseen + 1
              if sseen == 1 { s1o = p + 4; s1l = l }
              if sseen == 2 { s2o = p + 4; s2l = l }
              adv = 4 + l
          }
          if t == 82 { adv = 4 + a_u32(b, p) }
          if t == 89 { adv = 2 }
          if t == 67 { adv = 1 }
          if t == 73 { adv = 4 }
          if t == 70 { adv = 4 }
          if t == 68 {
              if dseen == 0 { dv1 = p }
              if dseen == 1 { dv2 = p }
              if dseen == 2 { dv3 = p }
              dseen = dseen + 1
              adv = 8
          }
          if t == 76 {
              lseen = lseen + 1
              if lseen == 1 { id1 = a_u64(b, p) }
              if lseen == 2 { id2 = a_u64(b, p) }
              adv = 8
          }
          var isarr: i64 = 0
          if t == 100 { isarr = 1 }
          if t == 102 { isarr = 2 }
          if t == 108 { isarr = 3 }
          if t == 105 { isarr = 3 }
          if t == 98 { isarr = 3 }
          if isarr > 0 {
              arrl = a_u32(b, p)
              arre = a_u32(b, p + 4)
              arrc = a_u32(b, p + 8)
              arro = p + 12
              adv = 12 + arrc
          }
          if adv < 0 { stop = 1 }
          if adv >= 0 { p = p + adv }
      }
      pi = pi + 1
  }
  var childc: i64 = cctx
  var childm: i64 = mctx
  if kind == 1 { if G[0] < A_MAGIC_4090 {
      G[A_MO + G[0]] = id1
      var lf: i64 = 0
      if s2l == 8 { if (b[s2o]&0xff)==76 { if (b[s2o+7]&0xff)==101 { lf = 1 } } }
      G[A_LO + G[0]] = lf
      G[A_NO + G[0]] = s1o
      G[A_NL + G[0]] = s1l
      childm = G[0]
      G[0] = G[0] + 1
  } }
  if kind == 2 { if G[3] < A_MAGIC_2040 { G[A_AN + G[3]] = id1; G[3] = G[3] + 1 } }
  if kind == 3 { if G[1] < A_MAGIC_2040 {
      G[A_CID + G[1]] = id1
      childc = G[1]
      G[1] = G[1] + 1
  } }
  if kind == 4 { if cctx >= 0 {
      G[A_CKT + cctx*4] = arro
      G[A_CKT + cctx*4 + 1] = arrl
      G[A_CKT + cctx*4 + 2] = arre
      G[A_CKT + cctx*4 + 3] = arrc
  } }
  if kind == 5 { if cctx >= 0 {
      G[A_CKV + cctx*4] = arro
      G[A_CKV + cctx*4 + 1] = arrl
      G[A_CKV + cctx*4 + 2] = arre
      G[A_CKV + cctx*4 + 3] = arrc
  } }
  if kind == 6 { if G[2] < A_MAGIC_119990 {
      var ptag: i64 = 0
      if s2l > 0 { ptag = s2l*256 + ((b[s2o + s2l - 1] & 0xff) as i64) }
      G[A_CONN + G[2]*3] = id1
      G[A_CONN + G[2]*3 + 1] = id2
      G[A_CONN + G[2]*3 + 2] = ptag
      G[2] = G[2] + 1
  } }
  // Properties70 P entry under a Model: name = FIRST S prop; vector value = 3 D props.
  // Matched by (len, first, last): PreRotation(11 P..n), Lcl Rotation(12 L..n),
  // Lcl Translation(15 L..n). Angles degrees->millideg, translation units x1000 (both x1000).
  if kind == 7 { if mctx >= 0 { if dseen >= 3 {
      var pk: i64 = 0
      if s1l == 11 { if (b[s1o]&0xff)==80 { if (b[s1o+10]&0xff)==110 { pk = 1 } } }
      if s1l == 12 { if (b[s1o]&0xff)==76 { if (b[s1o+11]&0xff)==110 { pk = 2 } } }
      if s1l == 15 { if (b[s1o]&0xff)==76 { if (b[s1o+14]&0xff)==110 { pk = 3 } } }
      if pk == 1 {
          G[A_PR + mctx*3] = a_f64(b, dv1, 1000)
          G[A_PR + mctx*3 + 1] = a_f64(b, dv2, 1000)
          G[A_PR + mctx*3 + 2] = a_f64(b, dv3, 1000)
          G[A_PF + mctx] = G[A_PF + mctx] | 1
      }
      if pk == 2 {
          G[A_LR + mctx*3] = a_f64(b, dv1, 1000)
          G[A_LR + mctx*3 + 1] = a_f64(b, dv2, 1000)
          G[A_LR + mctx*3 + 2] = a_f64(b, dv3, 1000)
          G[A_PF + mctx] = G[A_PF + mctx] | 2
      }
      if pk == 3 {
          G[A_LT + mctx*3] = a_f64(b, dv1, 1000)
          G[A_LT + mctx*3 + 1] = a_f64(b, dv2, 1000)
          G[A_LT + mctx*3 + 2] = a_f64(b, dv3, 1000)
          G[A_PF + mctx] = G[A_PF + mctx] | 4
      }
  } } }
  p = pstart + plen
  var sent: i64 = 13
  if big == 1 { sent = 25 }
  while p < endo - sent {
      p = a_walk(b, flen, p, big, G, childc, childm)
      if p >= flen { return flen }
  }
  return endo
286}
287
288func a_arr(b: *u8, off: i64, alen: i64, enc: i64, clen: i64, esz: i64) -> *u8 {
  if enc == 0 { return ((b as i64) + off) as *u8 }
  let zr: *NxZlibResult = nx_zlib_inflate(((b as i64) + off) as *u8, clen, alen*esz + A_MAGIC_4096)
  if zr.error_code != 0 { return 0 as *u8 }
  return zr.output_data
293}
294// sample curve (KeyTime l-array ticks, KeyValueFloat f-array) at t_ms -> value x1000
295func a_sample(kt: *u8, kv: *u8, nk: i64, tms: i64) -> i64 {
  if nk < 1 { return 0 }
  let t0: i64 = a_u64(kt, 0) / A_MAGIC_46186158
  if tms <= t0 { return a_f32(kv, 0, 1000) }
  let tl: i64 = a_u64(kt, (nk-1)*8) / A_MAGIC_46186158
  if tms >= tl { return a_f32(kv, (nk-1)*4, 1000) }
  var i: i64 = 1
  while i < nk {
      let ti: i64 = a_u64(kt, i*8) / A_MAGIC_46186158
      if ti >= tms {
          let tp: i64 = a_u64(kt, (i-1)*8) / A_MAGIC_46186158
          let vp: i64 = a_f32(kv, (i-1)*4, 1000)
          let vi: i64 = a_f32(kv, i*4, 1000)
          if ti == tp { return vi }
          return vp + (vi - vp)*(tms - tp)/(ti - tp)
      }
      i = i + 1
  }
  return a_f32(kv, (nk-1)*4, 1000)
314}
315// angular variant: SHORTEST-PATH lerp (mocap Euler channels cross the +-180deg seam;
316// a plain value lerp swings through the wrong side = frame-local limb shards, measured
317// on forearm-twist/shoulder channels of the CC walk)
318func a_sample_ang(kt: *u8, kv: *u8, nk: i64, tms: i64) -> i64 {
  if nk < 1 { return 0 }
  let t0: i64 = a_u64(kt, 0) / A_MAGIC_46186158
  if tms <= t0 { return a_f32(kv, 0, 1000) }
  let tl: i64 = a_u64(kt, (nk-1)*8) / A_MAGIC_46186158
  if tms >= tl { return a_f32(kv, (nk-1)*4, 1000) }
  var i: i64 = 1
  while i < nk {
      let ti: i64 = a_u64(kt, i*8) / A_MAGIC_46186158
      if ti >= tms {
          let tp: i64 = a_u64(kt, (i-1)*8) / A_MAGIC_46186158
          let vp: i64 = a_f32(kv, (i-1)*4, 1000)
          let vi: i64 = a_f32(kv, i*4, 1000)
          if ti == tp { return vi }
          var dv: i64 = vi - vp
          while dv > A_MAGIC_180000 { dv = dv - A_MAGIC_360000 }
          while dv < 0 - A_MAGIC_180000 { dv = dv + A_MAGIC_360000 }
          return vp + dv*(tms - tp)/(ti - tp)
      }
      i = i + 1
  }
  return a_f32(kv, (nk-1)*4, 1000)
340}
341// quat/FK primitives live in nx_nxa_fk.nx (nf_*), shared with nx_nxa_skin (DRY rule-15)
342
343// print a Model name ("Name\x00\x01Class" form -- stop at the 0x00) for diagnostics
344func a_wname(b: *u8, off: i64, len: i64) -> i64 {
  var n: i64 = 0
  while n < len {
      if (b[off+n] & 0xff) == 0 { len = n }
      if n < len { n = n + 1 }
  }
  if n > 48 { n = 48 }
  sys_write(1, ((b as i64) + off) as *u8, n)
  return 0
353}
354
355// does a Model name contain the ASCII pattern? (foot/toe identification for heel-walk
356// flattening -- names exist in the FBX even though SKEL stays nameless by design)
357func a_namehas(b: *u8, off: i64, len: i64, pat: *u8) -> i64 {
  var pl: i64 = 0
  while pat[pl] != (0 as u8) { pl = pl + 1 }
  if pl == 0 { return 0 }
  var i: i64 = 0
  while i + pl <= len {
      var k: i64 = 0
      var hit: i64 = 1
      while k < pl {
          if (b[off+i+k] & 0xff) != (pat[k] & 0xff) { hit = 0; k = pl }
          k = k + 1
      }
      if hit == 1 { return 1 }
      i = i + 1
  }
  return 0
373}
374
375// Explicit selected-stack loading. This qualifies channel identity, not affine evaluation or playback.
376const A_LAYER_BLEND_UNSUPPORTED:i64=0-44
377func a_selected_layers(selection:*FbxClipSelection)->i64 {
if selection.layers!=1{return A_LAYER_BLEND_UNSUPPORTED}
return 0
380}
381func a_load_selected(fb:*u8,flen:i64,stack_id:i64,G:*i64,graph:*FbxClipGraph,selection:*FbxClipSelection)->i64 {
if G[0]!=0||G[1]!=0||G[2]!=0||G[3]!=0{return FC_BAD}
let loaded:i64=fc_load(fb,flen,graph);if loaded!=0{return loaded}
let selected:i64=fc_select(graph,stack_id,A_MAGIC_2040,A_MAGIC_2040,selection);if selected!=0{return selected}
let layer_contract:i64=a_selected_layers(selection);if layer_contract!=0{return layer_contract}
let big:i64=fbxc_big(fbxc_version(fb,flen))
var i:i64=0
while i<graph.count{
let o:*FbxClipObject=fc_object(graph,i)
var include:i64=0
if o.kind==FC_MODEL{include=1;if G[0]>=A_MAGIC_4090{return FC_CAPACITY}}
if o.selected==1{if o.kind==FC_NODE||o.kind==FC_CURVE{include=1}}
if include==1{a_walk(fb,flen,o.offset,big,G,0-1,0-1)}
i=i+1
}
i=0
while i<graph.link_count{
let l:*FbxClipLink=fc_link(graph,i)
let src:i64=fc_find(graph,l.src);let dst:i64=fc_find(graph,l.dst)
if src==FC_AMBIGUOUS||dst==FC_AMBIGUOUS{return FC_AMBIGUOUS}
var include:i64=0
if src>=0&&dst>=0{
 let a:*FbxClipObject=fc_object(graph,src);let b:*FbxClipObject=fc_object(graph,dst)
 if a.kind==FC_MODEL&&b.kind==FC_MODEL{include=1}
 if a.selected==1&&b.selected==1{include=1}
 if a.kind==FC_NODE&&a.selected==1&&b.kind==FC_MODEL{include=1}
}
if include==1{if G[2]>=A_MAGIC_119990{return FC_CAPACITY};a_walk(fb,flen,l.offset,big,G,0-1,0-1)}
i=i+1
}
if G[1]!=selection.curves||G[3]!=selection.nodes{return FC_BAD}
return 0
413}
414func main(argc: i64, argv: *i64) -> i64 {
  if argc < 4 { aw("usage: nx_nxa_anim <in.fbx> <in.nxa5> <out.nxa> [--heels]\n" as *u8); return 2 }
  let lpf: *i64 = sys_mmap(16) as *i64
  let fb: *u8 = sys_map_file(argv[1] as *u8, lpf)
  let flen: i64 = lpf[0]
  if flen < 64 { aw("fbx unreadable\n" as *u8); return 3 }
  let ver: i64 = a_u32(fb, 23)
  var big: i64 = 0
  if ver >= A_MAGIC_7500 { big = 1 }
  let G: *i64 = sys_mmap(A_WORDS*8) as *i64
  var pos: i64 = 27
  var guard: i64 = 0
  while pos < flen - 200 {
      if guard > A_MAGIC_500000 { break }
      let e: i64 = a_walk(fb, flen, pos, big, G, 0 - 1, 0 - 1)
      if e <= pos { break }
      pos = e
      guard = guard + 1
  }
  aw("models=" as *u8); an(G[0])
  aw(" curves=" as *u8); an(G[1])
  aw(" curvenodes=" as *u8); an(G[3])
  aw(" conns=" as *u8); an(G[2]); aw("\n" as *u8)
  // joint indices EXACTLY as nx_nxa_skin assigns them (limb models in encounter order)
  let mc: i64 = G[0]
  let jmap: *i64 = sys_mmap(mc*8 + 64) as *i64
  let jmi: *i64 = sys_mmap(A_MAGIC_4096*8 + 64) as *i64
  var nj: i64 = 0
  var m0: i64 = 0
  while m0 < mc {
      jmap[m0] = 0 - 1
      if G[A_LO + m0] == 1 { jmap[m0] = nj; jmi[nj] = m0; nj = nj + 1 }
      m0 = m0 + 1
  }
  // parent per joint via Connections (child model -> parent model), skin-identical
  let jpar: *i64 = sys_mmap(nj*8 + 64) as *i64
  var j0: i64 = 0
  while j0 < nj { jpar[j0] = 0 - 1; j0 = j0 + 1 }
  let nc: i64 = G[2]
  var m1: i64 = 0
  while m1 < mc {
      if jmap[m1] >= 0 {
          let myid: i64 = G[A_MO + m1]
          var k: i64 = 0
          while k < nc {
              if G[A_CONN + k*3] == myid {
                  let dst: i64 = G[A_CONN + k*3 + 1]
                  var m2: i64 = 0
                  while m2 < mc {
                      if G[A_MO + m2] == dst { if jmap[m2] >= 0 {
                          jpar[jmap[m1]] = jmap[m2]
                          m2 = mc
                          k = nc
                      } }
                      m2 = m2 + 1
                  }
              }
              k = k + 1
          }
      }
      m1 = m1 + 1
  }
  // model-parent map over ALL models: armature/figure nodes ABOVE the root joints carry
  // the y-up->z-up conversion that TransformLink binds already include -- FK must chain
  // through them or every world position comes out axis-swapped (measured 1.01m divergence)
  let mpar: *i64 = sys_mmap(mc*8 + 64) as *i64
  var mp0: i64 = 0
  while mp0 < mc { mpar[mp0] = 0 - 1; mp0 = mp0 + 1 }
  var mp1: i64 = 0
  while mp1 < mc {
      let myid2: i64 = G[A_MO + mp1]
      var kp: i64 = 0
      while kp < nc {
          if G[A_CONN + kp*3] == myid2 {
              let dstp: i64 = G[A_CONN + kp*3 + 1]
              var mp2: i64 = 0
              while mp2 < mc {
                  if G[A_MO + mp2] == dstp { mpar[mp1] = mp2; mp2 = mc; kp = nc }
                  mp2 = mp2 + 1
              }
          }
          kp = kp + 1
      }
      mp1 = mp1 + 1
  }
  // per joint: rotation curves (ptag "Lcl Rotation" 12*256+110) and translation curves
  // (ptag "Lcl Translation" 15*256+110), each X/Y/Z via curve->node ptag 856/857/858
  let jrx: *i64 = sys_mmap(nj*8 + 64) as *i64
  let jry: *i64 = sys_mmap(nj*8 + 64) as *i64
  let jrz: *i64 = sys_mmap(nj*8 + 64) as *i64
  let jtx: *i64 = sys_mmap(nj*8 + 64) as *i64
  let jty: *i64 = sys_mmap(nj*8 + 64) as *i64
  let jtz: *i64 = sys_mmap(nj*8 + 64) as *i64
  var j1: i64 = 0
  while j1 < nj {
      jrx[j1] = 0 - 1
      jry[j1] = 0 - 1
      jrz[j1] = 0 - 1
      jtx[j1] = 0 - 1
      jty[j1] = 0 - 1
      jtz[j1] = 0 - 1
      j1 = j1 + 1
  }
  var rtracks: i64 = 0
  var ttracks: i64 = 0
  var maxms: i64 = 0
  var m3: i64 = 0
  while m3 < mc {
      if jmap[m3] >= 0 {
          let mid: i64 = G[A_MO + m3]
          var k1: i64 = 0
          while k1 < nc {
              if G[A_CONN + k1*3 + 1] == mid {
                  let ptag0: i64 = G[A_CONN + k1*3 + 2]
                  var chan: i64 = 0 - 1
                  if ptag0 == 12*256 + 110 { chan = 1 }
                  if ptag0 == 15*256 + 110 { chan = 0 }
                  if chan >= 0 {
                      let nid: i64 = G[A_CONN + k1*3]
                      var isn: i64 = 0
                      var q: i64 = 0
                      while q < G[3] { if G[A_AN + q] == nid { isn = 1; q = G[3] } q = q + 1 }
                      if isn == 1 {
                          var k2: i64 = 0
                          while k2 < nc {
                              if G[A_CONN + k2*3 + 1] == nid {
                                  let cid2: i64 = G[A_CONN + k2*3]
                                  let pt: i64 = G[A_CONN + k2*3 + 2]
                                  var ci: i64 = 0 - 1
                                  var q2: i64 = 0
                                  while q2 < G[1] { if G[A_CID + q2] == cid2 { ci = q2; q2 = G[1] } q2 = q2 + 1 }
                                  if ci >= 0 {
                                      let jj: i64 = jmap[m3]
                                      if chan == 1 {
                                          if pt == 3*256 + 88 { jrx[jj] = ci }
                                          if pt == 3*256 + 89 { jry[jj] = ci }
                                          if pt == 3*256 + 90 { jrz[jj] = ci }
                                      }
                                      if chan == 0 {
                                          if pt == 3*256 + 88 { jtx[jj] = ci }
                                          if pt == 3*256 + 89 { jty[jj] = ci }
                                          if pt == 3*256 + 90 { jtz[jj] = ci }
                                      }
                                      let nk2: i64 = G[A_CKT + ci*4 + 1]
                                      if nk2 > 0 {
                                          let kta: *u8 = a_arr(fb, G[A_CKT + ci*4], nk2, G[A_CKT + ci*4 + 2], G[A_CKT + ci*4 + 3], 8)
                                          if (kta as i64) != 0 {
                                              let em: i64 = a_u64(kta, (nk2-1)*8) / A_MAGIC_46186158
                                              if em > maxms { maxms = em }
                                          }
                                      }
                                  }
                              }
                              k2 = k2 + 1
                          }
                      }
                  }
              }
              k1 = k1 + 1
          }
      }
      m3 = m3 + 1
  }
  var jt: i64 = 0
  while jt < nj {
      if jrx[jt] >= 0 { rtracks = rtracks + 1 }
      if jtx[jt] >= 0 { ttracks = ttracks + 1 }
      jt = jt + 1
  }
  var pre_n: i64 = 0
  var lr_n: i64 = 0
  var lt_n: i64 = 0
  var jc0: i64 = 0
  while jc0 < nj {
      let f: i64 = G[A_PF + jmi[jc0]]
      if (f & 1) == 1 { pre_n = pre_n + 1 }
      if (f & 2) == 2 { lr_n = lr_n + 1 }
      if (f & 4) == 4 { lt_n = lt_n + 1 }
      jc0 = jc0 + 1
  }
  aw("joints=" as *u8); an(nj)
  aw(" rot_tracks=" as *u8); an(rtracks)
  aw(" trans_tracks=" as *u8); an(ttracks)
  aw(" prerot_joints=" as *u8); an(pre_n)
  aw(" lclrot_joints=" as *u8); an(lr_n)
  aw(" lclt_joints=" as *u8); an(lt_n)
  aw(" duration_ms=" as *u8); an(maxms); aw("\n" as *u8)
  if rtracks == 0 { aw("no animation found\n" as *u8); return 4 }
  if maxms < 33 { maxms = 33 }
  if maxms > A_MAGIC_60000 { maxms = A_MAGIC_60000 }
  // in.nxa5 SKEL = ground truth rig (TransformLink binds); joint count MUST match
  let lpn: *i64 = sys_mmap(16) as *i64
  let nb: *u8 = sys_map_file(argv[2] as *u8, lpn)
  let nlen2: i64 = lpn[0]
  let nh: *i64 = nb as *i64
  if nh[0] != nxa_magic() { aw("in.nxa bad\n" as *u8); return 5 }
  let swo: i64 = nxa_find(nb, nlen2, nxa_tag4("SKEL" as *u8))
  if swo < 0 { aw("in.nxa has no SKEL\n" as *u8); return 5 }
  let njs: i64 = nh[swo]
  if njs != nj { aw("RIG-MISMATCH skel joints=" as *u8); an(njs); aw(" fbx joints=" as *u8); an(nj); aw("\n" as *u8); return 7 }
  let skb: *i64 = ((nb as i64) + swo*8 + 8) as *i64
  var pmm: i64 = 0
  var jc1: i64 = 0
  while jc1 < nj {
      if skb[jc1*8] != jpar[jc1] { pmm = pmm + 1 }
      jc1 = jc1 + 1
  }
  // per-joint constant local quats: pq = PreRotation, sq = static Lcl Rotation
  let scr: *i64 = sys_mmap(256) as *i64
  let pq: *i64 = sys_mmap(nj*32 + 64) as *i64
  let sq: *i64 = sys_mmap(nj*32 + 64) as *i64
  var jc2: i64 = 0
  while jc2 < nj {
      let mi: i64 = jmi[jc2]
      nf_eul2q(G[A_PR + mi*3], G[A_PR + mi*3 + 1], G[A_PR + mi*3 + 2], ((pq as i64) + jc2*32) as *i64, scr)
      nf_eul2q(G[A_LR + mi*3], G[A_LR + mi*3 + 1], G[A_LR + mi*3 + 2], ((sq as i64) + jc2*32) as *i64, scr)
      jc2 = jc2 + 1
  }
  // topological order (parents first; FBX order is usually already topo but never assume)
  let topo: *i64 = sys_mmap(nj*8 + 64) as *i64
  let done: *i64 = sys_mmap(nj*8 + 64) as *i64
  var tn: i64 = 0
  var pass: i64 = 0
  while pass < nj {
      if tn < nj {
          var jp0: i64 = 0
          while jp0 < nj {
              if done[jp0] == 0 {
                  var ok: i64 = 0
                  if jpar[jp0] < 0 { ok = 1 }
                  if jpar[jp0] >= 0 { if done[jpar[jp0]] == 1 { ok = 1 } }
                  if ok == 1 { topo[tn] = jp0; tn = tn + 1; done[jp0] = 1 }
              }
              jp0 = jp0 + 1
          }
      }
      pass = pass + 1
  }
  if tn != nj { aw("RIG-MISMATCH parent cycle\n" as *u8); return 7 }
  // STATIC FK = the reference/bind pose this bake is relative to. VALIDATE it against the
  // SKEL bind translations before trusting any delta out of it.
  let gqs: *i64 = sys_mmap(nj*32 + 64) as *i64
  let gts: *i64 = sys_mmap(nj*24 + 64) as *i64
  let lq: *i64 = sys_mmap(64) as *i64
  let rv: *i64 = sys_mmap(64) as *i64
  // per-root PREFIX transform = the composed non-limb ancestor chain (armature nodes),
  // folded top-down; identity for non-root joints. Applied in BOTH static and anim FK.
  let prefq: *i64 = sys_mmap(nj*32 + 64) as *i64
  let preft: *i64 = sys_mmap(nj*24 + 64) as *i64
  let anc: *i64 = sys_mmap(32*8 + 64) as *i64
  let aqq: *i64 = sys_mmap(64) as *i64
  let bqq: *i64 = sys_mmap(64) as *i64
  let tq2: *i64 = sys_mmap(64) as *i64
  var jr0: i64 = 0
  while jr0 < nj {
      prefq[jr0*4] = 0
      prefq[jr0*4+1] = 0
      prefq[jr0*4+2] = 0
      prefq[jr0*4+3] = A_MAGIC_4096
      if jpar[jr0] < 0 {
          var nanc: i64 = 0
          var cm: i64 = mpar[jmi[jr0]]
          var hops: i64 = 0
          while cm >= 0 {
              if nanc < 30 { anc[nanc] = cm; nanc = nanc + 1 }
              cm = mpar[cm]
              hops = hops + 1
              if hops > 30 { cm = 0 - 1 }
          }
          var pi2: i64 = nanc - 1
          while pi2 >= 0 {
              let am: i64 = anc[pi2]
              nf_eul2q(G[A_PR + am*3], G[A_PR + am*3 + 1], G[A_PR + am*3 + 2], aqq, scr)
              nf_eul2q(G[A_LR + am*3], G[A_LR + am*3 + 1], G[A_LR + am*3 + 2], bqq, scr)
              nf_qmul(aqq, bqq, tq2)
              nf_qnorm(tq2)
              nf_qrotv(((prefq as i64) + jr0*32) as *i64, G[A_LT + am*3], G[A_LT + am*3 + 1], G[A_LT + am*3 + 2], rv, scr)
              preft[jr0*3] = preft[jr0*3] + rv[0]
              preft[jr0*3+1] = preft[jr0*3+1] + rv[1]
              preft[jr0*3+2] = preft[jr0*3+2] + rv[2]
              nf_qmul(((prefq as i64) + jr0*32) as *i64, tq2, aqq)
              nf_qnorm(aqq)
              prefq[jr0*4] = aqq[0]
              prefq[jr0*4+1] = aqq[1]
              prefq[jr0*4+2] = aqq[2]
              prefq[jr0*4+3] = aqq[3]
              pi2 = pi2 - 1
          }
      }
      jr0 = jr0 + 1
  }
  var ti0: i64 = 0
  while ti0 < nj {
      let j: i64 = topo[ti0]
      let mi2: i64 = jmi[j]
      nf_qmul(((pq as i64) + j*32) as *i64, ((sq as i64) + j*32) as *i64, lq)
      nf_qnorm(lq)
      let pj: i64 = jpar[j]
      if pj < 0 {
          nf_qmul(((prefq as i64) + j*32) as *i64, lq, ((gqs as i64) + j*32) as *i64)
          nf_qnorm(((gqs as i64) + j*32) as *i64)
          nf_qrotv(((prefq as i64) + j*32) as *i64, G[A_LT + mi2*3], G[A_LT + mi2*3 + 1], G[A_LT + mi2*3 + 2], rv, scr)
          gts[j*3] = preft[j*3] + rv[0]
          gts[j*3+1] = preft[j*3+1] + rv[1]
          gts[j*3+2] = preft[j*3+2] + rv[2]
      }
      if pj >= 0 {
          nf_qmul(((gqs as i64) + pj*32) as *i64, lq, ((gqs as i64) + j*32) as *i64)
          nf_qnorm(((gqs as i64) + j*32) as *i64)
          nf_qrotv(((gqs as i64) + pj*32) as *i64, G[A_LT + mi2*3], G[A_LT + mi2*3 + 1], G[A_LT + mi2*3 + 2], rv, scr)
          gts[j*3] = gts[pj*3] + rv[0]
          gts[j*3+1] = gts[pj*3+1] + rv[1]
          gts[j*3+2] = gts[pj*3+2] + rv[2]
      }
      ti0 = ti0 + 1
  }
  // validate ONLY joints with REAL cluster binds: nx_nxa_skin propagates a parent's bind
  // into unclustered joints (zero-length placeholder bones), so a placeholder equals its
  // parent's bind exactly (or is 0,0,0) -- comparing FK truth against those is meaningless
  // (measured: J4 fk=hip@1010mm vs placeholder bind 0,0,0 -- the FK was right all along).
  var maxerr: i64 = 0
  var maxerrj: i64 = 0 - 1
  var vbinds: i64 = 0
  var jc3: i64 = 0
  while jc3 < nj {
      var real: i64 = 1
      if skb[jc3*8+1] == 0 { if skb[jc3*8+2] == 0 { if skb[jc3*8+3] == 0 { real = 0 } } }
      let pjv: i64 = skb[jc3*8]
      if pjv >= 0 {
          if skb[jc3*8+1] == skb[pjv*8+1] { if skb[jc3*8+2] == skb[pjv*8+2] { if skb[jc3*8+3] == skb[pjv*8+3] { real = 0 } } }
      }
      if real == 1 {
          vbinds = vbinds + 1
          var a0: i64 = 0
          while a0 < 3 {
              var d: i64 = gts[jc3*3+a0] - skb[jc3*8 + 1 + a0]
              if d < 0 { d = 0 - d }
              if d > maxerr { maxerr = d; maxerrj = jc3 }
              a0 = a0 + 1
          }
      }
      jc3 = jc3 + 1
  }
  var jdbg: i64 = 0
  while jdbg < 8 {
      aw("J" as *u8); an(jdbg)
      aw(" fk=" as *u8); an(gts[jdbg*3]); aw("," as *u8); an(gts[jdbg*3+1]); aw("," as *u8); an(gts[jdbg*3+2])
      aw(" bind=" as *u8); an(skb[jdbg*8+1]); aw("," as *u8); an(skb[jdbg*8+2]); aw("," as *u8); an(skb[jdbg*8+3])
      aw(" par=" as *u8); an(jpar[jdbg]); aw("\n" as *u8)
      jdbg = jdbg + 1
  }
  aw("parent_mismatch=" as *u8); an(pmm)
  aw(" validated_binds=" as *u8); an(vbinds)
  aw(" static_maxerr_units=" as *u8); an(maxerr)
  aw(" at_joint=" as *u8); an(maxerrj); aw("\n" as *u8)
  if vbinds < 8 { aw("TOO-FEW-REAL-BINDS to validate FK -- refusing to bake\n" as *u8); return 7 }
  if maxerr > A_MAGIC_20000 { aw("STATIC-FK-DIVERGES from SKEL binds -- refusing to bake\n" as *u8); return 7 }
  // pre-inflate every rig-connected curve ONCE (inflating inside the 545x104 bake loop
  // would decompress the same arrays ~340k times); 6 channels per joint: rx ry rz tx ty tz
  let cidx: *i64 = sys_mmap(nj*48 + 64) as *i64
  let cptr: *i64 = sys_mmap(nj*96 + 64) as *i64
  let cnk: *i64 = sys_mmap(nj*48 + 64) as *i64
  var wrapn: i64 = 0
  var jc4: i64 = 0
  while jc4 < nj {
      cidx[jc4*6] = jrx[jc4]
      cidx[jc4*6+1] = jry[jc4]
      cidx[jc4*6+2] = jrz[jc4]
      cidx[jc4*6+3] = jtx[jc4]
      cidx[jc4*6+4] = jty[jc4]
      cidx[jc4*6+5] = jtz[jc4]
      var ch: i64 = 0
      while ch < 6 {
          let ci: i64 = cidx[jc4*6+ch]
          if ci >= 0 { if G[A_CKT + ci*4 + 1] > 0 { if G[A_CKT + ci*4 + 1] == G[A_CKV + ci*4 + 1] {
              let kta: *u8 = a_arr(fb, G[A_CKT + ci*4], G[A_CKT + ci*4 + 1], G[A_CKT + ci*4 + 2], G[A_CKT + ci*4 + 3], 8)
              let kva: *u8 = a_arr(fb, G[A_CKV + ci*4], G[A_CKV + ci*4 + 1], G[A_CKV + ci*4 + 2], G[A_CKV + ci*4 + 3], 4)
              if (kta as i64) != 0 { if (kva as i64) != 0 {
                  cptr[jc4*12 + ch*2] = kta as i64
                  cptr[jc4*12 + ch*2 + 1] = kva as i64
                  cnk[jc4*6 + ch] = G[A_CKT + ci*4 + 1]
                  if ch < 3 {
                      var kw: i64 = 0
                      while kw < G[A_CKT + ci*4 + 1] - 1 {
                          var dvv: i64 = a_f32(kva, (kw+1)*4, 1000) - a_f32(kva, kw*4, 1000)
                          if dvv < 0 { dvv = 0 - dvv }
                          if dvv > A_MAGIC_180000 { wrapn = wrapn + 1 }
                          kw = kw + 1
                      }
                  }
              } }
          } } }
          ch = ch + 1
      }
      jc4 = jc4 + 1
  }
  // FLAT-FEET (default; --heels keeps the authored tip-toe as a chosen behavior): the
  // walk mocap is heels-authored -- feet plantarflexed the whole clip. Re-center each
  // foot/toe joint's rotation curves around its STATIC pose (offset = channel mean minus
  // static default, data-driven, no magic angle) so the foot oscillates about neutral =
  // flat-ground walk; toe-off dynamics survive because only the MEAN shifts.
  let foff: *i64 = sys_mmap(nj*24 + 64) as *i64
  var heels: i64 = 0
  if argc >= 5 {
      let fav: *u8 = argv[4] as *u8
      if fav[2] == (104 as u8) { heels = 1 }
  }
  var nflat: i64 = 0
  var maxfo: i64 = 0
  if heels == 0 {
      var fj0: i64 = 0
      while fj0 < nj {
          let no: i64 = G[A_NO + jmi[fj0]]
          let nl: i64 = G[A_NL + jmi[fj0]]
          var isf: i64 = a_namehas(fb, no, nl, "_Foot" as *u8)
          if isf == 0 { isf = a_namehas(fb, no, nl, "Toe" as *u8) }
          if isf == 1 {
              nflat = nflat + 1
              var ch2: i64 = 0
              while ch2 < 3 {
                  let nk3: i64 = cnk[fj0*6 + ch2]
                  if nk3 > 1 {
                      let kva2: *u8 = cptr[fj0*12 + ch2*2 + 1] as *u8
                      var sum2: i64 = 0
                      var k3: i64 = 0
                      while k3 < nk3 { sum2 = sum2 + a_f32(kva2, k3*4, 1000); k3 = k3 + 1 }
                      foff[fj0*3 + ch2] = sum2/nk3 - G[A_LR + jmi[fj0]*3 + ch2]
                      var af0: i64 = foff[fj0*3 + ch2]
                      if af0 < 0 { af0 = 0 - af0 }
                      if af0 > maxfo { maxfo = af0 }
                  }
                  ch2 = ch2 + 1
              }
          }
          fj0 = fj0 + 1
      }
  }
  aw("flatfeet_joints=" as *u8); an(nflat)
  aw(" max_offset_mdeg=" as *u8); an(maxfo)
  aw(" heels=" as *u8); an(heels); aw("\n" as *u8)
  // per-joint curve motion range in millideg: exposes helper/duplicate joints whose
  // exported curves are FLAT (constraint-driven in-engine, not baked by the exporter)
  let rr: *i64 = sys_mmap(nj*8 + 64) as *i64
  var jd0: i64 = 0
  while jd0 < nj {
      var rrj: i64 = 0
      var ch9: i64 = 0
      while ch9 < 3 {
          let nk9: i64 = cnk[jd0*6+ch9]
          if nk9 > 1 {
              let kv9: *u8 = cptr[jd0*12+ch9*2+1] as *u8
              var vmin: i64 = A_MAGIC_4611686018427387903
              var vmax: i64 = 0 - A_MAGIC_4611686018427387903
              var k9: i64 = 0
              while k9 < nk9 {
                  let vv9: i64 = a_f32(kv9, k9*4, 1000)
                  if vv9 < vmin { vmin = vv9 }
                  if vv9 > vmax { vmax = vv9 }
                  k9 = k9 + 1
              }
              if vmax - vmin > rrj { rrj = vmax - vmin }
          }
          ch9 = ch9 + 1
      }
      rr[jd0] = rrj
      jd0 = jd0 + 1
  }
  // DEAD CHAINS (whole ancestor path flat, e.g. the duplicate pelvis chain the mocap does
  // not target -- measured: J5 w=1.3M range=0 beside thighs swinging 250deg): their flesh
  // would freeze at bind while the living skeleton walks away. ADOPT the exact world
  // transform of the nearest curve-moving joint by bind distance (flesh follows SPACE --
  // the proven region law, made per-file-exact at bake). Flat joints under a MOVING parent
  // (twist helpers) are left alone: FK already carries their parents into them.
  let flatj: *i64 = sys_mmap(nj*8 + 64) as *i64
  let deadj: *i64 = sys_mmap(nj*8 + 64) as *i64
  let donor: *i64 = sys_mmap(nj*8 + 64) as *i64
  var jf0: i64 = 0
  while jf0 < nj {
      flatj[jf0] = 0
      if rr[jf0] < A_MAGIC_2000 { flatj[jf0] = 1 }
      jf0 = jf0 + 1
  }
  var td0: i64 = 0
  while td0 < nj {
      let j8: i64 = topo[td0]
      deadj[j8] = 0
      if flatj[j8] == 1 {
          let pj8: i64 = jpar[j8]
          if pj8 < 0 { deadj[j8] = 1 }
          if pj8 >= 0 { if deadj[pj8] == 1 { deadj[j8] = 1 } }
      }
      td0 = td0 + 1
  }
  // ADOPTION SET v2 (measured escalation): dead chains PLUS living flat joints that CARRY
  // real flesh (constraint-driven twist/share helpers, e.g. the scapula chain w=759k rigid
  // under a 31deg-swinging upperarm while four sibling chains rotate -- the last shard
  // source). Nearest-moving-bone adoption minimizes flesh seams by construction.
  let kwo2: i64 = nxa_find(nb, nlen2, nxa_tag4("SKIN" as *u8))
  let wmass: *i64 = sys_mmap(nj*8 + 64) as *i64
  if kwo2 >= 0 {
      let skn2: *i64 = ((nb as i64) + kwo2*8 + 8) as *i64
      let nvv: i64 = nh[kwo2]
      var v9: i64 = 0
      while v9 < nvv {
          var s9: i64 = 0
          while s9 < 4 {
              let jw: i64 = skn2[v9*8+s9]
              if jw >= 0 { if jw < nj { wmass[jw] = wmass[jw] + skn2[v9*8+4+s9] } }
              s9 = s9 + 1
          }
          v9 = v9 + 1
      }
  }
  // MEASURED ROLLBACK: adopting LIVING flat helpers by nearest-mover picked finger bones
  // as donors for hand helpers (new spikes) and did not close the scapula seam -- living
  // twist chains need a real twist-share model (fraction-of-parent roll), filed as debt.
  // Adoption stays DEAD-CHAIN-ONLY, the measured clear win (duplicate pelvis, w=1.3M).
  let adoptj: *i64 = sys_mmap(nj*8 + 64) as *i64
  var ja0: i64 = 0
  while ja0 < nj {
      adoptj[ja0] = 0
      if deadj[ja0] == 1 { adoptj[ja0] = 1 }
      ja0 = ja0 + 1
  }
  var jn0: i64 = 0
  while jn0 < nj {
      var show: i64 = 0
      if wmass[jn0] > A_MAGIC_200000 { show = 1 }
      if adoptj[jn0] == 1 { show = 1 }
      if show == 1 {
          aw("JN " as *u8); an(jn0)
          aw(" par=" as *u8); an(jpar[jn0])
          aw(" w=" as *u8); an(wmass[jn0])
          aw(" rr=" as *u8); an(rr[jn0])
          aw(" adopt=" as *u8); an(adoptj[jn0])
          aw(" " as *u8)
          a_wname(fb, G[A_NO + jmi[jn0]], G[A_NL + jmi[jn0]])
          aw("\n" as *u8)
      }
      jn0 = jn0 + 1
  }
  var ndead: i64 = 0
  var jf1: i64 = 0
  while jf1 < nj {
      donor[jf1] = 0 - 1
      if adoptj[jf1] == 1 {
          ndead = ndead + 1
          var best: i64 = 0 - 1
          var bd2: i64 = A_MAGIC_4611686018427387903
          var jf2: i64 = 0
          while jf2 < nj {
              if flatj[jf2] == 0 {
                  let ddx: i64 = (gts[jf1*3] - gts[jf2*3])/16
                  let ddy: i64 = (gts[jf1*3+1] - gts[jf2*3+1])/16
                  let ddz: i64 = (gts[jf1*3+2] - gts[jf2*3+2])/16
                  let dd2: i64 = ddx*ddx + ddy*ddy + ddz*ddz
                  if dd2 < bd2 { bd2 = dd2; best = jf2 }
              }
              jf2 = jf2 + 1
          }
          donor[jf1] = best
      }
      jf1 = jf1 + 1
  }
  aw("adopted_joints=" as *u8); an(ndead); aw("\n" as *u8)
  // ANIM bake: per 30Hz sample evaluate FK with curves, emit channel-2 PACKED world deltas:
  // key = 2 words; w0 lanes LE [t_ms u16][dqx dqy dqz i16 q12]; w1 [dqw i16][dtx dty dtz i16 mm]
  // D = Gq_anim x conj(Gq_static); dt = (Gt_anim - Gt_static)/100 units->mm. Every joint gets
  // a track: ancestor rotation moves EVERY descendant's world transform.
  let nk: i64 = maxms/33 + 1
  let awl: i64 = 1 + nj*(3 + nk*2)
  let ap2: *i64 = sys_mmap(awl*8 + 64) as *i64
  ap2[0] = nj
  let gqa: *i64 = sys_mmap(nj*32 + 64) as *i64
  let gta: *i64 = sys_mmap(nj*24 + 64) as *i64
  let aq: *i64 = sys_mmap(64) as *i64
  let cq: *i64 = sys_mmap(64) as *i64
  let dq: *i64 = sys_mmap(64) as *i64
  // track headers first (fixed layout: track j at 1 + j*(3+nk*2))
  var jh: i64 = 0
  while jh < nj {
      let hb: i64 = 1 + jh*(3 + nk*2)
      ap2[hb] = jh
      ap2[hb+1] = 2
      ap2[hb+2] = nk
      jh = jh + 1
  }
  // transform snapshot at the stretch-test frame (s=106 ~ t=3.5s)
  let gqx: *i64 = sys_mmap(nj*32 + 64) as *i64
  let gtx: *i64 = sys_mmap(nj*24 + 64) as *i64
  // full per-sample world-transform store for the FOOT-LOCK IK pass (nk*nj quats+pos)
  let sgq: *i64 = sys_mmap(nk*nj*32 + 64) as *i64
  let sgt: *i64 = sys_mmap(nk*nj*24 + 64) as *i64
  var clamped: i64 = 0
  var s: i64 = 0
  while s < nk {
      let tms: i64 = s*33
      var ti1: i64 = 0
      while ti1 < nj {
          let j: i64 = topo[ti1]
          let mi3: i64 = jmi[j]
          // local rotation: curves replace Lcl Rotation entirely; PreRotation always applies
          var mdx: i64 = G[A_LR + mi3*3]
          var mdy: i64 = G[A_LR + mi3*3 + 1]
          var mdz: i64 = G[A_LR + mi3*3 + 2]
          if cnk[j*6] > 0 { mdx = a_sample_ang(cptr[j*12] as *u8, cptr[j*12+1] as *u8, cnk[j*6], tms) }
          if cnk[j*6+1] > 0 { mdy = a_sample_ang(cptr[j*12+2] as *u8, cptr[j*12+3] as *u8, cnk[j*6+1], tms) }
          if cnk[j*6+2] > 0 { mdz = a_sample_ang(cptr[j*12+4] as *u8, cptr[j*12+5] as *u8, cnk[j*6+2], tms) }
          nf_eul2q(mdx, mdy, mdz, aq, scr)
          nf_qmul(((pq as i64) + j*32) as *i64, aq, lq)
          nf_qnorm(lq)
          // local translation: curves replace Lcl Translation where present
          var ltx: i64 = G[A_LT + mi3*3]
          var lty: i64 = G[A_LT + mi3*3 + 1]
          var ltz: i64 = G[A_LT + mi3*3 + 2]
          if cnk[j*6+3] > 0 { ltx = a_sample(cptr[j*12+6] as *u8, cptr[j*12+7] as *u8, cnk[j*6+3], tms) }
          if cnk[j*6+4] > 0 { lty = a_sample(cptr[j*12+8] as *u8, cptr[j*12+9] as *u8, cnk[j*6+4], tms) }
          if cnk[j*6+5] > 0 { ltz = a_sample(cptr[j*12+10] as *u8, cptr[j*12+11] as *u8, cnk[j*6+5], tms) }
          let pj2: i64 = jpar[j]
          if pj2 < 0 {
              nf_qmul(((prefq as i64) + j*32) as *i64, lq, ((gqa as i64) + j*32) as *i64)
              nf_qnorm(((gqa as i64) + j*32) as *i64)
              nf_qrotv(((prefq as i64) + j*32) as *i64, ltx, lty, ltz, rv, scr)
              gta[j*3] = preft[j*3] + rv[0]
              gta[j*3+1] = preft[j*3+1] + rv[1]
              gta[j*3+2] = preft[j*3+2] + rv[2]
          }
          if pj2 >= 0 {
              nf_qmul(((gqa as i64) + pj2*32) as *i64, lq, ((gqa as i64) + j*32) as *i64)
              nf_qnorm(((gqa as i64) + j*32) as *i64)
              nf_qrotv(((gqa as i64) + pj2*32) as *i64, ltx, lty, ltz, rv, scr)
              gta[j*3] = gta[pj2*3] + rv[0]
              gta[j*3+1] = gta[pj2*3+1] + rv[1]
              gta[j*3+2] = gta[pj2*3+2] + rv[2]
          }
          // world delta about bind (static FK) -> packed key (dead joints packed below)
          if adoptj[j] == 0 {
              nf_qconj(((gqs as i64) + j*32) as *i64, cq)
              nf_qmul(((gqa as i64) + j*32) as *i64, cq, dq)
              nf_qnorm(dq)
              var dtx: i64 = (gta[j*3] - gts[j*3]) / 100
              var dty: i64 = (gta[j*3+1] - gts[j*3+1]) / 100
              var dtz: i64 = (gta[j*3+2] - gts[j*3+2]) / 100
              if dtx > A_MAGIC_32767 { dtx = A_MAGIC_32767; clamped = clamped + 1 }
              if dtx < 0 - A_MAGIC_32767 { dtx = 0 - A_MAGIC_32767; clamped = clamped + 1 }
              if dty > A_MAGIC_32767 { dty = A_MAGIC_32767; clamped = clamped + 1 }
              if dty < 0 - A_MAGIC_32767 { dty = 0 - A_MAGIC_32767; clamped = clamped + 1 }
              if dtz > A_MAGIC_32767 { dtz = A_MAGIC_32767; clamped = clamped + 1 }
              if dtz < 0 - A_MAGIC_32767 { dtz = 0 - A_MAGIC_32767; clamped = clamped + 1 }
              let kb: i64 = 1 + j*(3 + nk*2) + 3 + s*2
              ap2[kb] = (tms & A_MAGIC_65535) | ((dq[0] & A_MAGIC_65535) << 16) | ((dq[1] & A_MAGIC_65535) << 32) | ((dq[2] & A_MAGIC_65535) << 48)
              ap2[kb+1] = (dq[3] & A_MAGIC_65535) | ((dtx & A_MAGIC_65535) << 16) | ((dty & A_MAGIC_65535) << 32) | ((dtz & A_MAGIC_65535) << 48)
          }
          ti1 = ti1 + 1
      }
      // dead-chain joints: adopt the donor's EXACT world transform, re-expressed about the
      // dead joint's own bind: D = D_donor; dt = D(b_j - b_d) + b_d + dt_d - b_j
      var jd9: i64 = 0
      while jd9 < nj {
          if adoptj[jd9] == 1 { if donor[jd9] >= 0 {
              let dnr: i64 = donor[jd9]
              nf_qconj(((gqs as i64) + dnr*32) as *i64, cq)
              nf_qmul(((gqa as i64) + dnr*32) as *i64, cq, dq)
              nf_qnorm(dq)
              nf_qrotv(dq, gts[jd9*3] - gts[dnr*3], gts[jd9*3+1] - gts[dnr*3+1], gts[jd9*3+2] - gts[dnr*3+2], rv, scr)
              var dtx: i64 = (rv[0] + gta[dnr*3] - gts[jd9*3]) / 100
              var dty: i64 = (rv[1] + gta[dnr*3+1] - gts[jd9*3+1]) / 100
              var dtz: i64 = (rv[2] + gta[dnr*3+2] - gts[jd9*3+2]) / 100
              if dtx > A_MAGIC_32767 { dtx = A_MAGIC_32767; clamped = clamped + 1 }
              if dtx < 0 - A_MAGIC_32767 { dtx = 0 - A_MAGIC_32767; clamped = clamped + 1 }
              if dty > A_MAGIC_32767 { dty = A_MAGIC_32767; clamped = clamped + 1 }
              if dty < 0 - A_MAGIC_32767 { dty = 0 - A_MAGIC_32767; clamped = clamped + 1 }
              if dtz > A_MAGIC_32767 { dtz = A_MAGIC_32767; clamped = clamped + 1 }
              if dtz < 0 - A_MAGIC_32767 { dtz = 0 - A_MAGIC_32767; clamped = clamped + 1 }
              let kb2: i64 = 1 + jd9*(3 + nk*2) + 3 + s*2
              ap2[kb2] = (tms & A_MAGIC_65535) | ((dq[0] & A_MAGIC_65535) << 16) | ((dq[1] & A_MAGIC_65535) << 32) | ((dq[2] & A_MAGIC_65535) << 48)
              ap2[kb2+1] = (dq[3] & A_MAGIC_65535) | ((dtx & A_MAGIC_65535) << 16) | ((dty & A_MAGIC_65535) << 32) | ((dtz & A_MAGIC_65535) << 48)
          } }
          jd9 = jd9 + 1
      }
      if s == 106 {
          var sn0: i64 = 0
          while sn0 < nj*4 { gqx[sn0] = gqa[sn0]; sn0 = sn0 + 1 }
          var sn1: i64 = 0
          while sn1 < nj*3 { gtx[sn1] = gta[sn1]; sn1 = sn1 + 1 }
      }
      var sc0: i64 = 0
      while sc0 < nj*4 { sgq[s*nj*4 + sc0] = gqa[sc0]; sc0 = sc0 + 1 }
      var sc1: i64 = 0
      while sc1 < nj*3 { sgt[s*nj*3 + sc1] = gta[sc1]; sc1 = sc1 + 1 }
      s = s + 1
  }
  // ===== FOOT-LOCK IK (SOTA rung 1): plant heels during MEASURED stance phases =====
  // stance = foot XY-speed ~0; ground = min foot-z over clip; 2-bone thigh-calf IK moves
  // the ankle to (pinned XY, ground z) blended by a smoothed stance weight; the whole
  // thigh subtree (twists/toes) is rigidly re-based on the corrected chain and repacked.
  var jFL: i64 = 0 - 1
  var jFR: i64 = 0 - 1
  var jq9: i64 = 0
  while jq9 < nj {
      if a_namehas(fb, G[A_NO + jmi[jq9]], G[A_NL + jmi[jq9]], "_L_Foot" as *u8) == 1 { jFL = jq9 }
      if a_namehas(fb, G[A_NO + jmi[jq9]], G[A_NL + jmi[jq9]], "_R_Foot" as *u8) == 1 { jFR = jq9 }
      jq9 = jq9 + 1
  }
  var planted: i64 = 0
  if heels == 0 { if jFL >= 0 { if jFR >= 0 {
      let ikw: *i64 = sys_mmap(nk*16 + 64) as *i64
      let pinx: *i64 = sys_mmap(nk*16 + 64) as *i64
      let piny: *i64 = sys_mmap(nk*16 + 64) as *i64
      let dq1: *i64 = sys_mmap(64) as *i64
      let dq2: *i64 = sys_mmap(64) as *i64
      let qc9: *i64 = sys_mmap(64) as *i64
      let qr9: *i64 = sys_mmap(64) as *i64
      let qo9: *i64 = sys_mmap(64) as *i64
      var side: i64 = 0
      while side < 2 {
          var jF: i64 = jFL
          if side == 1 { jF = jFR }
          let jC: i64 = jpar[jF]
          let jT: i64 = jpar[jC]
          var gz: i64 = A_MAGIC_4611686018427387903
          var s9: i64 = 0
          while s9 < nk {
              if sgt[s9*nj*3 + jF*3 + 2] < gz { gz = sgt[s9*nj*3 + jF*3 + 2] }
              s9 = s9 + 1
          }
          var s8: i64 = 0
          while s8 < nk {
              // stance = foot in its LOWEST height band (works for in-place AND traveling
              // walks; XY-speed failed on this in-place clip: planted foot slides backward)
              var st9: i64 = 0
              if sgt[s8*nj*3 + jF*3 + 2] - gz < A_MAGIC_1500 { st9 = 1 }
              ikw[s8*2 + side] = 0
              if st9 == 1 { ikw[s8*2 + side] = 1000 }
              s8 = s8 + 1
          }
          var bp: i64 = 0
          while bp < 2 {
              var s7: i64 = 1
              while s7 < nk - 1 {
                  ikw[s7*2+side] = (ikw[(s7-1)*2+side] + ikw[s7*2+side]*2 + ikw[(s7+1)*2+side])/4
                  s7 = s7 + 1
              }
              bp = bp + 1
          }
          var lx: i64 = 0
          var ly: i64 = 0
          var inrun: i64 = 0
          var s6: i64 = 0
          while s6 < nk {
              if ikw[s6*2+side] > 500 {
                  if inrun == 0 { lx = sgt[s6*nj*3 + jF*3]; ly = sgt[s6*nj*3 + jF*3 + 1]; inrun = 1 }
              }
              if ikw[s6*2+side] <= 500 { inrun = 0; lx = sgt[s6*nj*3+jF*3]; ly = sgt[s6*nj*3+jF*3+1] }
              pinx[s6*2+side] = lx
              piny[s6*2+side] = ly
              s6 = s6 + 1
          }
          let L1: i64 = nf_isqrt((gts[jC*3]-gts[jT*3])*(gts[jC*3]-gts[jT*3]) + (gts[jC*3+1]-gts[jT*3+1])*(gts[jC*3+1]-gts[jT*3+1]) + (gts[jC*3+2]-gts[jT*3+2])*(gts[jC*3+2]-gts[jT*3+2]))
          let L2: i64 = nf_isqrt((gts[jF*3]-gts[jC*3])*(gts[jF*3]-gts[jC*3]) + (gts[jF*3+1]-gts[jC*3+1])*(gts[jF*3+1]-gts[jC*3+1]) + (gts[jF*3+2]-gts[jC*3+2])*(gts[jF*3+2]-gts[jC*3+2]))
          var s5: i64 = 0
          while s5 < nk {
              let w5: i64 = ikw[s5*2+side]
              if w5 > 20 {
                  planted = planted + 1
                  let bq: i64 = s5*nj*4
                  let bt: i64 = s5*nj*3
                  let hx: i64 = sgt[bt+jT*3]
                  let hy: i64 = sgt[bt+jT*3+1]
                  let hz: i64 = sgt[bt+jT*3+2]
                  let kx: i64 = sgt[bt+jC*3]
                  let ky: i64 = sgt[bt+jC*3+1]
                  let kz: i64 = sgt[bt+jC*3+2]
                  let fx: i64 = sgt[bt+jF*3]
                  let fy: i64 = sgt[bt+jF*3+1]
                  let fz: i64 = sgt[bt+jF*3+2]
                  var tx: i64 = fx
                  var ty: i64 = fy
                  var tz: i64 = fz + (gz - fz)*w5/1000
                  var ddx: i64 = tx - hx
                  var ddy: i64 = ty - hy
                  var ddz: i64 = tz - hz
                  var dd: i64 = nf_isqrt(ddx*ddx + ddy*ddy + ddz*ddz)
                  let dmax: i64 = L1 + L2 - 60
                  if dd > dmax {
                      tx = hx + ddx*dmax/dd
                      ty = hy + ddy*dmax/dd
                      tz = hz + ddz*dmax/dd
                      ddx = tx - hx
                      ddy = ty - hy
                      ddz = tz - hz
                      dd = dmax
                  }
                  if dd < 100 { dd = 100 }
                  let aa: i64 = (L1*L1 + dd*dd - L2*L2)/(2*dd)
                  var h2: i64 = L1*L1 - aa*aa
                  if h2 < 0 { h2 = 0 }
                  let hh: i64 = nf_isqrt(h2)
                  let khx: i64 = kx - hx
                  let khy: i64 = ky - hy
                  let khz: i64 = kz - hz
                  let along: i64 = (khx*ddx + khy*ddy + khz*ddz)/dd
                  var px9: i64 = khx - ddx*along/dd
                  var py9: i64 = khy - ddy*along/dd
                  var pz9: i64 = khz - ddz*along/dd
                  var pl: i64 = nf_isqrt(px9*px9 + py9*py9 + pz9*pz9)
                  if pl < 20 { px9 = ddy; py9 = 0 - ddx; pz9 = 0; pl = nf_isqrt(px9*px9 + py9*py9 + pz9*pz9); if pl < 1 { pl = 1 } }
                  let nkx: i64 = hx + ddx*aa/dd + px9*hh/pl
                  let nky: i64 = hy + ddy*aa/dd + py9*hh/pl
                  let nkz: i64 = hz + ddz*aa/dd + pz9*hh/pl
                  nf_qarc(kx-hx, ky-hy, kz-hz, nkx-hx, nky-hy, nkz-hz, dq1)
                  nf_qarc(fx-kx, fy-ky, fz-kz, tx-nkx, ty-nky, tz-nkz, dq2)
                  // corrected world transforms: thigh(rot only), calf, foot (+rides dq2)
                  var jx9: i64 = 0
                  while jx9 < nj {
                      // nearest corrected ancestor: F beats C beats T
                      var anc: i64 = 0 - 1
                      if jx9 == jT { anc = 0 - 2 }
                      if jx9 == jC { anc = 0 - 2 }
                      if jx9 == jF { anc = 0 - 2 }
                      if anc == 0 - 1 {
                          var cu9: i64 = jpar[jx9]
                          var hops9: i64 = 0
                          while cu9 >= 0 {
                              if cu9 == jF { anc = jF; cu9 = 0 - 1 }
                              if cu9 == jC { if anc < 0 { anc = jC; cu9 = 0 - 1 } }
                              if cu9 == jT { if anc < 0 { anc = jT; cu9 = 0 - 1 } }
                              if cu9 >= 0 { cu9 = jpar[cu9] }
                              hops9 = hops9 + 1
                              if hops9 > 32 { cu9 = 0 - 1 }
                          }
                      }
                      if anc != 0 - 1 {
                          // old world of this joint
                          let qj0: i64 = bq + jx9*4
                          // compute corrected world for jx9
                          var nqx: i64 = 0
                          var nqy: i64 = 0
                          var nqz: i64 = 0
                          var nqw: i64 = A_MAGIC_4096
                          var ntx: i64 = 0
                          var nty: i64 = 0
                          var ntz: i64 = 0
                          if jx9 == jT {
                              nf_qmul(dq1, ((sgq as i64) + qj0*8) as *i64, qo9)
                              nf_qnorm(qo9)
                              nqx = qo9[0]; nqy = qo9[1]; nqz = qo9[2]; nqw = qo9[3]
                              ntx = hx; nty = hy; ntz = hz
                          }
                          if jx9 == jC {
                              nf_qmul(dq2, ((sgq as i64) + qj0*8) as *i64, qo9)
                              nf_qnorm(qo9)
                              nqx = qo9[0]; nqy = qo9[1]; nqz = qo9[2]; nqw = qo9[3]
                              ntx = nkx; nty = nky; ntz = nkz
                          }
                          if jx9 == jF {
                              nf_qmul(dq2, ((sgq as i64) + qj0*8) as *i64, qo9)
                              nf_qnorm(qo9)
                              nqx = qo9[0]; nqy = qo9[1]; nqz = qo9[2]; nqw = qo9[3]
                              ntx = tx; nty = ty; ntz = tz
                          }
                          if anc >= 0 {
                              // rebase on corrected ancestor: G' = Ganc' o (Ganc^-1 o G)
                              var aq0: i64 = bq + anc*4
                              var at0: i64 = bt + anc*3
                              nf_qconj(((sgq as i64) + aq0*8) as *i64, qc9)
                              nf_qmul(qc9, ((sgq as i64) + qj0*8) as *i64, qr9)
                              nf_qrotv(qc9, sgt[bt+jx9*3]-sgt[at0], sgt[bt+jx9*3+1]-sgt[at0+1], sgt[bt+jx9*3+2]-sgt[at0+2], rv, scr)
                              let rlx: i64 = rv[0]
                              let rly: i64 = rv[1]
                              let rlz: i64 = rv[2]
                              // ancestor corrected values
                              var acqx: i64 = 0
                              var acqy: i64 = 0
                              var acqz: i64 = 0
                              var acqw: i64 = A_MAGIC_4096
                              var actx: i64 = 0
                              var acty: i64 = 0
                              var actz: i64 = 0
                              if anc == jT {
                                  nf_qmul(dq1, ((sgq as i64) + (bq+jT*4)*8) as *i64, qo9)
                                  nf_qnorm(qo9)
                                  acqx=qo9[0]; acqy=qo9[1]; acqz=qo9[2]; acqw=qo9[3]
                                  actx=hx; acty=hy; actz=hz
                              }
                              if anc == jC {
                                  nf_qmul(dq2, ((sgq as i64) + (bq+jC*4)*8) as *i64, qo9)
                                  nf_qnorm(qo9)
                                  acqx=qo9[0]; acqy=qo9[1]; acqz=qo9[2]; acqw=qo9[3]
                                  actx=nkx; acty=nky; actz=nkz
                              }
                              if anc == jF {
                                  nf_qmul(dq2, ((sgq as i64) + (bq+jF*4)*8) as *i64, qo9)
                                  nf_qnorm(qo9)
                                  acqx=qo9[0]; acqy=qo9[1]; acqz=qo9[2]; acqw=qo9[3]
                                  actx=tx; acty=ty; actz=tz
                              }
                              qc9[0]=acqx; qc9[1]=acqy; qc9[2]=acqz; qc9[3]=acqw
                              nf_qmul(qc9, qr9, qo9)
                              nf_qnorm(qo9)
                              nqx=qo9[0]; nqy=qo9[1]; nqz=qo9[2]; nqw=qo9[3]
                              nf_qrotv(qc9, rlx, rly, rlz, rv, scr)
                              ntx = actx + rv[0]
                              nty = acty + rv[1]
                              ntz = actz + rv[2]
                          }
                          // repack this joint at this sample: D = q' x conj(static), dt=(t'-static)/100
                          qc9[0]=nqx; qc9[1]=nqy; qc9[2]=nqz; qc9[3]=nqw
                          nf_qconj(((gqs as i64) + jx9*32) as *i64, qr9)
                          nf_qmul(qc9, qr9, qo9)
                          nf_qnorm(qo9)
                          var dtx9: i64 = (ntx - gts[jx9*3]) / 100
                          var dty9: i64 = (nty - gts[jx9*3+1]) / 100
                          var dtz9: i64 = (ntz - gts[jx9*3+2]) / 100
                          if dtx9 > A_MAGIC_32767 { dtx9 = A_MAGIC_32767 }
                          if dtx9 < 0 - A_MAGIC_32767 { dtx9 = 0 - A_MAGIC_32767 }
                          if dty9 > A_MAGIC_32767 { dty9 = A_MAGIC_32767 }
                          if dty9 < 0 - A_MAGIC_32767 { dty9 = 0 - A_MAGIC_32767 }
                          if dtz9 > A_MAGIC_32767 { dtz9 = A_MAGIC_32767 }
                          if dtz9 < 0 - A_MAGIC_32767 { dtz9 = 0 - A_MAGIC_32767 }
                          let kb9: i64 = 1 + jx9*(3 + nk*2) + 3 + s5*2
                          let tms9: i64 = s5*33
                          ap2[kb9] = (tms9 & A_MAGIC_65535) | ((qo9[0] & A_MAGIC_65535) << 16) | ((qo9[1] & A_MAGIC_65535) << 32) | ((qo9[2] & A_MAGIC_65535) << 48)
                          ap2[kb9+1] = (qo9[3] & A_MAGIC_65535) | ((dtx9 & A_MAGIC_65535) << 16) | ((dty9 & A_MAGIC_65535) << 32) | ((dtz9 & A_MAGIC_65535) << 48)
                      }
                      jx9 = jx9 + 1
                  }
              }
              s5 = s5 + 1
          }
          side = side + 1
      }
  } } }
  aw("footik_planted_samples=" as *u8); an(planted); aw("\n" as *u8)
  // EDGE-STRETCH QUALITY METRIC (permanent): skin every vert with the s=106 transforms,
  // measure each triangle edge's skinned/bind length ratio. Tears = edges stretched >2x;
  // the worst offender's joint slots NAME the culprit pair (this instrument found the
  // eye-bound-face defect's successors instead of another day of guessing).
  let vwo9: i64 = nxa_find(nb, nlen2, nxa_tag4("VERT" as *u8))
  let two9: i64 = nxa_find(nb, nlen2, nxa_tag4("TRIS" as *u8))
  let kwo9: i64 = nxa_find(nb, nlen2, nxa_tag4("SKIN" as *u8))
  if vwo9 >= 0 { if two9 >= 0 { if kwo9 >= 0 {
      let nv9: i64 = nh[vwo9]
      let nt9: i64 = nh[two9]
      let vx9: *i64 = ((nb as i64) + vwo9*8 + 8) as *i64
      let tr9: *i64 = ((nb as i64) + two9*8 + 8) as *i64
      let sk9: *i64 = ((nb as i64) + kwo9*8 + 8) as *i64
      let sp: *i64 = sys_mmap(nv9*24 + 64) as *i64
      let dqs: *i64 = sys_mmap(64) as *i64
      var v8: i64 = 0
      while v8 < nv9 {
          var px: i64 = 0
          var py: i64 = 0
          var pz: i64 = 0
          var s8: i64 = 0
          while s8 < 4 {
              let jj8: i64 = sk9[v8*8+s8]
              let ww8: i64 = sk9[v8*8+4+s8]
              if ww8 > 0 { if jj8 >= 0 { if jj8 < nj {
                  nf_qconj(((gqs as i64) + jj8*32) as *i64, cq)
                  nf_qmul(((gqx as i64) + jj8*32) as *i64, cq, dqs)
                  nf_qnorm(dqs)
                  nf_qrotv(dqs, vx9[v8*3] - gts[jj8*3], vx9[v8*3+1] - gts[jj8*3+1], vx9[v8*3+2] - gts[jj8*3+2], rv, scr)
                  px = px + ww8*(rv[0] + gtx[jj8*3]) / A_MAGIC_4096
                  py = py + ww8*(rv[1] + gtx[jj8*3+1]) / A_MAGIC_4096
                  pz = pz + ww8*(rv[2] + gtx[jj8*3+2]) / A_MAGIC_4096
              } } }
              s8 = s8 + 1
          }
          sp[v8*3] = px
          sp[v8*3+1] = py
          sp[v8*3+2] = pz
          v8 = v8 + 1
      }
      var over2: i64 = 0
      var worst: i64 = 0
      let pcnt: *i64 = sys_mmap(nj*nj*8 + 64) as *i64
      var t8: i64 = 0
      while t8 < nt9 {
          var e8: i64 = 0
          while e8 < 3 {
              let va: i64 = tr9[t8*3 + e8]
              var vb: i64 = tr9[t8*3]
              if e8 < 2 { vb = tr9[t8*3 + e8 + 1] }
              let bx9: i64 = vx9[va*3] - vx9[vb*3]
              let by9: i64 = vx9[va*3+1] - vx9[vb*3+1]
              let bz9: i64 = vx9[va*3+2] - vx9[vb*3+2]
              let sx9: i64 = sp[va*3] - sp[vb*3]
              let sy9: i64 = sp[va*3+1] - sp[vb*3+1]
              let sz9: i64 = sp[va*3+2] - sp[vb*3+2]
              let bl: i64 = nf_isqrt(bx9*bx9 + by9*by9 + bz9*bz9)
              let sl: i64 = nf_isqrt(sx9*sx9 + sy9*sy9 + sz9*sz9)
              if bl > 20 {
                  let ratio: i64 = sl*100/bl
                  if ratio > 200 {
                      over2 = over2 + 1
                      // dominant joint of each endpoint -> pair bucket
                      var da: i64 = 0
                      var sa2: i64 = 1
                      while sa2 < 4 { if sk9[va*8+4+sa2] > sk9[va*8+4+da] { da = sa2 } sa2 = sa2 + 1 }
                      var db: i64 = 0
                      var sb2: i64 = 1
                      while sb2 < 4 { if sk9[vb*8+4+sb2] > sk9[vb*8+4+db] { db = sb2 } sb2 = sb2 + 1 }
                      var ja0: i64 = sk9[va*8+da]
                      var jb0: i64 = sk9[vb*8+db]
                      if ja0 > jb0 { let tt0: i64 = ja0; ja0 = jb0; jb0 = tt0 }
                      if ja0 >= 0 { if jb0 < nj { pcnt[ja0*nj + jb0] = pcnt[ja0*nj + jb0] + 1 } }
                  }
                  if ratio > worst { worst = ratio }
              }
              e8 = e8 + 1
          }
          t8 = t8 + 1
      }
      aw("stretch_over2x=" as *u8); an(over2)
      aw(" worst_x100=" as *u8); an(worst); aw("\n" as *u8)
      // top-5 tearing joint pairs by edge count
      var rank: i64 = 0
      while rank < 5 {
          var bc: i64 = 0
          var bja: i64 = 0 - 1
          var bjb: i64 = 0 - 1
          var pa0: i64 = 0
          while pa0 < nj {
              var pb0: i64 = pa0
              while pb0 < nj {
                  if pcnt[pa0*nj + pb0] > bc { bc = pcnt[pa0*nj + pb0]; bja = pa0; bjb = pb0 }
                  pb0 = pb0 + 1
              }
              pa0 = pa0 + 1
          }
          if bja >= 0 {
              aw("  PAIR n=" as *u8); an(bc)
              aw(" " as *u8)
              a_wname(fb, G[A_NO + jmi[bja]], G[A_NL + jmi[bja]])
              aw(" <> " as *u8)
              a_wname(fb, G[A_NO + jmi[bjb]], G[A_NL + jmi[bjb]])
              aw("\n" as *u8)
              pcnt[bja*nj + bjb] = 0
          }
          rank = rank + 1
      }
  } } }
  aw("baked tracks=" as *u8); an(nj)
  aw(" keys_per_track=" as *u8); an(nk)
  aw(" clamped=" as *u8); an(clamped)
  aw(" wrap_events=" as *u8); an(wrapn); aw("\n" as *u8)
  // CORRECTED SKEL: FK-true world positions for ALL joints replace the placeholder-
  // propagated binds (19 unclustered joints incl the hip chain sat at a parent's bind or
  // 0,0,0) -- the baked deltas pivot about gts, so the shipped SKEL must too, exactly.
  let swl2: i64 = 1 + nj*8
  let cskel: *i64 = sys_mmap(swl2*8 + 64) as *i64
  cskel[0] = nj
  var jc5: i64 = 0
  while jc5 < nj {
      cskel[1 + jc5*8] = skb[jc5*8]
      cskel[1 + jc5*8 + 1] = gts[jc5*3]
      cskel[1 + jc5*8 + 2] = gts[jc5*3+1]
      cskel[1 + jc5*8 + 3] = gts[jc5*3+2]
      cskel[1 + jc5*8 + 4] = 0
      cskel[1 + jc5*8 + 5] = 0
      cskel[1 + jc5*8 + 6] = 0
      cskel[1 + jc5*8 + 7] = A_MAGIC_4096
      jc5 = jc5 + 1
  }
  // copy the sections from in.nxa5 (SKEL swapped for the corrected one), append ANIM
  let ons: i64 = nh[2]
  let otoc: *i64 = ((nb as i64) + 32) as *i64
  let ns2: i64 = ons + 1
  let hdr: *i64 = sys_mmap(64) as *i64
  let toc: *i64 = sys_mmap(A_MAGIC_1024) as *i64
  var o: i64 = 32 + ns2*32
  var ti: i64 = 0
  while ti < ons {
      toc[ti*4] = otoc[ti*4]
      toc[ti*4+1] = o
      toc[ti*4+2] = otoc[ti*4+2]
      toc[ti*4+3] = otoc[ti*4+3]
      if otoc[ti*4] == nxa_tag4("SKEL" as *u8) { toc[ti*4+3] = nxa_check2(1, cskel, swl2) }
      o = o + otoc[ti*4+2]*8
      ti = ti + 1
  }
  toc[ti*4] = nxa_tag4("ANIM" as *u8)
  toc[ti*4+1] = o
  toc[ti*4+2] = awl
  toc[ti*4+3] = nxa_check2(1, ap2, awl)
  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 { aw("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] == nxa_tag4("SKEL" as *u8) { sys_write(fd, cskel as *u8, swl2*8) }
      if otoc[ci3*4] != nxa_tag4("SKEL" as *u8) { sys_write(fd, ((nb as i64) + otoc[ci3*4+1]) as *u8, otoc[ci3*4+2]*8) }
      ci3 = ci3 + 1
  }
  sys_write(fd, ap2 as *u8, awl*8)
  sys_close(fd)
  aw("NXA6 written tracks=" as *u8); an(nj)
  aw(" duration_ms=" as *u8); an(maxms); aw("\n" as *u8)
  return 0
1519}
nx_nxa_anim.nx source

`nx_nxa_anim.nx` source
