`nx_gltf_load.nx` source

↩ module page · 390 lines · 16421 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
14
15// IEEE-754 float32 bit pattern -> integer (inverse of gl_f32bits; exact for the integer coordinates we export)
16func 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
29}
30func gll_ru8(buf: *u8, at: i64) -> i64 { return buf[at] as i64 }
31func 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) }
32func gll_align4(x: i64) -> i64 { return (x+3)/4*4 }
33func gll_slen(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} return n }
34// find the n-th integer that follows `needle` within buf[start,end)
35func 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
58}
59
60// load a .glb file into the trimesh buffers. returns 1 on success, 0 on failure. base_col used where colours absent.
61func 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]
  if (buf as i64) == 0 { return 0 }
  if size < 20 { return 0 }
  if (buf[0] as i64) != 103 { return 0 }        // 'g'
  if (buf[1] as i64) != 108 { return 0 }        // 'l'
  if (buf[2] as i64) != 84 { return 0 }         // 'T'
  if (buf[3] as i64) != 70 { return 0 }         // 'F'
  let jsonLen: i64 = gll_ru32(buf, 12)
  let jsonStart: i64 = 20
  let binStart: i64 = 20 + jsonLen + 8
  // 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 0 }
  if NI <= 0 { return 0 }
  // 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
  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)
      tm_tri(a, b, c, 200+200*256+200*K_MAGIC_65536)
      t = t + 1
  }
  tm_compute_normals()
  return 1
107}
108
109// ================================================================================================================
110// ★STANDARD-glTF loader (2026-07-11, the graphics-MSU rung): parse REAL third-party .glb (Khronos conformance
111// assets), not just our own exporter's layout -- proper JSON accessor/bufferView walking (byteOffset defaults,
112// byteStride, u16/u32 indices, float32 positions/normals, baseColorFactor). Needles searched WITHOUT quote chars
113// (avoids the "-in-literal hazard); slices keep keys unambiguous. license part of nx_gltf_load. ==================
114func gls_ru16(buf: *u8, at: i64) -> i64 { return (buf[at] as i64) + ((buf[at+1] as i64)<<8) }
115// float32 bits -> integer of (value * 2^k) by exponent shift; zero-guarded.
116func gls_f32s(bits: i64, k: i64) -> i64 { if (bits & K_MAGIC_2147483647) == 0 { return 0 } return gll_f32i(bits + (k<<23)) }
117func 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
127}
128// integer value right after `key` (skips to ':', then spaces). -1 if absent in [s,e).
129func 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
152}
153// bounds of the k-th object in the JSON array named `arrName`: out[0]=pos of '{', out[1]=pos after matching '}'.
154func gls_arr_obj(buf: *u8, end: i64, arrName: *u8, k: i64, out: *i64) -> i64 {
  let an: i64 = gls_find(buf, end, 0, 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
179}
180// accessor A -> out: [bufferView, accessorByteOffset, componentType, count]
181func 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
193}
194// bufferView B -> out: [byteOffset, byteStride]
195func 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
205}
206// ★locate the FIRST embedded image's bytes in a .glb: out[0]=absolute offset, out[1]=length. 1 ok.
207func 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
223}
224// baseColorFactor -> out r,g,b (0..255). 1 if present (parses decimals like 0.800000011920929, keeps 3 frac digits).
225func gls_basecolor(buf: *u8, jE: i64, out: *i64) -> i64 {
  var p: i64 = gls_find(buf, jE, 0, "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
      if (buf[p] as i64) == 46 {
          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
272}
273// ★load a REAL .glb (Khronos-conformant): parse primitive/accessors/bufferViews properly, normalize the model to
274// `target` extent centered at origin (integer), per-vertex normals from the file (or recomputed), baseColorFactor.
275func 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]
  if (buf as i64) == 0 { return 0 }
  if size < 20 { return 0 }
  if (buf[0] as i64) != 103 { return 0 }
  let jsonLen: i64 = gll_ru32(buf, 12)
  let jE: i64 = 20 + jsonLen
  let binStart: i64 = jE + 8
  let pr: *i64 = sys_mmap(16) as *i64
  if gls_arr_obj(buf, jE, "primitives" as *u8, 0, pr) == 0 { return 0 }
  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 0 }
  if idxA < 0 { return 0 }
  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 0 }
  let NV: i64 = ac[3]
  if NV <= 0 { return 0 }
  if gls_bufview(buf, jE, ac[0], bv) == 0 { return 0 }
  let posBase: i64 = binStart + bv[0] + ac[1]
  var posStride: i64 = bv[1]
  if posStride == 0 { posStride = 12 }
  // 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
          }
      }
  }
  // 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
          }
      }
  }
  // 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 0 }
  let NI: i64 = ac[3]
  let ctype: i64 = ac[2]
  if gls_bufview(buf, jE, ac[0], bv) == 0 { return 0 }
  let iBase: i64 = binStart + bv[0] + ac[1]
  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) }
      tm_tri(a, b, c, col)
      t = t + 1
  }
  if hasN == 0 { tm_compute_normals() }
  return 1
390}
nx_gltf_load.nx source

`nx_gltf_load.nx` source
