`nx_mesh_view.nx` source

↩ module page · 274 lines · 11343 B
1// nx_mesh_view.nx -- SOVEREIGN full-detail mesh renderer: loads a .nxmesh (every vertex, every
2// triangle -- the 1:1 capture of the reference model) and software-rasterizes it to PNG with a
3// z-buffer, barycentric depth, and two-light lambert. This is the proof the sovereign pipeline
4// CARRIES reference-class detail: 28k triangles, not 30 primitives.
5// usage: nx_mesh_view <in.nxmesh> <out.png> [yaw_deg]
6// license_tier: ORIGINAL
7import "nx_syscalls.nx"
8import "nx_itrig.nx"
9import "nx_png_write.nx"
10import "nx_nxa.nx"
11const MV_MAGIC_1314016334: i64 = 1314016334
12const MV_MAGIC_4611686018427387903: i64 = 4611686018427387903
13const MV_MAGIC_4096: i64 = 4096
14
15const MV_W: i64 = 640
16const MV_H: i64 = 1024
17
18func mvw(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
19func mvn(v: i64) -> i64 {
  let t: *u8 = sys_mmap(32) as *u8
  var m: i64 = v; var w: i64 = 0
  if m<0 { t[w]=45 as u8; w=w+1; m=0-m }
  if m==0 { t[w]=48 as u8; sys_write(1,t,w+1); return 0 }
  let d: *u8 = sys_mmap(32) as *u8
  var k: i64=0
  while m>0 { d[k]=(48+(m%10)) as u8; m=m/10; k=k+1 }
  var j: i64=0
  while j<k { t[w]=d[k-1-j]; w=w+1; j=j+1 }
  sys_write(1,t,w); return 0
30}
31func mv_isqrt(v: i64) -> i64 {
  if v <= 0 { return 0 }
  var x: i64 = v
  var y: i64 = (x + 1) / 2
  var g: i64 = 0
  while g < 40 { if y < x { x = y; y = (x + v/x)/2 } g = g + 1 }
  return x
38}
39func mv_min3(a: i64, b: i64, c: i64) -> i64 { var m: i64 = a; if b < m { m = b } if c < m { m = c } return m }
40func mv_max3(a: i64, b: i64, c: i64) -> i64 { var m: i64 = a; if b > m { m = b } if c > m { m = c } return m }
41
42func main(argc: i64, argv: *i64) -> i64 {
  if argc < 3 { mvw("usage: nx_mesh_view <in.nxmesh> <out.png> [yaw_deg]\n" as *u8); return 2 }
  var yawdeg: i64 = 20
  if argc >= 4 {
      let a3: *u8 = argv[3] as *u8
      yawdeg = 0
      var q: i64 = 0
      while a3[q] != (0 as u8) { yawdeg = yawdeg*10 + ((a3[q] & 0xff) as i64) - 48; q = q + 1 }
  }
  let lp: *i64 = sys_mmap(16) as *i64
  let b: *u8 = sys_map_file(argv[1] as *u8, lp)
  if lp[0] < 24 { mvw("unreadable\n" as *u8); return 3 }
  let hdr: *i64 = b as *i64
  var nv: i64 = 0
  var nt: i64 = 0
  var vx: *i64 = 0 as *i64
  var tr: *i64 = 0 as *i64
  if hdr[0] == MV_MAGIC_1314016334 {
      // legacy .nxmesh v0 (additive-only: old artifacts keep rendering)
      nv = hdr[1]
      nt = hdr[2]
      vx = ((b as i64) + 24) as *i64
      tr = ((b as i64) + 24 + nv*24) as *i64
  }
  if hdr[0] == nxa_magic() {
      let vwo: i64 = nxa_find(b, lp[0], nxa_tag4("VERT" as *u8))
      if vwo == 0 - 2 { mvw("NXA-FUTURE-VERSION: refusing\n" as *u8); return 6 }
      if vwo < 0 { mvw("NXA-CORRUPT: refusing\n" as *u8); return 5 }
      let two: i64 = nxa_find(b, lp[0], nxa_tag4("TRIS" as *u8))
      if two < 0 { mvw("NXA-CORRUPT: refusing\n" as *u8); return 5 }
      nv = hdr[vwo]
      nt = hdr[two]
      vx = ((b as i64) + vwo*8 + 8) as *i64
      tr = ((b as i64) + two*8 + 8) as *i64
  }
  if nv < 3 { mvw("bad magic\n" as *u8); return 4 }
  mvw("verts=" as *u8); mvn(nv); mvw(" tris=" as *u8); mvn(nt); mvw("\n" as *u8)
  // bounds (fbx z-up: x=lat, y=depth, z=up)
  var mnx: i64 = MV_MAGIC_4611686018427387903
  var mxx: i64 = 0 - mnx
  var mny: i64 = mnx
  var mxy: i64 = 0 - mnx
  var mnz: i64 = mnx
  var mxz: i64 = 0 - mnx
  var i: i64 = 0
  while i < nv {
      let X: i64 = vx[i*3]
      let Y: i64 = vx[i*3+1]
      let Z: i64 = vx[i*3+2]
      if X < mnx { mnx = X } if X > mxx { mxx = X }
      if Y < mny { mny = Y } if Y > mxy { mxy = Y }
      if Z < mnz { mnz = Z } if Z > mxz { mxz = Z }
      i = i + 1
  }
  // UP-AXIS AUTO-DETECT (parity with the browser viewer and fm_measure): a standing body's
  // largest extent IS its up axis; lat = larger of the rest. FBX files arrive both z-up and
  // y-up -- assuming z-up framed the y-up 2M-tri model as a lying close-up.
  let exv: *i64 = sys_mmap(64) as *i64
  exv[0] = mxx - mnx
  exv[1] = mxy - mny
  exv[2] = mxz - mnz
  var iu: i64 = 0
  if exv[1] > exv[iu] { iu = 1 }
  if exv[2] > exv[iu] { iu = 2 }
  var il: i64 = 0
  if iu == 0 { il = 1 }
  let io0: i64 = 3 - iu - il
  if exv[io0] > exv[il] { il = io0 }
  let io: i64 = 3 - iu - il
  let mnv: *i64 = sys_mmap(64) as *i64
  mnv[0] = mnx
  mnv[1] = mny
  mnv[2] = mnz
  let mxv: *i64 = sys_mmap(64) as *i64
  mxv[0] = mxx
  mxv[1] = mxy
  mxv[2] = mxz
  let H: i64 = exv[iu]
  let cx: i64 = (mnv[il] + mxv[il])/2
  let cy: i64 = (mnv[io] + mxv[io])/2
  // yaw the model around the up axis so the view angle is a parameter
  let ya: i64 = yawdeg * IT_PI / 180
  let sy: i64 = it_sin4096(ya)
  let cyw: i64 = it_cos4096(ya)
  // scale: fit height to 94% of canvas
  let scale_n: i64 = MV_H * 94 / 100
  let fb: *i64 = sys_mmap(MV_W*MV_H*8) as *i64
  let zb: *i64 = sys_mmap(MV_W*MV_H*8) as *i64
  var p0: i64 = 0
  while p0 < MV_W*MV_H {
      let g: i64 = 26 + p0/(MV_W*MV_H/14)
      fb[p0] = g | ((g+4) << 8) | ((g+10) << 16)
      zb[p0] = 0 - MV_MAGIC_4611686018427387903
      p0 = p0 + 1
  }
  // screen coords per vertex (mm -> px), rotated: xr = (x-cx)*cos + (y-cy)*sin; depth = -(x-cx)*sin + (y-cy)*cos
  let sxp: *i64 = sys_mmap(nv*8) as *i64
  let syp: *i64 = sys_mmap(nv*8) as *i64
  let szp: *i64 = sys_mmap(nv*8) as *i64
  var i2: i64 = 0
  while i2 < nv {
      let rx: i64 = ((vx[i2*3+il] - cx)*cyw + (vx[i2*3+io] - cy)*sy)/MV_MAGIC_4096
      let rd: i64 = (0 - (vx[i2*3+il] - cx)*sy + (vx[i2*3+io] - cy)*cyw)/MV_MAGIC_4096
      sxp[i2] = MV_W/2 + rx*scale_n/H
      syp[i2] = MV_H - (MV_H - scale_n)/2 - (vx[i2*3+iu] - mnv[iu])*scale_n/H
      szp[i2] = rd
      i2 = i2 + 1
  }
  // rasterize with barycentric z; two lights (key upper-left-front, fill right)
  var t: i64 = 0
  var drawn: i64 = 0
  while t < nt {
      let a: i64 = tr[t*3]
      let bb: i64 = tr[t*3+1]
      let c: i64 = tr[t*3+2]
      let x0: i64 = sxp[a]
      let y0: i64 = syp[a]
      let x1: i64 = sxp[bb]
      let y1: i64 = syp[bb]
      let x2: i64 = sxp[c]
      let y2: i64 = syp[c]
      let area: i64 = (x1-x0)*(y2-y0) - (x2-x0)*(y1-y0)
      if area != 0 {
          // world-space normal for lighting (mm coords, rotated frame)
          let e1x: i64 = (vx[bb*3]-vx[a*3])
          let e1y: i64 = (vx[bb*3+1]-vx[a*3+1])
          let e1z: i64 = (vx[bb*3+2]-vx[a*3+2])
          let e2x: i64 = (vx[c*3]-vx[a*3])
          let e2y: i64 = (vx[c*3+1]-vx[a*3+1])
          let e2z: i64 = (vx[c*3+2]-vx[a*3+2])
          var nxv: i64 = e1y*e2z - e1z*e2y
          var nyv: i64 = e1z*e2x - e1x*e2z
          var nzv: i64 = e1x*e2y - e1y*e2x
          let nl: i64 = mv_isqrt(nxv*nxv/256 + nyv*nyv/256 + nzv*nzv/256)*16
          if nl > 0 {
              nxv = nxv*1000/nl
              nyv = nyv*1000/nl
              nzv = nzv*1000/nl
              // key light dir ~ (-.4,-.75,.53) front-upper-left (y = toward viewer at yaw 0)
              var lam: i64 = (0-400)*nxv + (0-750)*nyv + 530*nzv
              if lam < 0 { lam = 0 - lam }                 // double-sided (raw scan meshes flip)
              lam = lam/1000
              var lit: i64 = 300 + lam*720/1000
              if lit > 1000 { lit = 1000 }
              let rr: i64 = 236*lit/1000
              let gg: i64 = 196*lit/1000
              let bl: i64 = 172*lit/1000
              let col: i64 = rr | (gg << 8) | (bl << 16)
              var miny: i64 = mv_min3(y0, y1, y2)
              var maxy: i64 = mv_max3(y0, y1, y2)
              var minx: i64 = mv_min3(x0, x1, x2)
              var maxx: i64 = mv_max3(x0, x1, x2)
              if miny < 0 { miny = 0 }
              if minx < 0 { minx = 0 }
              if maxy > MV_H-1 { maxy = MV_H-1 }
              if maxx > MV_W-1 { maxx = MV_W-1 }
              var py: i64 = miny
              while py <= maxy {
                  var px: i64 = minx
                  while px <= maxx {
                      let w0: i64 = (x1-px)*(y2-py) - (x2-px)*(y1-py)
                      let w1: i64 = (x2-px)*(y0-py) - (x0-px)*(y2-py)
                      let w2: i64 = (x0-px)*(y1-py) - (x1-px)*(y0-py)
                      var inside: i64 = 0
                      if w0 >= 0 { if w1 >= 0 { if w2 >= 0 { inside = 1 } } }
                      if w0 <= 0 { if w1 <= 0 { if w2 <= 0 { inside = 1 } } }
                      if inside == 1 {
                          let z: i64 = (w0*szp[a] + w1*szp[bb] + w2*szp[c]) / area
                          let o: i64 = py*MV_W + px
                          if z > zb[o] {
                              zb[o] = z
                              fb[o] = col
                          }
                      }
                      px = px + 1
                  }
                  py = py + 1
              }
              drawn = drawn + 1
          }
      }
      t = t + 1
  }
  mvw("drawn=" as *u8); mvn(drawn); mvw("\n" as *u8)
  // SKELETON OVERLAY: if SKEL is present, draw bones (parent->joint) as bright segments
  // through the SAME projection -- the proof that binds share the mesh's space: a coherent
  // armature INSIDE the figure, or the import is wrong.
  let swo: i64 = nxa_find(b, lp[0], nxa_tag4("SKEL" as *u8))
  if swo >= 0 {
      let njj: i64 = hdr[swo]
      let sk: *i64 = ((b as i64) + swo*8 + 8) as *i64
      var jb: i64 = 0
      var bones: i64 = 0
      while jb < njj {
          let par: i64 = sk[jb*8]
          if par >= 0 {
              // project both ends with the same axis permutation + yaw
              var seg: i64 = 0
              while seg <= 100 {
                  let bx3: i64 = (sk[par*8+1]*(100-seg) + sk[jb*8+1]*seg)/100
                  let by3: i64 = (sk[par*8+2]*(100-seg) + sk[jb*8+2]*seg)/100
                  let bz3: i64 = (sk[par*8+3]*(100-seg) + sk[jb*8+3]*seg)/100
                  let co: *i64 = sys_mmap(32) as *i64
                  co[0] = bx3
                  co[1] = by3
                  co[2] = bz3
                  let rx2: i64 = ((co[il] - cx)*cyw + (co[io] - cy)*sy)/MV_MAGIC_4096
                  let px3: i64 = MV_W/2 + rx2*scale_n/H
                  let py3: i64 = MV_H - (MV_H - scale_n)/2 - (co[iu] - mnv[iu])*scale_n/H
                  if px3 >= 1 { if px3 < MV_W-1 { if py3 >= 1 { if py3 < MV_H-1 {
                      fb[py3*MV_W + px3] = 60 | (255 << 8) | (120 << 16)
                      fb[py3*MV_W + px3 + 1] = 60 | (255 << 8) | (120 << 16)
                  } } } }
                  seg = seg + 1
              }
              bones = bones + 1
          }
          jb = jb + 1
      }
      mvw("bones=" as *u8); mvn(bones); mvw("\n" as *u8)
  }
  let rgb: *u8 = sys_mmap(MV_W*MV_H*3) as *u8
  var p2: i64 = 0
  while p2 < MV_W*MV_H {
      rgb[p2*3] = (fb[p2] & 255) as u8
      rgb[p2*3+1] = ((fb[p2] >> 8) & 255) as u8
      rgb[p2*3+2] = ((fb[p2] >> 16) & 255) as u8
      p2 = p2 + 1
  }
  nx_png_write_rgb(argv[2] as *u8, rgb, MV_W, MV_H)
  mvw("PNG written\n" as *u8)
  return 0
274}
nx_mesh_view.nx source

`nx_mesh_view.nx` source
