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

↩ module page · 935 lines · 43619 B
1// nx_gltf_load.nx -- ★sovereign glTF (.glb) LOADER: parse a binary glTF back into nx_trimesh buffers, so the Nishi stack
2// (Nishi OS / Nishi browser) can NATIVELY VIEW a .glb -- and so we can render our own exports on our own renderer to prove
3// the round-trip (the honest-scope gap: "eyeball the model sovereignly"). Inverse of nx_gltf_mesh: includes an integer
4// IEEE-754 float32 DECODER. Loads POSITION + COLOR_0 + indices from our exporter's layout; recomputes normals. license_tier: ORIGINAL
5import "nx_syscalls.nx"
6import "nx_trimesh.nx"
7const K_MAGIC_8388607: i64 = 8388607
8const K_MAGIC_8388608: i64 = 8388608
9const K_MAGIC_65536: i64 = 65536
10const K_MAGIC_2147483647: i64 = 2147483647
11const K_MAGIC_2000000000: i64 = 2000000000
12const K_MAGIC_1024: i64 = 1024
13const K_MAGIC_5123: i64 = 5123
14const K_MAGIC_5125: i64 = 5125
15
16// IEEE-754 float32 bit pattern -> integer (inverse of gl_f32bits; exact for the integer coordinates we export)
17func gll_f32i(bits: i64) -> i64 {
  if bits == 0 { return 0 }
  let sign: i64 = (bits>>31)&1
  let exp: i64 = (bits>>23)&255
  let mant: i64 = bits & K_MAGIC_8388607
  if exp == 0 { return 0 }
  let e: i64 = exp - 127
  if e < 0-30 { return 0 }                    // |v| < 2^-30 rounds to integer 0 (also guards shift-by->63 UB)
  let m: i64 = K_MAGIC_8388608 + mant                 // 1.mant scaled by 2^23
  var val: i64 = 0
  if e >= 23 { val = m << (e-23) } else { val = m >> (23-e) }
  if sign == 1 { val = 0-val }
  return val
30}
31func gll_ru8(buf: *u8, at: i64) -> i64 { return buf[at] as i64 }
32func gll_ru32(buf: *u8, at: i64) -> i64 { return (buf[at] as i64) + ((buf[at+1] as i64)<<8) + ((buf[at+2] as i64)<<16) + ((buf[at+3] as i64)<<24) }
33func gll_align4(x: i64) -> i64 { return (x+3)/4*4 }
34func gll_slen(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} return n }
35// ★D1 FAIL-CLOSED (debt 1785902685): a loader that cannot parse an input must REFUSE with a NAMED
36// reason and never read outside the mapped file. GLL_WHY carries the last refusal for callers/gates.
37static GLL_WHY: i64
38func gltf_load_why() -> *u8 { if GLL_WHY == 0 { return "ok" as *u8 } return GLL_WHY as *u8 }
39func gll_refuse(why: *u8) -> i64 {
  GLL_WHY = why as i64
  let pre: *u8 = "gltf-load REFUSE: " as *u8
  sys_write(1, pre, gll_slen(pre))
  sys_write(1, why, gll_slen(why))
  let nl: *u8 = sys_mmap(1) as *u8
  nl[0] = 10 as u8
  sys_write(1, nl, 1)
  return 0
48}
49// every byte of [off, off+need) must lie inside the mapped file
50func gll_inb(off: i64, need: i64, size: i64) -> i64 {
  if off < 0 { return 0 }
  if need < 0 { return 0 }
  if off > size { return 0 }
  if off + need > size { return 0 }
  return 1
56}
57// all three vertex indices must name a loaded vertex
58func gll_idx3(a: i64, b: i64, c: i64, nv: i64) -> i64 {
  if a < 0 { return 0 }
  if a >= nv { return 0 }
  if b < 0 { return 0 }
  if b >= nv { return 0 }
  if c < 0 { return 0 }
  if c >= nv { return 0 }
  return 1
66}
67// find the n-th integer that follows `needle` within buf[start,end)
68func gll_nth_num(buf: *u8, start: i64, end: i64, needle: *u8, n: i64) -> i64 {
  let m: i64 = gll_slen(needle)
  var found: i64 = 0
  var i: i64 = start
  while i+m <= end {
      var k: i64 = 0
      while k < m { if (buf[i+k] as i64) != (needle[k] as i64) { k = m+9 } else { k = k+1 } }
      if k == m {
          found = found + 1
          if found == n {
              var p: i64 = i+m
              while (buf[p] as i64) == 32 { p = p+1 }
              var neg: i64 = 0
              if (buf[p] as i64) == 45 { neg = 1; p = p+1 }
              var v: i64 = 0
              while p < end { let c: i64 = buf[p] as i64; if c >= 48 { if c <= 57 { v = v*10 + (c-48); p = p+1 } else { p = end } } else { p = end } }
              if neg == 1 { v = 0-v }
              return v
          }
          i = i + m
      } else { i = i + 1 }
  }
  return 0-1
91}
92
93// load a .glb file into the trimesh buffers. returns 1 on success, 0 on failure. base_col used where colours absent.
94func gltf_load(path: *u8) -> i64 {
  let szp: *i64 = sys_mmap(16) as *i64
  let buf: *u8 = sys_read_file(path, szp)
  let size: i64 = szp[0]
  GLL_WHY = 0
  if (buf as i64) == 0 { return gll_refuse("file-unreadable" as *u8) }
  if size < 20 { return gll_refuse("file-too-short" as *u8) }
  if (buf[0] as i64) != 103 { return gll_refuse("not-glb-magic" as *u8) }        // 'g'
  if (buf[1] as i64) != 108 { return gll_refuse("not-glb-magic" as *u8) }        // 'l'
  if (buf[2] as i64) != 84 { return gll_refuse("not-glb-magic" as *u8) }         // 'T'
  if (buf[3] as i64) != 70 { return gll_refuse("not-glb-magic" as *u8) }         // 'F'
  let jsonLen: i64 = gll_ru32(buf, 12)
  let jsonStart: i64 = 20
  let binStart: i64 = 20 + jsonLen + 8
  if gll_inb(jsonStart, jsonLen, size) == 0 { return gll_refuse("json-chunk-oob" as *u8) }
  if binStart > size { return gll_refuse("bin-chunk-missing" as *u8) }
  // NV = first "count" (POSITION accessor), NI = fourth "count" (indices accessor)
  let NV: i64 = gll_nth_num(buf, jsonStart, jsonStart+jsonLen, "\"count\":" as *u8, 1)
  let NI: i64 = gll_nth_num(buf, jsonStart, jsonStart+jsonLen, "\"count\":" as *u8, 4)
  if NV <= 0 { return gll_refuse("position-count-absent" as *u8) }
  if NI <= 0 { return gll_refuse("index-count-absent" as *u8) }
  // derive our exporter's BIN layout
  let posOff: i64 = binStart
  let colOff: i64 = binStart + gll_align4(NV*12 + NV*6)
  let idxOff: i64 = colOff + NV*4
  if gll_inb(posOff, NV*12, size) == 0 { return gll_refuse("legacy-position-oob" as *u8) }
  if gll_inb(colOff, NV*4, size) == 0 { return gll_refuse("legacy-colour-oob" as *u8) }
  if gll_inb(idxOff, NI*4, size) == 0 { return gll_refuse("legacy-index-oob" as *u8) }
  tm_reset()
  var i: i64 = 0
  while i < NV {
      let x: i64 = gll_f32i(gll_ru32(buf, posOff+i*12))
      let y: i64 = gll_f32i(gll_ru32(buf, posOff+i*12+4))
      let z: i64 = gll_f32i(gll_ru32(buf, posOff+i*12+8))
      let idx: i64 = tm_vert(x, y, z)
      let cr: i64 = gll_ru8(buf, colOff+i*4)
      let cg: i64 = gll_ru8(buf, colOff+i*4+1)
      let cb: i64 = gll_ru8(buf, colOff+i*4+2)
      tm_vcol(idx, cr + cg*256 + cb*K_MAGIC_65536)
      i = i + 1
  }
  let NTRI: i64 = NI/3
  var t: i64 = 0
  while t < NTRI {
      let a: i64 = gll_ru32(buf, idxOff + (t*3)*4)
      let b: i64 = gll_ru32(buf, idxOff + (t*3+1)*4)
      let c: i64 = gll_ru32(buf, idxOff + (t*3+2)*4)
      if gll_idx3(a, b, c, NV) == 0 { return gll_refuse("index-out-of-range" as *u8) }
      tm_tri(a, b, c, 200+200*256+200*K_MAGIC_65536)
      t = t + 1
  }
  if tm_ovf() != 0 { return gll_refuse("mesh-capacity-overflow" as *u8) }
  tm_compute_normals()
  return 1
148}
149
150// ================================================================================================================
151// ★STANDARD-glTF loader (2026-07-11, the graphics-MSU rung): parse REAL third-party .glb (Khronos conformance
152// assets), not just our own exporter's layout -- proper JSON accessor/bufferView walking (byteOffset defaults,
153// byteStride, u16/u32 indices, float32 positions/normals, baseColorFactor). Needles searched WITHOUT quote chars
154// (avoids the "-in-literal hazard); slices keep keys unambiguous. license part of nx_gltf_load. ==================
155func gls_ru16(buf: *u8, at: i64) -> i64 { return (buf[at] as i64) + ((buf[at+1] as i64)<<8) }
156// float32 bits -> integer of (value * 2^k) by exponent shift; zero-guarded.
157func gls_f32s(bits: i64, k: i64) -> i64 { if (bits & K_MAGIC_2147483647) == 0 { return 0 } return gll_f32i(bits + (k<<23)) }
158func gls_find(buf: *u8, end: i64, from: i64, needle: *u8) -> i64 {
  let m: i64 = gll_slen(needle)
  var i: i64 = from
  while i + m <= end {
      var k: i64 = 0
      while k < m { if (buf[i+k] as i64) != (needle[k] as i64) { k = m + 9 } else { k = k + 1 } }
      if k == m { return i }
      i = i + 1
  }
  return 0-1
168}
169// integer value right after `key` (skips to ':', then spaces). -1 if absent in [s,e).
170func gls_key_int(buf: *u8, s: i64, e: i64, key: *u8) -> i64 {
  let p0: i64 = gls_find(buf, e, s, key)
  if p0 < 0 { return 0-1 }
  var p: i64 = p0 + gll_slen(key)
  var col: i64 = 0-1
  while p < e { if (buf[p] as i64) == 58 { col = p; p = e } else { p = p + 1 } }
  if col < 0 { return 0-1 }
  p = col + 1
  var sk: i64 = 1
  while sk == 1 { if p < e { if (buf[p] as i64) == 32 { p = p + 1 } else { sk = 0 } } else { sk = 0 } }
  var v: i64 = 0
  var any: i64 = 0
  var go: i64 = 1
  while go == 1 {
      if p < e {
          let c: i64 = buf[p] as i64
          var isd: i64 = 0
          if c >= 48 { if c <= 57 { isd = 1 } }
          if isd == 1 { v = v*10 + (c-48); any = 1; p = p + 1 } else { go = 0 }
      } else { go = 0 }
  }
  if any == 0 { return 0-1 }
  return v
193}
194// bounds of the k-th object in the JSON array named `arrName`: out[0]=pos of '{', out[1]=pos after matching '}'.
195func gls_arr_obj(buf: *u8, end: i64, arrName: *u8, k: i64, out: *i64) -> i64 {
  return gls_arr_obj_from(buf, end, 0, arrName, k, out)
197}
198// same, but the array NAME is searched from `from` -- for arrays nested inside one object's bounds
199// (each mesh carries its OWN "primitives" array; D2 multi-mesh concat needs the mesh-local one)
200func gls_arr_obj_from(buf: *u8, end: i64, from: i64, arrName: *u8, k: i64, out: *i64) -> i64 {
  let an: i64 = gls_find(buf, end, from, arrName)
  if an < 0 { return 0 }
  var p: i64 = an
  var br: i64 = 0-1
  while p < end { if (buf[p] as i64) == 91 { br = p; p = end } else { p = p + 1 } }
  if br < 0 { return 0 }
  var depth: i64 = 0
  var idx: i64 = 0-1
  var objS: i64 = 0-1
  p = br + 1
  while p < end {
      let c: i64 = buf[p] as i64
      if c == 123 {
          if depth == 0 { idx = idx + 1; if idx == k { objS = p } }
          depth = depth + 1
      }
      if c == 125 {
          depth = depth - 1
          if depth == 0 { if idx == k { out[0] = objS; out[1] = p + 1; return 1 } }
      }
      if c == 93 { if depth == 0 { p = end } }
      p = p + 1
  }
  return 0
225}
226// accessor A -> out: [bufferView, accessorByteOffset, componentType, count]
227func gls_accessor(buf: *u8, jE: i64, A: i64, out: *i64) -> i64 {
  let ob: *i64 = sys_mmap(16) as *i64
  if gls_arr_obj(buf, jE, "accessors" as *u8, A, ob) == 0 { return 0 }
  var bv: i64 = gls_key_int(buf, ob[0], ob[1], "bufferView" as *u8)
  if bv < 0 { bv = 0 }
  var bo: i64 = gls_key_int(buf, ob[0], ob[1], "byteOffset" as *u8)
  if bo < 0 { bo = 0 }
  out[0] = bv
  out[1] = bo
  out[2] = gls_key_int(buf, ob[0], ob[1], "componentType" as *u8)
  out[3] = gls_key_int(buf, ob[0], ob[1], "count" as *u8)
  return 1
239}
240// bufferView B -> out: [byteOffset, byteStride]
241func gls_bufview(buf: *u8, jE: i64, B: i64, out: *i64) -> i64 {
  let ob: *i64 = sys_mmap(16) as *i64
  if gls_arr_obj(buf, jE, "bufferViews" as *u8, B, ob) == 0 { return 0 }
  var bo: i64 = gls_key_int(buf, ob[0], ob[1], "byteOffset" as *u8)
  if bo < 0 { bo = 0 }
  var st: i64 = gls_key_int(buf, ob[0], ob[1], "byteStride" as *u8)
  if st < 0 { st = 0 }
  out[0] = bo
  out[1] = st
  return 1
251}
252// ★locate the FIRST embedded image's bytes in a .glb: out[0]=absolute offset, out[1]=length. 1 ok.
253func gls_image_slice(buf: *u8, size: i64, out: *i64) -> i64 {
  let jsonLen: i64 = gll_ru32(buf, 12)
  let jE: i64 = 20 + jsonLen
  let binStart: i64 = jE + 8
  let ob: *i64 = sys_mmap(16) as *i64
  if gls_arr_obj(buf, jE, "images" as *u8, 0, ob) == 0 { return 0 }
  let bvi: i64 = gls_key_int(buf, ob[0], ob[1], "bufferView" as *u8)
  if bvi < 0 { return 0 }
  if gls_arr_obj(buf, jE, "bufferViews" as *u8, bvi, ob) == 0 { return 0 }
  var bo: i64 = gls_key_int(buf, ob[0], ob[1], "byteOffset" as *u8)
  if bo < 0 { bo = 0 }
  let bl: i64 = gls_key_int(buf, ob[0], ob[1], "byteLength" as *u8)
  if bl <= 0 { return 0 }
  out[0] = binStart + bo
  out[1] = bl
  return 1
269}
270// baseColorFactor -> out r,g,b (0..255). 1 if present (parses decimals like 0.800000011920929, keeps 3 frac digits).
271func gls_basecolor(buf: *u8, jE: i64, out: *i64) -> i64 { return gls_basecolor_in(buf, 0, jE, out) }
272// bounded variant: search only [s, jE) -- one MATERIAL object's bounds (D2 per-primitive colour)
273func gls_basecolor_in(buf: *u8, s: i64, jE: i64, out: *i64) -> i64 {
  var p: i64 = gls_find(buf, jE, s, "baseColorFactor" as *u8)
  if p < 0 { return 0 }
  var ch: i64 = 0
  while ch < 3 {
      var go: i64 = 1
      while go == 1 {
          if p >= jE { go = 0 } else {
              let c: i64 = buf[p] as i64
              var isd: i64 = 0
              if c >= 48 { if c <= 57 { isd = 1 } }
              if isd == 1 { go = 0 } else { p = p + 1 }
          }
      }
      var ip: i64 = 0
      go = 1
      while go == 1 {
          if p >= jE { go = 0 } else {
              let c: i64 = buf[p] as i64
              var isd: i64 = 0
              if c >= 48 { if c <= 57 { isd = 1 } }
              if isd == 1 { ip = ip*10 + (c-48); p = p + 1 } else { go = 0 }
          }
      }
      var milli: i64 = ip * 1000
      var dotp: i64 = 0
      if p < jE { if (buf[p] as i64) == 46 { dotp = 1 } }
      if dotp == 1 {
          p = p + 1
          var fd: i64 = 0
          var mul: i64 = 100
          go = 1
          while go == 1 {
              if p >= jE { go = 0 } else {
                  let c: i64 = buf[p] as i64
                  var isd: i64 = 0
                  if c >= 48 { if c <= 57 { isd = 1 } }
                  if isd == 1 {
                      if fd < 3 { milli = milli + (c-48)*mul; mul = mul/10; fd = fd + 1 }
                      p = p + 1
                  } else { go = 0 }
              }
          }
      }
      if milli > 1000 { milli = 1000 }
      out[ch] = milli * 255 / 1000
      ch = ch + 1
  }
  return 1
322}
323// ★load a REAL .glb (Khronos-conformant): parse primitive/accessors/bufferViews properly, normalize the model to
324// `target` extent centered at origin (integer), per-vertex normals from the file (or recomputed), baseColorFactor.
325func gltf_load_std(path: *u8, target: i64) -> i64 {
  let szp: *i64 = sys_mmap(16) as *i64
  let buf: *u8 = sys_read_file(path, szp)
  let size: i64 = szp[0]
  GLL_WHY = 0
  if (buf as i64) == 0 { return gll_refuse("file-unreadable" as *u8) }
  if size < 20 { return gll_refuse("file-too-short" as *u8) }
  if (buf[0] as i64) != 103 { return gll_refuse("not-glb-magic" as *u8) }
  if (buf[1] as i64) != 108 { return gll_refuse("not-glb-magic" as *u8) }
  if (buf[2] as i64) != 84 { return gll_refuse("not-glb-magic" as *u8) }
  if (buf[3] as i64) != 70 { return gll_refuse("not-glb-magic" as *u8) }
  let jsonLen: i64 = gll_ru32(buf, 12)
  let jE: i64 = 20 + jsonLen
  let binStart: i64 = jE + 8
  if gll_inb(20, jsonLen, size) == 0 { return gll_refuse("json-chunk-oob" as *u8) }
  if binStart > size { return gll_refuse("bin-chunk-missing" as *u8) }
  let pr: *i64 = sys_mmap(16) as *i64
  if gls_arr_obj(buf, jE, "primitives" as *u8, 0, pr) == 0 { return gll_refuse("no-primitives" as *u8) }
  let posA: i64 = gls_key_int(buf, pr[0], pr[1], "POSITION" as *u8)
  let nrmA: i64 = gls_key_int(buf, pr[0], pr[1], "NORMAL" as *u8)
  let uvA: i64 = gls_key_int(buf, pr[0], pr[1], "TEXCOORD_0" as *u8)
  let idxA: i64 = gls_key_int(buf, pr[0], pr[1], "indices" as *u8)
  if posA < 0 { return gll_refuse("no-POSITION-attribute" as *u8) }
  if idxA < 0 { return gll_refuse("no-indices" as *u8) }
  let ac: *i64 = sys_mmap(32) as *i64
  let bv: *i64 = sys_mmap(16) as *i64
  if gls_accessor(buf, jE, posA, ac) == 0 { return gll_refuse("position-accessor-unparsable" as *u8) }
  let NV: i64 = ac[3]
  if NV <= 0 { return gll_refuse("position-count-absent" as *u8) }
  if NV > tm_vcap() { return gll_refuse("mesh-capacity-overflow" as *u8) }
  if gls_bufview(buf, jE, ac[0], bv) == 0 { return gll_refuse("position-bufferview-unparsable" as *u8) }
  let posBase: i64 = binStart + bv[0] + ac[1]
  var posStride: i64 = bv[1]
  if posStride == 0 { posStride = 12 }
  if posStride < 12 { return gll_refuse("position-stride-under-12" as *u8) }
  if gll_inb(posBase, (NV-1)*posStride + 12, size) == 0 { return gll_refuse("position-accessor-oob" as *u8) }
  // pass 1: bbox over raw ints (float x256)
  var minx: i64 = K_MAGIC_2000000000; var miny: i64 = K_MAGIC_2000000000; var minz: i64 = K_MAGIC_2000000000
  var maxx: i64 = 0-K_MAGIC_2000000000; var maxy: i64 = 0-K_MAGIC_2000000000; var maxz: i64 = 0-K_MAGIC_2000000000
  var i: i64 = 0
  while i < NV {
      let x: i64 = gls_f32s(gll_ru32(buf, posBase+i*posStride), 8)
      let y: i64 = gls_f32s(gll_ru32(buf, posBase+i*posStride+4), 8)
      let z: i64 = gls_f32s(gll_ru32(buf, posBase+i*posStride+8), 8)
      if x<minx {minx=x} if x>maxx {maxx=x}
      if y<miny {miny=y} if y>maxy {maxy=y}
      if z<minz {minz=z} if z>maxz {maxz=z}
      i = i + 1
  }
  var ext: i64 = maxx-minx
  if maxy-miny > ext { ext = maxy-miny }
  if maxz-minz > ext { ext = maxz-minz }
  if ext < 1 { ext = 1 }
  let s1024: i64 = target*K_MAGIC_1024/ext
  let cx: i64 = (minx+maxx)/2; let cy: i64 = (miny+maxy)/2; let cz: i64 = (minz+maxz)/2
  // normals accessor (optional)
  var nBase: i64 = 0
  var nStride: i64 = 12
  var hasN: i64 = 0
  if nrmA >= 0 {
      if gls_accessor(buf, jE, nrmA, ac) == 1 {
          if gls_bufview(buf, jE, ac[0], bv) == 1 {
              nBase = binStart + bv[0] + ac[1]
              if bv[1] != 0 { nStride = bv[1] }
              hasN = 1
          }
      }
  }
  if hasN == 1 { if nStride < 12 { return gll_refuse("normal-stride-under-12" as *u8) } }
  if hasN == 1 { if gll_inb(nBase, (NV-1)*nStride + 12, size) == 0 { return gll_refuse("normal-accessor-oob" as *u8) } }
  // UV accessor (optional; Q16)
  var uBase: i64 = 0
  var uStride: i64 = 8
  var hasUV: i64 = 0
  if uvA >= 0 {
      if gls_accessor(buf, jE, uvA, ac) == 1 {
          if gls_bufview(buf, jE, ac[0], bv) == 1 {
              uBase = binStart + bv[0] + ac[1]
              if bv[1] != 0 { uStride = bv[1] }
              hasUV = 1
          }
      }
  }
  if hasUV == 1 { if uStride < 8 { return gll_refuse("uv-stride-under-8" as *u8) } }
  if hasUV == 1 { if gll_inb(uBase, (NV-1)*uStride + 8, size) == 0 { return gll_refuse("uv-accessor-oob" as *u8) } }
  // colour
  let colv: *i64 = sys_mmap(24) as *i64
  var col: i64 = 205 + 205*256 + 205*K_MAGIC_65536
  if gls_basecolor(buf, jE, colv) == 1 { col = colv[0] + colv[1]*256 + colv[2]*K_MAGIC_65536 }
  // pass 2: emit
  tm_reset()
  i = 0
  while i < NV {
      let x: i64 = (gls_f32s(gll_ru32(buf, posBase+i*posStride), 8) - cx)*s1024/K_MAGIC_1024
      let y: i64 = (gls_f32s(gll_ru32(buf, posBase+i*posStride+4), 8) - cy)*s1024/K_MAGIC_1024
      let z: i64 = (gls_f32s(gll_ru32(buf, posBase+i*posStride+8), 8) - cz)*s1024/K_MAGIC_1024
      if hasN == 1 {
          let nx: i64 = gls_f32s(gll_ru32(buf, nBase+i*nStride), 12)
          let ny: i64 = gls_f32s(gll_ru32(buf, nBase+i*nStride+4), 12)
          let nz: i64 = gls_f32s(gll_ru32(buf, nBase+i*nStride+8), 12)
          tm_vert_n(x, y, z, nx, ny, nz)
      } else { tm_vert(x, y, z) }
      tm_vcol(i, col)
      if hasUV == 1 {
          let uu: i64 = gls_f32s(gll_ru32(buf, uBase+i*uStride), 16)
          let vv: i64 = gls_f32s(gll_ru32(buf, uBase+i*uStride+4), 16)
          tm_vuv(i, uu, vv)
      }
      i = i + 1
  }
  // indices
  if gls_accessor(buf, jE, idxA, ac) == 0 { return gll_refuse("index-accessor-unparsable" as *u8) }
  let NI: i64 = ac[3]
  let ctype: i64 = ac[2]
  if gls_bufview(buf, jE, ac[0], bv) == 0 { return gll_refuse("index-bufferview-unparsable" as *u8) }
  let iBase: i64 = binStart + bv[0] + ac[1]
  if NI <= 0 { return gll_refuse("index-count-absent" as *u8) }
  if NI/3 > TM_TCAP { return gll_refuse("mesh-capacity-overflow" as *u8) }
  var isz: i64 = 4
  if ctype == K_MAGIC_5123 { isz = 2 } else { if ctype != K_MAGIC_5125 { return gll_refuse("index-componentType-unsupported" as *u8) } }
  if gll_inb(iBase, NI*isz, size) == 0 { return gll_refuse("index-accessor-oob" as *u8) }
  var t: i64 = 0
  while t < NI/3 {
      var a: i64 = 0
      var b: i64 = 0
      var c: i64 = 0
      if ctype == K_MAGIC_5123 { a = gls_ru16(buf, iBase+(t*3)*2); b = gls_ru16(buf, iBase+(t*3+1)*2); c = gls_ru16(buf, iBase+(t*3+2)*2) }
      else { a = gll_ru32(buf, iBase+(t*3)*4); b = gll_ru32(buf, iBase+(t*3+1)*4); c = gll_ru32(buf, iBase+(t*3+2)*4) }
      if gll_idx3(a, b, c, NV) == 0 { return gll_refuse("index-out-of-range" as *u8) }
      tm_tri(a, b, c, col)
      t = t + 1
  }
  if tm_ovf() != 0 { return gll_refuse("mesh-capacity-overflow" as *u8) }
  if hasN == 0 { tm_compute_normals() }
  return 1
460}
461
462// ================================================================================================================
463// ★D2 DONOR-SCOPE loader (debt 1786545740, 2026-08-12): load EVERY primitive of EVERY mesh, concatenated into
464// one trimesh, with per-primitive material baseColorFactor. Additive: gltf_load_std keeps its contract (first
465// primitive only) for existing callers; whole-file callers use THIS. Same D1 fail-closed law: every JSON-derived
466// offset is bounds-checked and refusals are NAMED (gll_refuse / gltf_load_why). NAMED residue: node world
467// transforms are NOT applied (skinned humanoid meshes share bind space so that donor class assembles correctly);
468// textures + skins are the next rungs. ⚠needle scan takes the FIRST "meshes" occurrence as THE meshes array --
469// an extension key containing 'meshes' appearing earlier would misparse (unobserved in practice).
470const K_MAGIC_PRIMCAP: i64 = 512
471const K_MAGIC_PSTRIDE: i64 = 13
472
473func gltf_load_all(path: *u8, target: i64) -> i64 {
  let szp: *i64 = sys_mmap(16) as *i64
  let buf: *u8 = sys_read_file(path, szp)
  let size: i64 = szp[0]
  GLL_WHY = 0
  if (buf as i64) == 0 { return gll_refuse("file-unreadable" as *u8) }
  if size < 20 { return gll_refuse("file-too-short" as *u8) }
  if (buf[0] as i64) != 103 { return gll_refuse("not-glb-magic" as *u8) }
  if (buf[1] as i64) != 108 { return gll_refuse("not-glb-magic" as *u8) }
  if (buf[2] as i64) != 84 { return gll_refuse("not-glb-magic" as *u8) }
  if (buf[3] as i64) != 70 { return gll_refuse("not-glb-magic" as *u8) }
  let jsonLen: i64 = gll_ru32(buf, 12)
  let jE: i64 = 20 + jsonLen
  let binStart: i64 = jE + 8
  if gll_inb(20, jsonLen, size) == 0 { return gll_refuse("json-chunk-oob" as *u8) }
  if binStart > size { return gll_refuse("bin-chunk-missing" as *u8) }
  let mb: *i64 = sys_mmap(16) as *i64
  let pr: *i64 = sys_mmap(16) as *i64
  let mo: *i64 = sys_mmap(16) as *i64
  let ac: *i64 = sys_mmap(32) as *i64
  let bv: *i64 = sys_mmap(16) as *i64
  let colv: *i64 = sys_mmap(24) as *i64
  let pt: *i64 = sys_mmap(K_MAGIC_PRIMCAP*K_MAGIC_PSTRIDE*8 + 64) as *i64
  var np: i64 = 0
  var mi: i64 = 0
  var moremesh: i64 = 1
  while moremesh == 1 {
      if gls_arr_obj(buf, jE, "meshes" as *u8, mi, mb) == 0 { moremesh = 0 } else {
          var pi: i64 = 0
          var moreprim: i64 = 1
          while moreprim == 1 {
              if gls_arr_obj_from(buf, mb[1], mb[0], "primitives" as *u8, pi, pr) == 0 { moreprim = 0 } else {
                  if np >= K_MAGIC_PRIMCAP { return gll_refuse("primitive-count-over-capacity" as *u8) }
                  let posA: i64 = gls_key_int(buf, pr[0], pr[1], "POSITION" as *u8)
                  let nrmA: i64 = gls_key_int(buf, pr[0], pr[1], "NORMAL" as *u8)
                  let uvA: i64 = gls_key_int(buf, pr[0], pr[1], "TEXCOORD_0" as *u8)
                  let idxA: i64 = gls_key_int(buf, pr[0], pr[1], "indices" as *u8)
                  let matI: i64 = gls_key_int(buf, pr[0], pr[1], "material" as *u8)
                  if posA < 0 { return gll_refuse("no-POSITION-attribute" as *u8) }
                  if idxA < 0 { return gll_refuse("no-indices" as *u8) }
                  if gls_accessor(buf, jE, posA, ac) == 0 { return gll_refuse("position-accessor-unparsable" as *u8) }
                  let NV: i64 = ac[3]
                  if NV <= 0 { return gll_refuse("position-count-absent" as *u8) }
                  if gls_bufview(buf, jE, ac[0], bv) == 0 { return gll_refuse("position-bufferview-unparsable" as *u8) }
                  let posBase: i64 = binStart + bv[0] + ac[1]
                  var posStride: i64 = bv[1]
                  if posStride == 0 { posStride = 12 }
                  if posStride < 12 { return gll_refuse("position-stride-under-12" as *u8) }
                  if gll_inb(posBase, (NV-1)*posStride + 12, size) == 0 { return gll_refuse("position-accessor-oob" as *u8) }
                  var nBase: i64 = 0
                  var nStride: i64 = 12
                  var hasN: i64 = 0
                  if nrmA >= 0 {
                      if gls_accessor(buf, jE, nrmA, ac) == 1 {
                          if gls_bufview(buf, jE, ac[0], bv) == 1 {
                              nBase = binStart + bv[0] + ac[1]
                              if bv[1] != 0 { nStride = bv[1] }
                              hasN = 1
                          }
                      }
                  }
                  if hasN == 1 { if nStride < 12 { return gll_refuse("normal-stride-under-12" as *u8) } }
                  if hasN == 1 { if gll_inb(nBase, (NV-1)*nStride + 12, size) == 0 { return gll_refuse("normal-accessor-oob" as *u8) } }
                  var uBase: i64 = 0
                  var uStride: i64 = 8
                  var hasUV: i64 = 0
                  if uvA >= 0 {
                      if gls_accessor(buf, jE, uvA, ac) == 1 {
                          if gls_bufview(buf, jE, ac[0], bv) == 1 {
                              uBase = binStart + bv[0] + ac[1]
                              if bv[1] != 0 { uStride = bv[1] }
                              hasUV = 1
                          }
                      }
                  }
                  if hasUV == 1 { if uStride < 8 { return gll_refuse("uv-stride-under-8" as *u8) } }
                  if hasUV == 1 { if gll_inb(uBase, (NV-1)*uStride + 8, size) == 0 { return gll_refuse("uv-accessor-oob" as *u8) } }
                  if gls_accessor(buf, jE, idxA, ac) == 0 { return gll_refuse("index-accessor-unparsable" as *u8) }
                  let NI: i64 = ac[3]
                  let ctype: i64 = ac[2]
                  if gls_bufview(buf, jE, ac[0], bv) == 0 { return gll_refuse("index-bufferview-unparsable" as *u8) }
                  let iBase: i64 = binStart + bv[0] + ac[1]
                  if NI <= 0 { return gll_refuse("index-count-absent" as *u8) }
                  var isz: i64 = 4
                  if ctype == K_MAGIC_5123 { isz = 2 } else { if ctype != K_MAGIC_5125 { return gll_refuse("index-componentType-unsupported" as *u8) } }
                  if gll_inb(iBase, NI*isz, size) == 0 { return gll_refuse("index-accessor-oob" as *u8) }
                  var col: i64 = 205 + 205*256 + 205*K_MAGIC_65536
                  if matI >= 0 {
                      if gls_arr_obj(buf, jE, "materials" as *u8, matI, mo) == 1 {
                          if gls_basecolor_in(buf, mo[0], mo[1], colv) == 1 { col = colv[0] + colv[1]*256 + colv[2]*K_MAGIC_65536 }
                      }
                  }
                  let pb: i64 = np*K_MAGIC_PSTRIDE
                  pt[pb] = posBase
                  pt[pb+1] = posStride
                  pt[pb+2] = NV
                  pt[pb+3] = hasN
                  pt[pb+4] = nBase
                  pt[pb+5] = nStride
                  pt[pb+6] = hasUV
                  pt[pb+7] = uBase
                  pt[pb+8] = uStride
                  pt[pb+9] = iBase
                  pt[pb+10] = isz
                  pt[pb+11] = NI
                  pt[pb+12] = col
                  np = np + 1
                  pi = pi + 1
              }
          }
          mi = mi + 1
      }
  }
  if np == 0 { return gll_refuse("no-primitives" as *u8) }
  // capacity BEFORE emit: tm_vcol/tm_vuv take raw indices, so the cap must hold up front
  var sumv: i64 = 0
  var sumt: i64 = 0
  var p1: i64 = 0
  while p1 < np { sumv = sumv + pt[p1*K_MAGIC_PSTRIDE+2]; sumt = sumt + pt[p1*K_MAGIC_PSTRIDE+11]/3; p1 = p1 + 1 }
  if sumv > tm_vcap() { return gll_refuse("mesh-capacity-overflow" as *u8) }
  if sumt > TM_TCAP { return gll_refuse("mesh-capacity-overflow" as *u8) }
  // global bbox across every primitive (float x256 ints)
  var minx: i64 = K_MAGIC_2000000000
  var miny: i64 = K_MAGIC_2000000000
  var minz: i64 = K_MAGIC_2000000000
  var maxx: i64 = 0-K_MAGIC_2000000000
  var maxy: i64 = 0-K_MAGIC_2000000000
  var maxz: i64 = 0-K_MAGIC_2000000000
  var p2: i64 = 0
  while p2 < np {
      let pb2: i64 = p2*K_MAGIC_PSTRIDE
      var i: i64 = 0
      while i < pt[pb2+2] {
          let x: i64 = gls_f32s(gll_ru32(buf, pt[pb2]+i*pt[pb2+1]), 8)
          let y: i64 = gls_f32s(gll_ru32(buf, pt[pb2]+i*pt[pb2+1]+4), 8)
          let z: i64 = gls_f32s(gll_ru32(buf, pt[pb2]+i*pt[pb2+1]+8), 8)
          if x<minx {minx=x} if x>maxx {maxx=x}
          if y<miny {miny=y} if y>maxy {maxy=y}
          if z<minz {minz=z} if z>maxz {maxz=z}
          i = i + 1
      }
      p2 = p2 + 1
  }
  var ext: i64 = maxx-minx
  if maxy-miny > ext { ext = maxy-miny }
  if maxz-minz > ext { ext = maxz-minz }
  if ext < 1 { ext = 1 }
  let s1024: i64 = target*K_MAGIC_1024/ext
  let cx: i64 = (minx+maxx)/2
  let cy: i64 = (miny+maxy)/2
  let cz: i64 = (minz+maxz)/2
  // emit: every primitive appended at a running base offset, per-primitive material colour
  tm_reset()
  var allN: i64 = 1
  var base: i64 = 0
  var p3: i64 = 0
  while p3 < np {
      let pb3: i64 = p3*K_MAGIC_PSTRIDE
      let NV3: i64 = pt[pb3+2]
      var i3: i64 = 0
      while i3 < NV3 {
          let x: i64 = (gls_f32s(gll_ru32(buf, pt[pb3]+i3*pt[pb3+1]), 8) - cx)*s1024/K_MAGIC_1024
          let y: i64 = (gls_f32s(gll_ru32(buf, pt[pb3]+i3*pt[pb3+1]+4), 8) - cy)*s1024/K_MAGIC_1024
          let z: i64 = (gls_f32s(gll_ru32(buf, pt[pb3]+i3*pt[pb3+1]+8), 8) - cz)*s1024/K_MAGIC_1024
          if pt[pb3+3] == 1 {
              let nx: i64 = gls_f32s(gll_ru32(buf, pt[pb3+4]+i3*pt[pb3+5]), 12)
              let ny: i64 = gls_f32s(gll_ru32(buf, pt[pb3+4]+i3*pt[pb3+5]+4), 12)
              let nz: i64 = gls_f32s(gll_ru32(buf, pt[pb3+4]+i3*pt[pb3+5]+8), 12)
              tm_vert_n(x, y, z, nx, ny, nz)
          } else { tm_vert(x, y, z) }
          tm_vcol(base + i3, pt[pb3+12])
          if pt[pb3+6] == 1 {
              let uu: i64 = gls_f32s(gll_ru32(buf, pt[pb3+7]+i3*pt[pb3+8]), 16)
              let vv: i64 = gls_f32s(gll_ru32(buf, pt[pb3+7]+i3*pt[pb3+8]+4), 16)
              tm_vuv(base + i3, uu, vv)
          }
          i3 = i3 + 1
      }
      if pt[pb3+3] == 0 { allN = 0 }
      var t: i64 = 0
      while t < pt[pb3+11]/3 {
          var a: i64 = 0
          var b2: i64 = 0
          var c2: i64 = 0
          if pt[pb3+10] == 2 { a = gls_ru16(buf, pt[pb3+9]+(t*3)*2); b2 = gls_ru16(buf, pt[pb3+9]+(t*3+1)*2); c2 = gls_ru16(buf, pt[pb3+9]+(t*3+2)*2) }
          else { a = gll_ru32(buf, pt[pb3+9]+(t*3)*4); b2 = gll_ru32(buf, pt[pb3+9]+(t*3+1)*4); c2 = gll_ru32(buf, pt[pb3+9]+(t*3+2)*4) }
          if gll_idx3(a, b2, c2, NV3) == 0 { return gll_refuse("index-out-of-range" as *u8) }
          tm_tri(base + a, base + b2, base + c2, pt[pb3+12])
          t = t + 1
      }
      base = base + NV3
      p3 = p3 + 1
  }
  if tm_ovf() != 0 { return gll_refuse("mesh-capacity-overflow" as *u8) }
  if allN == 0 { tm_compute_normals() }
  return 1
669}
670
671// Preservation-first interchange normalization. Existing mesh loaders remain unchanged.
672// This entry point does not convert authored rigs/materials into nx_trimesh or NXA.
673import "nx_compare_openapi.nx"
674import "nx_base64.nx"
675
676func glp_eq(t: *NxJsonTok, key: *u8) -> i64 {
if t.kind != NX_JSON_STRING { return 0 }
let n: i64 = gll_slen(key)
if t.tok_len != n+2 { return 0 }
var i:i64=0
while i<n { if t.src[t.tok_off+1+i]!=key[i] {return 0}; i=i+1 }
return 1
683}
684// out: value start/end, removable member start/end. Refuse escaped identity keys.
685func glp_member(t: *NxJsonTok, key: *u8, out: *i64, states: *u8, cap: i64) -> i64 {
if t.kind!=NX_JSON_LBRACE {return -1}
var previous:i64=-1; var found:i64=0
nx_json_next(t)
while t.kind!=NX_JSON_RBRACE {
if t.kind!=NX_JSON_STRING {return -1}
var k:i64=1
while k<t.tok_len-1 {if t.src[t.tok_off+k]==92 as u8{return -2}; k=k+1}
let start:i64=t.tok_off
let keymatch:i64=glp_eq(t,key)
if nx_json_next(t)!=NX_JSON_COLON{return -1}
nx_json_next(t)
let vs:i64=t.tok_off
let ve:i64=cgo_value_end(t,states,cap)
if ve<0{return -1}
if keymatch==1 {
 if found!=0{return -3}; found=1; out[0]=vs; out[1]=ve
 if previous>=0 {out[2]=previous;out[3]=ve}
 else {out[2]=start;out[3]=ve;if t.kind==NX_JSON_COMMA{out[3]=t.pos}}
}
if t.kind==NX_JSON_RBRACE {break}
if t.kind!=NX_JSON_COMMA{return -1}
previous=t.tok_off;nx_json_next(t)
}
nx_json_next(t)
return found
711}
712func glp_reset(t: *NxJsonTok, src: *u8, n: i64, pos: i64) {
t.src=src;t.len=n;t.pos=pos;nx_json_next(t)
714}
715func glp_u32(out:*u8, at:i64, value:i64) {
var i:i64=0;while i<4 {out[at+i]=((value>>(i*8))&255) as u8;i=i+1}
717}
718// Return complete GLB length or a named negative contract code. Caller owns output.
719// scratch owns tokenizer + spans + grammar stack; wrapper checks allocations and frees them.
720func glp_build(src:*u8,n:i64,out:*u8,cap:i64,t:*NxJsonTok,states:*u8,sp:*i64)->i64 {
glp_reset(t,src,n,0)
if cgo_value_end(t,states,n)<0{return -10}
if t.kind!=NX_JSON_EOF{return -10}
glp_reset(t,src,n,0)
if glp_member(t,"asset" as *u8,sp,states,n)!=1{return -11}
glp_reset(t,src,n,sp[0])
if glp_member(t,"version" as *u8,sp,states,n)!=1{return -11}
glp_reset(t,src,n,sp[0])
if glp_eq(t,"2.0" as *u8)!=1{return -12}
glp_reset(t,src,n,0)
if glp_member(t,"buffers" as *u8,sp,states,n)!=1{return -13}
glp_reset(t,src,n,sp[0])
if t.kind!=NX_JSON_LBRACKET{return -13}
nx_json_next(t)
let bo:i64=t.tok_off
if t.kind!=NX_JSON_LBRACE{return -13}
if cgo_value_end(t,states,n)<0{return -10}
if t.kind!=NX_JSON_RBRACKET{return -14}
glp_reset(t,src,n,bo)
if glp_member(t,"byteLength" as *u8,sp,states,n)!=1{return -15}
glp_reset(t,src,n,sp[0])
if t.kind!=NX_JSON_NUMBER{return -15}
var bn:i64=0;var i:i64=0
while i<t.tok_len {
let c:i64=src[t.tok_off+i] as i64
if c<48{return -15};if c>57{return -15}
if bn>(cap-(c-48))/10{return -16}
bn=bn*10+c-48;i=i+1
}
if bn<=0{return -15}
glp_reset(t,src,n,bo)
if glp_member(t,"uri" as *u8,sp,states,n)!=1{return -17}
let cut0:i64=sp[2];let cut1:i64=sp[3]
glp_reset(t,src,n,sp[0])
if t.kind!=NX_JSON_STRING{return -17}
let uri:*u8=(src as i64+t.tok_off+1) as *u8
let un:i64=t.tok_len-2
var prefix:*u8="data:application/octet-stream;base64," as *u8
var pn:i64=gll_slen(prefix);var same:i64=1;i=0
while i<pn {if i>=un{return -18};if uri[i]!=prefix[i]{same=0};i=i+1}
if same==0 {
prefix="data:application/gltf-buffer;base64," as *u8;pn=gll_slen(prefix);i=0
while i<pn {if i>=un{return -18};if uri[i]!=prefix[i]{return -18};i=i+1}
}
let encoded:i64=un-pn
if encoded!=((bn+2)/3)*4{return -19}
let jn:i64=n-(cut1-cut0)
let jp:i64=gll_align4(jn);let bp:i64=gll_align4(bn)
if jp>cap-28{return -16};if bp>cap-28-jp{return -16}
let total:i64=28+jp+bp
if total>4294967295{return -16}
// Canonical roundtrip checks every input byte, including padding and trailing garbage.
let bin:*u8=(out as i64+28+jp) as *u8
let decoded:*u8=sys_mmap(encoded)
if (decoded as i64)<=0{return -20}
if b64_decode((uri as i64+pn) as *u8,encoded,decoded)!=bn{sys_munmap(decoded,encoded);return -19}
let check:*u8=sys_mmap(encoded)
if (check as i64)<=0{sys_munmap(decoded,encoded);return -20}
let en:i64=b64_encode(decoded,bn,check);var valid:i64=1;i=0
while i<encoded {if check[i]!=uri[pn+i]{valid=0};i=i+1}
sys_munmap(check,encoded)
if valid==0{sys_munmap(decoded,encoded);return -19};if en!=encoded{sys_munmap(decoded,encoded);return -19}
i=0;while i<bn{bin[i]=decoded[i];i=i+1};sys_munmap(decoded,encoded)
glp_u32(out,0,1179937895);glp_u32(out,4,2);glp_u32(out,8,total)
glp_u32(out,12,jp);glp_u32(out,16,1313821514)
var o:i64=cgo_copy(out,cap,20,src,0,cut0)
o=cgo_copy(out,cap,o,src,cut1,n)
if o<0{return -16}
while o<20+jp {out[o]=32 as u8;o=o+1}
glp_u32(out,20+jp,bp);glp_u32(out,24+jp,5130562)
i=bn;while i<bp{bin[i]=0 as u8;i=i+1}
return total
793}
794func gltf_json_to_glb(src:*u8,n:i64,out:*u8,cap:i64)->i64 {
if (src as i64)<=0{return -1};if n<=0{return -1}
if (out as i64)<=0{return -1};if cap<28{return -1}
if n>cap{return -16}
if cap>4294967295{return -16}
if (out as i64)<(src as i64)+n {if (src as i64)<(out as i64)+cap{return -1}}
let states:*u8=sys_mmap(n)
if (states as i64)<=0{return -20}
let t:*NxJsonTok=nx_json_new(src,n)
if (t as i64)<=0{sys_munmap(states,n);return -20}
let sp:*i64=sys_mmap(32) as *i64
if (sp as i64)<=0{sys_munmap(states,n);sys_munmap(t as *u8,NX_JSONTOK_BYTES);return -20}
let result:i64=glp_build(src,n,out,cap,t,states,sp)
sys_munmap(sp as *u8,32);sys_munmap(t as *u8,NX_JSONTOK_BYTES);sys_munmap(states,n)
return result
809}
810
811// Read-only GLB structural inventory. All authored JSON survives in the report;
812// this is not accessor decoding, unit inference, or rendering qualification.
813const GLI_STATS_WORDS:i64=34
814const GLI_CONTEXT_WORDS:i64=6
815func gli_name(i:i64)->*u8 {
if i==4{return "scenes"};if i==5{return "nodes"};if i==6{return "meshes"}
if i==7{return "materials"};if i==8{return "skins"};if i==9{return "animations"}
if i==10{return "accessors"};if i==11{return "images"};if i==12{return "textures"}
if i==13{return "buffers"};if i==14{return "bufferViews"};if i==15{return "samplers"}
if i==16{return "cameras"};if i==17{return "primitives"};if i==18{return "morph_target_records"}
if i==19{return "meshes_with_morph_targets"};if i==20{return "skin_joint_references"}
if i==21{return "animation_channels"};if i==22{return "translation_channels"}
if i==23{return "rotation_channels"};if i==24{return "scale_channels"}
if i==25{return "weights_channels"};if i==26{return "other_target_paths"}
if i==27{return "nodes_with_matrix"};if i==28{return "nodes_with_translation"}
if i==29{return "nodes_with_rotation"};if i==30{return "nodes_with_scale"}
if i==31{return "meshes_with_weights"};if i==32{return "nodes_with_weights"}
return "unknown_glb_chunks"
829}
830func gli_member(cx:*i64,parent:i64,key:*u8)->i64 {
let t:*NxJsonTok=cx[2] as *NxJsonTok
glp_reset(t,cx[0] as *u8,cx[1],parent)
return glp_member(t,key,cx[4] as *i64,cx[3] as *u8,cx[1])
834}
835func gli_present(cx:*i64,parent:i64,key:*u8,slot:i64)->i64 {
let have:i64=gli_member(cx,parent,key)
if have<0{return -1}
if have==1 {let counts:*i64=cx[5] as *i64;counts[slot]=counts[slot]+1}
return 0
840}
841// mode: 0 scalar/object count, 1 mesh, 2 primitive, 3 skin, 4 animation,
842// 5 animation channel, 6 node. No fixed item table or silent truncation.
843func gli_array(cx:*i64,parent:i64,key:*u8,mode:i64)->i64 {
let have:i64=gli_member(cx,parent,key)
if have<0{return -1};if have==0{return 0}
let t:*NxJsonTok=cx[2] as *NxJsonTok;let sp:*i64=cx[4] as *i64
let counts:*i64=cx[5] as *i64
glp_reset(t,cx[0] as *u8,cx[1],sp[0])
if t.kind!=NX_JSON_LBRACKET{return -1}
nx_json_next(t);var count:i64=0
while t.kind!=NX_JSON_RBRACKET {
let start:i64=t.tok_off
if mode>0 {if t.kind!=NX_JSON_LBRACE{return -1}}
let end:i64=cgo_value_end(t,cx[3] as *u8,cx[1])
if end<0{return -1}
if mode==1 {
 let before:i64=counts[18]
 let np:i64=gli_array(cx,start,"primitives",2)
 if np<0{return -1};counts[17]=counts[17]+np
 if counts[18]>before {counts[19]=counts[19]+1}
 if gli_present(cx,start,"weights",31)<0{return -1}
}
if mode==2 {let nt:i64=gli_array(cx,start,"targets",0);if nt<0{return -1};counts[18]=counts[18]+nt}
if mode==3 {let nj:i64=gli_array(cx,start,"joints",0);if nj<0{return -1};counts[20]=counts[20]+nj}
if mode==4 {let nc:i64=gli_array(cx,start,"channels",5);if nc<0{return -1};counts[21]=counts[21]+nc}
if mode==5 {
 let ht:i64=gli_member(cx,start,"target")
 if ht!=1{return -1}
 let target:i64=sp[0]
 if gli_member(cx,target,"path")!=1{return -1}
 glp_reset(t,cx[0] as *u8,cx[1],sp[0])
 if t.kind!=NX_JSON_STRING{return -1}
 var slot:i64=26
 if glp_eq(t,"translation")==1{slot=22}
 if glp_eq(t,"rotation")==1{slot=23}
 if glp_eq(t,"scale")==1{slot=24}
 if glp_eq(t,"weights")==1{slot=25}
 counts[slot]=counts[slot]+1
}
if mode==6 {
 if gli_present(cx,start,"matrix",27)<0{return -1}
 if gli_present(cx,start,"translation",28)<0{return -1}
 if gli_present(cx,start,"rotation",29)<0{return -1}
 if gli_present(cx,start,"scale",30)<0{return -1}
 if gli_present(cx,start,"weights",32)<0{return -1}
}
count=count+1;glp_reset(t,cx[0] as *u8,cx[1],end)
if t.kind==NX_JSON_RBRACKET{break}
if t.kind!=NX_JSON_COMMA{return -1};nx_json_next(t)
}
return count
892}
893// stats0 JSON offset,1 JSON length,2 BIN bytes,3 chunks,4..33 counts.
894func gltf_inventory_glb(src:*u8,n:i64,stats:*i64)->i64 {
if (src as i64)<=0 || (stats as i64)<=0 || n<20{return -1}
var z:i64=0;while z<GLI_STATS_WORDS{stats[z]=0;z=z+1}
if gll_ru32(src,0)!=0x46546c67 || gll_ru32(src,4)!=2 || gll_ru32(src,8)!=n{return -2}
var off:i64=12;var bins:i64=0
while off<n {
if n-off<8{return -3}
let size:i64=gll_ru32(src,off);let kind:i64=gll_ru32(src,off+4)
if size%4!=0 || size>n-off-8{return -3}
if stats[3]==0 && kind!=0x4e4f534a{return -4}
if kind==0x4e4f534a {
 if stats[0]!=0{return -4};stats[0]=off+8;stats[1]=size
} else {if kind==0x004e4942 {bins=bins+1;if bins>1 || stats[3]!=1{return -4};stats[2]=size} else {stats[33]=stats[33]+1}}
stats[3]=stats[3]+1;off=off+8+size
}
if stats[0]==0 || stats[1]<=0{return -4}
let json:*u8=(src as i64+stats[0]) as *u8;let jn:i64=stats[1]
let states:*u8=sys_mmap(jn);let t:*NxJsonTok=nx_json_new(json,jn)
let sp:*i64=sys_mmap(32) as *i64;let cx:*i64=sys_mmap(GLI_CONTEXT_WORDS*8) as *i64
var rc:i64=-7
if (states as i64)>0 && (t as i64)>0 && (sp as i64)>0 && (cx as i64)>0 {
rc=-5;glp_reset(t,json,jn,0)
if t.kind==NX_JSON_LBRACE {
 let end:i64=cgo_value_end(t,states,jn)
 if end>0 && t.kind==NX_JSON_EOF {
  cx[0]=json as i64;cx[1]=jn;cx[2]=t as i64;cx[3]=states as i64;cx[4]=sp as i64;cx[5]=stats as i64
  rc=0;var i:i64=4
  while i<=16 {
   var mode:i64=0
   if i==5{mode=6};if i==6{mode=1};if i==8{mode=3};if i==9{mode=4}
   let count:i64=gli_array(cx,0,gli_name(i),mode)
   if count<0{rc=-6;break};stats[i]=count;i=i+1
  }
 }
}
}
if (cx as i64)>0{sys_munmap(cx as *u8,GLI_CONTEXT_WORDS*8)}
if (sp as i64)>0{sys_munmap(sp as *u8,32)}
if (t as i64)>0{sys_munmap(t as *u8,NX_JSONTOK_BYTES)}
if (states as i64)>0{sys_munmap(states,jn)}
return rc
935}
nx_gltf_load_inventory_t180.nx source

`nx_gltf_load_inventory_t180.nx` source
