code wiki / _hdl_build / nx_explodelab_meshgen.nx
`nx_explodelab_meshgen.nx` source

↩ module page · 361 lines · 12863 B
1// nx_explodelab_meshgen.nx -- GENERATOR: bake the REAL 53/53 file-true part meshes into a compiled data module
2// for the /explodelab viewer (build-generators-not-artifacts doctrine). Parses as1 -> per-part v2 tessellation
3// (nx_cadtwin_report pipeline: attribution + planar/NURBS + weld) -> CENTERS each part at its own origin and
4// scales fx256 -> world units (/8 = 32 units/mm; rod ±3200, plate ±2880 -- fits the viewer's existing ~3400
5// camera scale) -> emits runtime/nx_explodelab_meshes.nx: exm_load(e,kind,col) writing ex3_vert/ex3_tri (tri
6// indices offset by the captured e[1] base), chunked <=200 emissions/function (compiler-safe), plus
7// exm_counts(kind) and exm_dims(kind) = TRUE mm dims + thou (via nx_unitconv, baked). Display quantization:
8// /8 truncation <= 31um -- labels carry the TRUE fx256 dims, the mesh is display-only. Kinds: 1 nut, 2 bolt,
9// 3 rod, 4 plate, 5 l-bracket. expect_exit: 0  license_tier: ORIGINAL
10import "nx_cadtwin_report.nx"
11import "nx_step_write.nx"
12const K_MAGIC_4194304: i64 = 4194304
13const K_MAGIC_524288: i64 = 524288
14const K_MAGIC_8192: i64 = 8192
15const K_MAGIC_4096: i64 = 4096
16const K_MAGIC_1024: i64 = 1024
17const K_MAGIC_20480: i64 = 20480
18
19// emit a signed constant as a wasm-safe term: "N" or "(0 - N)"
20func mg_term(b: *i64, v: i64) -> i64 {
  if v >= 0 { swb_n(b, v); return 0 }
  swb_s(b, "(0 - " as *u8)
  swb_n(b, 0 - v)
  swb_s(b, ")" as *u8)
  return 0
26}
27
28// emit one part's mesh as chunked functions; returns tri count. names: exm_k<K>_v<N> / exm_k<K>_t<N> / exm_k<K>.
29// Loaders take the instance CENTER (cx,cy,cz world units) -- ex3 verts are ABSOLUTE assembled coords (pose adds
30// displacement only), matching the mp_* convention they replace.
31func mg_part(b: *i64, mesh: i64, kind: i64, cx3: *i64) -> i64 {
  let h: *i64 = m3_hdr(mesh)
  let nv: i64 = h[0]
  let ntr: i64 = h[1]
  // vert chunks
  var chunk: i64 = 0
  var i: i64 = 0
  while i < nv {
      swb_s(b, "func exm_k" as *u8)
      swb_n(b, kind)
      swb_s(b, "_v" as *u8)
      swb_n(b, chunk)
      swb_s(b, "(e: *i64, cx: i64, cy: i64, cz: i64, col: i64) -> i64 " as *u8)
      swb_c(b, 123)
      swb_c(b, 10)
      var e2: i64 = i + 200
      if e2 > nv { e2 = nv }
      while i < e2 {
          let v: *i64 = m3_vert(mesh, i)
          swb_s(b, "    ex3_vert(e, cx + " as *u8)
          mg_term(b, (v[0] - cx3[0]) / 8)
          swb_s(b, ", cy + " as *u8)
          mg_term(b, (v[1] - cx3[1]) / 8)
          swb_s(b, ", cz + " as *u8)
          mg_term(b, (v[2] - cx3[2]) / 8)
          swb_s(b, ", col)" as *u8)
          swb_c(b, 10)
          i = i + 1
      }
      swb_s(b, "    return 0" as *u8)
      swb_c(b, 10)
      swb_c(b, 125)
      swb_c(b, 10)
      chunk = chunk + 1
  }
  let vchunks: i64 = chunk
  // tri chunks (indices offset by b0)
  chunk = 0
  var t: i64 = 0
  while t < ntr {
      swb_s(b, "func exm_k" as *u8)
      swb_n(b, kind)
      swb_s(b, "_t" as *u8)
      swb_n(b, chunk)
      swb_s(b, "(e: *i64, b0: i64) -> i64 " as *u8)
      swb_c(b, 123)
      swb_c(b, 10)
      var e3: i64 = t + 200
      if e3 > ntr { e3 = ntr }
      while t < e3 {
          let tr: *i64 = m3_tri(mesh, t)
          swb_s(b, "    ex3_tri(e, b0 + " as *u8)
          swb_n(b, tr[0])
          swb_s(b, ", b0 + " as *u8)
          swb_n(b, tr[1])
          swb_s(b, ", b0 + " as *u8)
          swb_n(b, tr[2])
          swb_s(b, ")" as *u8)
          swb_c(b, 10)
          t = t + 1
      }
      swb_s(b, "    return 0" as *u8)
      swb_c(b, 10)
      swb_c(b, 125)
      swb_c(b, 10)
      chunk = chunk + 1
  }
  let tchunks: i64 = chunk
  // parent
  swb_s(b, "func exm_k" as *u8)
  swb_n(b, kind)
  swb_s(b, "(e: *i64, cx: i64, cy: i64, cz: i64, col: i64) -> i64 " as *u8)
  swb_c(b, 123)
  swb_c(b, 10)
  swb_s(b, "    let b0: i64 = e[1]" as *u8)
  swb_c(b, 10)
  var c2: i64 = 0
  while c2 < vchunks {
      swb_s(b, "    exm_k" as *u8)
      swb_n(b, kind)
      swb_s(b, "_v" as *u8)
      swb_n(b, c2)
      swb_s(b, "(e, cx, cy, cz, col)" as *u8)
      swb_c(b, 10)
      c2 = c2 + 1
  }
  c2 = 0
  while c2 < tchunks {
      swb_s(b, "    exm_k" as *u8)
      swb_n(b, kind)
      swb_s(b, "_t" as *u8)
      swb_n(b, c2)
      swb_s(b, "(e, b0)" as *u8)
      swb_c(b, 10)
      c2 = c2 + 1
  }
  swb_s(b, "    return 0" as *u8)
  swb_c(b, 10)
  swb_c(b, 125)
  swb_c(b, 10)
  return ntr
132}
133
134func main() -> i64 {
  sp_puts("=== nx_explodelab_meshgen -- bake REAL 53/53 part meshes for the viewer ===\n" as *u8)
  let buf: *u8 = sys_mmap(K_MAGIC_4194304)
  let a1: *i64 = sys_mmap(K_MAGIC_524288) as *i64
  let a2: *i64 = sys_mmap(K_MAGIC_524288) as *i64
  let a3: *i64 = sys_mmap(K_MAGIC_524288) as *i64
  let a4: *i64 = sys_mmap(K_MAGIC_524288) as *i64
  let a5: *i64 = sys_mmap(K_MAGIC_524288) as *i64
  let st: *i64 = sys_mmap(256) as *i64
  let n: i64 = sp_read_file("knowledge/fetched/step_as1.stp" as *u8, buf, K_MAGIC_4194304)
  if n <= 0 { sp_puts("MISSING as1\nRED\n" as *u8); return 1 }
  sp_init(st, buf, n, a1, a2, a3, a4, a5)
  sp_scan(st)
  // ctxs (report-pipeline pattern)
  let tt: *i64 = sys_mmap(128) as *i64
  let cp: *i64 = sys_mmap(128) as *i64
  var z: i64 = 0
  while z < 16 { cp[z] = 0; z = z + 1 }
  tt[0] = st as i64
  tt[2] = cp as i64
  tt[3] = sys_mmap(768) as i64
  tt[4] = 0
  tt[5] = sys_mmap(K_MAGIC_8192) as i64
  tt[6] = sys_mmap(K_MAGIC_4096) as i64
  tt[7] = sys_mmap(128) as i64
  tt[8] = sys_mmap(16) as i64
  tt[9] = 0
  let t2: *i64 = sys_mmap(128) as *i64
  t2[0] = st as i64
  t2[1] = cp as i64
  t2[2] = sys_mmap(32) as i64
  t2[3] = sys_mmap(960) as i64
  t2[4] = sys_mmap(K_MAGIC_1024) as i64
  t2[5] = sys_mmap(128) as i64
  t2[6] = sys_mmap(512) as i64
  t2[7] = sys_mmap(256) as i64
  t2[8] = sys_mmap(K_MAGIC_8192) as i64
  t2[9] = sys_mmap(128) as i64
  t2[10] = sys_mmap(768) as i64
  t2[11] = sys_mmap(128) as i64
  t2[12] = sys_mmap(256) as i64
  let slab: *i64 = sys_mmap(K_MAGIC_20480) as *i64
  let nt: *i64 = sys_mmap(128) as *i64
  let c2n: *i64 = sys_mmap(128) as *i64
  z = 0
  while z < 16 { c2n[z] = 0; z = z + 1 }
  nt[0] = st as i64
  nt[2] = c2n as i64
  nt[3] = sys_mmap(256) as i64
  nt[4] = sys_mmap(64) as i64
  nt[5] = sys_mmap(16) as i64
  nt[6] = sys_mmap(128) as i64
  nt[7] = sys_mmap(128) as i64
  let pdid: *i64 = sys_mmap(128) as *i64
  let prodidx: *i64 = sys_mmap(128) as *i64
  let shellidx: *i64 = sys_mmap(128) as *i64
  let np: i64 = cr_find_parts(st, pdid, prodidx, shellidx)
  if np != 5 { sp_puts("expected 5 parts\nRED\n" as *u8); return 1 }
  // units registry for baked thou values
  let u: *i64 = sys_mmap(64) as *i64
  ur_init(u, 64)
  ur_std(u)
  let iFX: i64 = ur_find(u, "fx256mm" as *u8)
  let iTHOU: i64 = ur_find(u, "thou" as *u8)
  let uout: *i64 = sys_mmap(16) as *i64
  // output builder
  let b: *i64 = sys_mmap(64) as *i64
  swb_init(b, K_MAGIC_4194304)
  swb_s(b, "// nx_explodelab_meshes.nx -- GENERATED by nx_explodelab_meshgen (do not hand-edit): the REAL 53/53" as *u8)
  swb_c(b, 10)
  swb_s(b, "// file-true as1 part meshes for /explodelab, centered per part, world scale = fx256/8 (32 units/mm)." as *u8)
  swb_c(b, 10)
  swb_s(b, "// exm_load(e,kind,col): 1 nut, 2 bolt, 3 rod, 4 plate, 5 l-bracket. exm_dims = TRUE mm (fx256) + thou." as *u8)
  swb_c(b, 10)
  swb_s(b, "// license_tier: ORIGINAL" as *u8)
  swb_c(b, 10)
  swb_s(b, "import " as *u8)
  swb_c(b, 34)
  swb_s(b, "nx_explode3d.nx" as *u8)
  swb_c(b, 34)
  swb_c(b, 10)
  // per kind: name order 1..5
  let vcnt: *i64 = sys_mmap(64) as *i64
  let tcnt: *i64 = sys_mmap(64) as *i64
  let dims: *i64 = sys_mmap(256) as *i64                   // per kind: w,h,d fx + thou
  let out4: *i64 = sys_mmap(32) as *i64
  var kind: i64 = 1
  while kind <= 5 {
      // find the part index by name
      var want: i64 = 0 - 1
      var pi: i64 = 0
      while pi < np {
          var m: i64 = 0
          if kind == 1 { m = sp_prod_name_is(st, prodidx[pi], "nut" as *u8) }
          if kind == 2 { m = sp_prod_name_is(st, prodidx[pi], "bolt" as *u8) }
          if kind == 3 { m = sp_prod_name_is(st, prodidx[pi], "rod" as *u8) }
          if kind == 4 { m = sp_prod_name_is(st, prodidx[pi], "plate" as *u8) }
          if kind == 5 { m = sp_prod_name_is(st, prodidx[pi], "l-bracket" as *u8) }
          if m == 1 { want = pi }
          pi = pi + 1
      }
      if want < 0 { sp_puts("part missing\nRED\n" as *u8); return 1 }
      let mesh: i64 = sys_mmap(m3_bytes()) as i64
      m3_init(mesh)
      tt[1] = mesh
      nt[1] = mesh
      cr_tess_part(tt, nt, t2, slab, shellidx[want], out4)
      cr_weld(mesh)
      let h: *i64 = m3_hdr(mesh)
      // bbox + center
      var mn0: i64 = 0
      var mx0: i64 = 0
      var mn1: i64 = 0
      var mx1: i64 = 0
      var mn2: i64 = 0
      var mx2: i64 = 0
      if h[0] > 0 {
          let v0: *i64 = m3_vert(mesh, 0)
          mn0 = v0[0]; mx0 = v0[0]; mn1 = v0[1]; mx1 = v0[1]; mn2 = v0[2]; mx2 = v0[2]
          var vi: i64 = 1
          while vi < h[0] {
              let v: *i64 = m3_vert(mesh, vi)
              if v[0] < mn0 { mn0 = v[0] }
              if v[0] > mx0 { mx0 = v[0] }
              if v[1] < mn1 { mn1 = v[1] }
              if v[1] > mx1 { mx1 = v[1] }
              if v[2] < mn2 { mn2 = v[2] }
              if v[2] > mx2 { mx2 = v[2] }
              vi = vi + 1
          }
      }
      let cx3: *i64 = sys_mmap(32) as *i64
      cx3[0] = (mn0 + mx0) / 2
      cx3[1] = (mn1 + mx1) / 2
      cx3[2] = (mn2 + mx2) / 2
      mg_part(b, mesh, kind, cx3)
      vcnt[kind] = h[0]
      tcnt[kind] = h[1]
      dims[kind * 4] = mx0 - mn0
      dims[kind * 4 + 1] = mx1 - mn1
      dims[kind * 4 + 2] = mx2 - mn2
      var ext: i64 = mx0 - mn0
      if mx1 - mn1 > ext { ext = mx1 - mn1 }
      if mx2 - mn2 > ext { ext = mx2 - mn2 }
      ur_conv(u, ext, iFX, iTHOU, uout)
      dims[kind * 4 + 3] = uout[0]
      sp_puts("  kind " as *u8); sp_putn(kind)
      sp_puts(": verts=" as *u8); sp_putn(h[0])
      sp_puts(" tris=" as *u8); sp_putn(h[1])
      sp_puts(" maxext-thou=" as *u8); sp_putn(uout[0]); sp_puts("\n" as *u8)
      kind = kind + 1
  }
  // dispatcher + tables
  swb_s(b, "func exm_load(e: *i64, kind: i64, cx: i64, cy: i64, cz: i64, col: i64) -> i64 " as *u8)
  swb_c(b, 123)
  swb_c(b, 10)
  kind = 1
  while kind <= 5 {
      swb_s(b, "    if kind == " as *u8)
      swb_n(b, kind)
      swb_s(b, " " as *u8)
      swb_c(b, 123)
      swb_s(b, " return exm_k" as *u8)
      swb_n(b, kind)
      swb_s(b, "(e, cx, cy, cz, col) " as *u8)
      swb_c(b, 125)
      swb_c(b, 10)
      kind = kind + 1
  }
  swb_s(b, "    return 0 - 1" as *u8)
  swb_c(b, 10)
  swb_c(b, 125)
  swb_c(b, 10)
  swb_s(b, "func exm_counts(kind: i64, out2: *i64) -> i64 " as *u8)
  swb_c(b, 123)
  swb_c(b, 10)
  kind = 1
  while kind <= 5 {
      swb_s(b, "    if kind == " as *u8)
      swb_n(b, kind)
      swb_s(b, " " as *u8)
      swb_c(b, 123)
      swb_s(b, " out2[0] = " as *u8)
      swb_n(b, vcnt[kind])
      swb_s(b, "; out2[1] = " as *u8)
      swb_n(b, tcnt[kind])
      swb_s(b, "; return 1 " as *u8)
      swb_c(b, 125)
      swb_c(b, 10)
      kind = kind + 1
  }
  swb_s(b, "    return 0" as *u8)
  swb_c(b, 10)
  swb_c(b, 125)
  swb_c(b, 10)
  swb_s(b, "func exm_dims(kind: i64, out4: *i64) -> i64 " as *u8)
  swb_c(b, 123)
  swb_c(b, 10)
  kind = 1
  while kind <= 5 {
      swb_s(b, "    if kind == " as *u8)
      swb_n(b, kind)
      swb_s(b, " " as *u8)
      swb_c(b, 123)
      swb_s(b, " out4[0] = " as *u8)
      swb_n(b, dims[kind * 4])
      swb_s(b, "; out4[1] = " as *u8)
      swb_n(b, dims[kind * 4 + 1])
      swb_s(b, "; out4[2] = " as *u8)
      swb_n(b, dims[kind * 4 + 2])
      swb_s(b, "; out4[3] = " as *u8)
      swb_n(b, dims[kind * 4 + 3])
      swb_s(b, "; return 1 " as *u8)
      swb_c(b, 125)
      swb_c(b, 10)
      kind = kind + 1
  }
  swb_s(b, "    return 0" as *u8)
  swb_c(b, 10)
  swb_c(b, 125)
  swb_c(b, 10)
  let fd: i64 = sys_openat_wr("runtime/nx_explodelab_meshes.nx" as *u8, 420)
  if fd < 0 { sp_puts("open fail\nRED\n" as *u8); return 1 }
  sys_write(fd, b[0] as *u8, b[1])
  sys_close(fd)
  sp_puts("wrote runtime/nx_explodelab_meshes.nx bytes=" as *u8); sp_putn(b[1]); sp_puts("\nGREEN -- real meshes baked\n" as *u8)
  return 0
361}
nx_explodelab_meshgen.nx source

`nx_explodelab_meshgen.nx` source
