`nx_csg_scene.nx` source

↩ module page · 264 lines · 10583 B
1// nx_csg_scene.nx -- N-PRIMITIVE CSG.  nx_csg_extract is hardwired to TWO primitives
2// (a op b); real parts need many features folded into ONE watertight solid -- a toilet-
3// cleaner head is plate MINUS pocket MINUS slots UNION neck UNION socket MINUS bore.
4//
5// This GROWS the capability by COMPOSING what already exists, adding no new geometry math:
6//   * the boolean algebra is the EXISTING nx_csg_combine_k (min/max + smooth-min fillet)
7//   * the surface mesher is the EXISTING marching-tetrahedra core (mt_tet, imported)
8//   * per-primitive ROTATION (about an arbitrary pivot) is the EXISTING nx_trig (cos/sin),
9//     applied by inverse-rotating the query point -- nx_sdf stays untouched
10//   * the only new thing is a LEFT-FOLD of the field over a list of (prim, op, fillet-k):
11//       field = combine_k(op[1], eval(p0), eval(p1), k[1]) ... combine_k(op[n-1], ., eval(p_{n-1}), k[n-1])
12//     prim[0] is the seed (its op/k ignored).
13//
14// Robust by construction: SDF booleans can never fail/self-intersect the way B-rep does,
15// and the marching grid is shared so the result is watertight by the same canonical-edge
16// argument as nx_csg_extract.  Output is a pipeline-native Q14-mm NxMesh -> nx_stl_write_mesh
17// -> slicer -> G-code, exactly like every other sovereign solid.
18//
19// NOTE (tech-debt, logged not hidden): the grid+marching loop below is copied from
20// nx_csg_extract with only the 2-prim field swapped for the scene field.  The clean
21// refactor is a field-eval callback in nx_csg_extract; deferred until NishiLang fn-ptr
22// support is confirmed.  license_tier: ORIGINAL
23
24import "nx_syscalls.nx"
25import "nx_mesh.nx"
26import "nx_sdf.nx"
27import "nx_csg.nx"
28import "nx_trig.nx"
29const NX_MAGIC_1024: i64 = 1024
30const NX_MAGIC_65536: i64 = 65536
31
32// rotation axes (v1 implements Y -- the hook tilt; X/Z are easy follow-ons)
33const NX_ROT_NONE: i64 = 0
34const NX_ROT_X:    i64 = 1
35const NX_ROT_Y:    i64 = 2
36const NX_ROT_Z:    i64 = 3
37
38// A scene applies its primitives left-to-right.  prim[0] seeds the field; for i>=1 the
39// field so far is combined with eval(prim[i]) under ops[i] (fillet radius ks[i], 0=sharp).
40// Each prim may carry a rotation: axis rax[i] about pivot (rpx,rpy,rpz)[i] by rang[i]
41// (Q10 turn; 1024 = full circle).  rax=0 -> axis-aligned (no rotation).
42struct NxCsgScene {
  n:     i64,
  cap:   i64,
  prims: *i64,    // n entries, each an (NxSdfPrim*) stored as i64
  ops:   *i64,    // n entries (ops[0] unused)
  ks:    *i64,    // n entries (ks[0] unused); 0 = sharp boolean, >0 = fillet radius (Q14)
  rax:   *i64,    // rotation axis (NX_ROT_*)
  rang:  *i64,    // rotation angle (Q10 turn)
  rpx:   *i64,    // pivot x (Q14)
  rpy:   *i64,    // pivot y (Q14)
  rpz:   *i64,    // pivot z (Q14)
53}
54
55func nx_csg_scene_new(cap: i64) -> *NxCsgScene {
  let s: *NxCsgScene = (sys_mmap(80)) as *NxCsgScene
  s.n     = 0
  s.cap   = cap
  s.prims = (sys_mmap(cap * 8)) as *i64
  s.ops   = (sys_mmap(cap * 8)) as *i64
  s.ks    = (sys_mmap(cap * 8)) as *i64
  s.rax   = (sys_mmap(cap * 8)) as *i64
  s.rang  = (sys_mmap(cap * 8)) as *i64
  s.rpx   = (sys_mmap(cap * 8)) as *i64
  s.rpy   = (sys_mmap(cap * 8)) as *i64
  s.rpz   = (sys_mmap(cap * 8)) as *i64
  return s
68}
69
70// add an axis-aligned primitive; returns its index, or -1 if full.
71func nx_csg_scene_add(s: *NxCsgScene, p: *NxSdfPrim, op: i64, k: i64) -> i64 {
  if s.n >= s.cap { return 0 - 1 }
  let i: i64 = s.n
  s.prims[i] = p as i64
  s.ops[i]   = op
  s.ks[i]    = k
  s.rax[i]   = NX_ROT_NONE
  s.rang[i]  = 0
  s.rpx[i]   = 0
  s.rpy[i]   = 0
  s.rpz[i]   = 0
  s.n = i + 1
  return i
84}
85
86// add a ROTATED primitive (axis about pivot, angle Q10 turn); returns its index or -1.
87func nx_csg_scene_add_rot(s: *NxCsgScene, p: *NxSdfPrim, op: i64, k: i64,
                        axis: i64, ang_q10: i64, px: i64, py: i64, pz: i64) -> i64 {
  let i: i64 = nx_csg_scene_add(s, p, op, k)
  if i < 0 { return i }
  s.rax[i]  = axis
  s.rang[i] = ang_q10
  s.rpx[i]  = px
  s.rpy[i]  = py
  s.rpz[i]  = pz
  return i
97}
98
99// signed distance of primitive i at world (x,y,z), applying its rotation if any.
100// Rotating the SHAPE by +ang = inverse-rotating the query point about the pivot.
101func nx_csg_scene_eval_i(s: *NxCsgScene, i: i64, x: i64, y: i64, z: i64) -> i64 {
  let p: *NxSdfPrim = (s.prims[i]) as *NxSdfPrim
  let ax: i64 = s.rax[i]
  if ax == NX_ROT_NONE { return nx_sdf_eval(p, x, y, z) }
  let c:  i64 = nx_cos_turn_q10(s.rang[i])
  let sn: i64 = nx_sin_turn_q10(s.rang[i])
  if ax == NX_ROT_Y {
      let dx: i64 = x - s.rpx[i]
      let dz: i64 = z - s.rpz[i]
      let qx: i64 = (dx * c + dz * sn) / NX_MAGIC_1024
      let qz: i64 = (0 - dx * sn + dz * c) / NX_MAGIC_1024
      return nx_sdf_eval(p, s.rpx[i] + qx, y, s.rpz[i] + qz)
  }
  if ax == NX_ROT_X {
      let dy: i64 = y - s.rpy[i]
      let dz: i64 = z - s.rpz[i]
      let qy: i64 = (dy * c + dz * sn) / NX_MAGIC_1024
      let qz: i64 = (0 - dy * sn + dz * c) / NX_MAGIC_1024
      return nx_sdf_eval(p, x, s.rpy[i] + qy, s.rpz[i] + qz)
  }
  // NX_ROT_Z
  let dx2: i64 = x - s.rpx[i]
  let dy2: i64 = y - s.rpy[i]
  let qx2: i64 = (dx2 * c + dy2 * sn) / NX_MAGIC_1024
  let qy2: i64 = (0 - dx2 * sn + dy2 * c) / NX_MAGIC_1024
  return nx_sdf_eval(p, s.rpx[i] + qx2, s.rpy[i] + qy2, z)
127}
128
129// fold the scene field at (x,y,z).
130func nx_csg_scene_field(s: *NxCsgScene, x: i64, y: i64, z: i64) -> i64 {
  if s.n <= 0 { return 1 }                                   // empty -> everywhere outside
  var d: i64 = nx_csg_scene_eval_i(s, 0, x, y, z)
  var i: i64 = 1
  while i < s.n {
      let di: i64 = nx_csg_scene_eval_i(s, i, x, y, z)
      d = nx_csg_combine_k(s.ops[i], d, di, s.ks[i])
      i = i + 1
  }
  return d
140}
141
142// inside-sample count over a coarse grid (debug / feature-presence proofs).
143func nx_csg_scene_count_inside(s: *NxCsgScene,
                             lox: i64, loy: i64, loz: i64,
                             hix: i64, hiy: i64, hiz: i64, step: i64) -> i64 {
  var c: i64 = 0
  var z: i64 = loz
  while z <= hiz {
      var y: i64 = loy
      while y <= hiy {
          var x: i64 = lox
          while x <= hix {
              if nx_csg_scene_field(s, x, y, z) < 0 { c = c + 1 }
              x = x + step
          }
          y = y + step
      }
      z = z + step
  }
  return c
161}
162
163// Extract the composed scene over the box [lo,hi] at grid resolution res into an NxMesh.
164// Mirrors nx_csg_extract's proven grid + 6-tet (Kuhn) marching loop; the ONLY change is
165// the field is the N-primitive scene fold instead of a 2-primitive boolean.
166func nx_csg_extract_scene(s: *NxCsgScene,
                        lox: i64, loy: i64, loz: i64,
                        hix: i64, hiy: i64, hiz: i64, res: i64) -> *NxMesh {
  let np: i64 = res + 1
  let field: *i64 = (sys_mmap(np * np * np * 8)) as *i64
  var k: i64 = 0
  while k <= res {
      let z: i64 = loz + (hiz - loz) * k / res
      var j: i64 = 0
      while j <= res {
          let y: i64 = loy + (hiy - loy) * j / res
          var ii: i64 = 0
          while ii <= res {
              let x: i64 = lox + (hix - lox) * ii / res
              field[ii + j*np + k*np*np] = nx_csg_scene_field(s, x, y, z)
              ii = ii + 1
          }
          j = j + 1
      }
      k = k + 1
  }
187
  // 6-tet (Kuhn) decomposition along cube diagonal 0-7 (identical to nx_csg_extract)
  let tets: *i64 = (sys_mmap(24 * 8)) as *i64
  tets[0]=0;tets[1]=7;tets[2]=1;tets[3]=3;     tets[4]=0;tets[5]=7;tets[6]=3;tets[7]=2
  tets[8]=0;tets[9]=7;tets[10]=2;tets[11]=6;   tets[12]=0;tets[13]=7;tets[14]=6;tets[15]=4
  tets[16]=0;tets[17]=7;tets[18]=4;tets[19]=5; tets[20]=0;tets[21]=7;tets[22]=5;tets[23]=1
193
  // generous tri cap (bigger constant than nx_csg_extract: multi-feature parts have
  // more surface area; a too-small cap would silently DROP tris and break watertightness).
  let cap: i64 = 48 * res * res + NX_MAGIC_65536
  let tribuf: *i64 = (sys_mmap(cap * 9 * 8)) as *i64
  let ntri: *i64 = (sys_mmap(8)) as *i64
  ntri[0] = 0
200
  let cp: *i64 = (sys_mmap(8 * 3 * 8)) as *i64
  let cd: *i64 = (sys_mmap(8 * 8)) as *i64
  let P:  *i64 = (sys_mmap(12 * 8)) as *i64
  let D:  *i64 = (sys_mmap(4 * 8)) as *i64
  let ins:  *i64 = (sys_mmap(4 * 8)) as *i64
  let outs: *i64 = (sys_mmap(4 * 8)) as *i64
  let q0: *i64 = (sys_mmap(24)) as *i64
  let q1: *i64 = (sys_mmap(24)) as *i64
  let q2: *i64 = (sys_mmap(24)) as *i64
  let q3: *i64 = (sys_mmap(24)) as *i64
211
  var ck: i64 = 0
  while ck < res {
      var cj: i64 = 0
      while cj < res {
          var ci: i64 = 0
          while ci < res {
              var c: i64 = 0
              while c < 8 {
                  let gi: i64 = ci + (c & 1)
                  let gj: i64 = cj + ((c >> 1) & 1)
                  let gk: i64 = ck + ((c >> 2) & 1)
                  cp[c*3+0] = lox + (hix - lox) * gi / res
                  cp[c*3+1] = loy + (hiy - loy) * gj / res
                  cp[c*3+2] = loz + (hiz - loz) * gk / res
                  cd[c] = field[gi + gj*np + gk*np*np]
                  c = c + 1
              }
              var t: i64 = 0
              while t < 6 {
                  var v: i64 = 0
                  while v < 4 {
                      let corner: i64 = tets[t*4+v]
                      P[v*3+0] = cp[corner*3+0]
                      P[v*3+1] = cp[corner*3+1]
                      P[v*3+2] = cp[corner*3+2]
                      D[v] = cd[corner]
                      v = v + 1
                  }
                  mt_tet(tribuf, ntri, cap, P, D, ins, outs, q0, q1, q2, q3)
                  t = t + 1
              }
              ci = ci + 1
          }
          cj = cj + 1
      }
      ck = ck + 1
  }
249
  let nt: i64 = ntri[0]
  if nt <= 0 { return 0 as *NxMesh }
  let m: *NxMesh = nx_mesh_alloc(nt * 3, nt, 0)
  if (m as i64) == 0 { return m }
  var t2: i64 = 0
  while t2 < nt {
      let base: i64 = t2 * 9
      nx_mesh_set_vertex(m, t2*3+0, tribuf[base+0], tribuf[base+1], tribuf[base+2], 0)
      nx_mesh_set_vertex(m, t2*3+1, tribuf[base+3], tribuf[base+4], tribuf[base+5], 0)
      nx_mesh_set_vertex(m, t2*3+2, tribuf[base+6], tribuf[base+7], tribuf[base+8], 0)
      nx_mesh_set_triangle(m, t2, t2*3+0, t2*3+1, t2*3+2)
      t2 = t2 + 1
  }
  return m
264}
nx_csg_scene.nx source

`nx_csg_scene.nx` source
