`nx_nxa_groom.nx` source

↩ module page · 619 lines · 29067 B
1// nx_nxa_groom.nx -- GENERATE THE GROOM: full-scalp procedural hair strands written into the
2// asset's HSTR section, replacing the sampled partial cap that left the back of the head bare
3// (operator-reported 2026-08-26: "the back of the head is shaved").
4//
5// INFINIGEN-2 PRINCIPLE, APPLIED (operator standing order: those principles for everything):
6// hair is GENERATED from parameters and the mesh's own measured geometry -- no groom asset, no
7// donor, no hand-placed strand. The industry's own groom pipelines (XGen, Ornatrix, Houdini)
8// are procedural for the same reason: a scalp map plus guide growth beats any sampled cap.
9//
10// METHOD (every number derived or parameterized, never tasted):
11//   1. Axes derived from vertex extents (the nx_nxa_dyna derivation, same tree of assumptions).
12//   2. HEAD TOP = highest vertex; HEAD CENTER = centroid of verts in the top head band (the
13//      band spans from crown down by a face-height fraction derived from stature).
14//   3. ROOTS: every scalp vertex above the EAR LINE (head centre height) whose radial direction
15//      is not into the face cone, deterministically thinned to <= GRO_MAX_STRANDS with a seeded
16//      hash (Infinigen principle: seeded, reproducible diversity).
17//   4. GROWTH: 8 points per strand (the HSTR contract, NXHCH_W=24 words). Point i steps
18//      seg_len along a direction that starts RADIAL (off the scalp) and blends toward GRAVITY
19//      (down the stature axis) as the strand extends -- long hair hangs, crown hair lifts then
20//      falls, back hair drapes the nape. Length = stature * length_permil / 1000.
21//   5. Writes HSTR via the proven section-replace machinery (nx_nxa_dyna pattern): input never
22//      modified, an existing HSTR is REPLACED, re-runs identical.
23//
24//   usage: nx_nxa_groom <in.nxa> <out.nxa> [length_permil=280] [strands=1400] [seed=7]
25//   exit 0 OK | 2 usage | 3 bad-nxa | 1 io
26// license_tier: ORIGINAL   No hw writes (Rule 26).   expect_exit: 0
27import "nx_syscalls.nx"
28import "nx_nxa.nx"
29
30const GR_HDR: i64 = 32
31const GR_TOCE: i64 = 32
32const GR_MAXSEC: i64 = 64
33const GR_MODE: i64 = 0x1a4
34const GR_PTS: i64 = 8            // points per strand == NXHCH_N(7 segments) + 1: the page contract
35const GR_WORDS: i64 = 24         // GR_PTS * 3 coords == NXHCH_W: the page contract
36const GR_DEF_LEN_PERMIL: i64 = 150   // default hair length as permil of stature: mid-back on a
                                   // 1.71 m figure (~48 cm) -- the "long and beautiful" band the
                                   // operator asked for; a style PARAMETER, not a constant
39const GR_DEF_STRANDS: i64 = 4800  // lock granularity for digital-twin density: ~25 follicles per lock against the ~120k human scalp (follicle-count citation to mirror; the RATIO is the parameter) // page samples down to its 900 guides (step floor), so anything
                               // >= 900 renders at full guide density
41const GR_DEF_SEED: i64 = 7
42// head-band fraction: the head occupies ~1/8 of stature (the 917-permil head anchor the estate
43// already banks against a 744 nipple line puts crown-to-chin near 120 permil); the scalp band is
44// the top HALF of that. Derived from the banked anchors, stated here.
45const GR_HEADBAND_PERMIL: i64 = 60
46// face cone: roots whose radial direction points ANTERIOR more than this permil of the radial
47// length are the FACE, not scalp -- no bangs into the eyes at v1 (a style parameter later).
48const GR_FACE_PERMIL: i64 = 350
49// side-sweep (operator: hair must FRAME the face, never cover it): a root whose radial
50// direction carries face-ward component gets a lateral bias toward its OWN side of the part,
51// scaled by how face-ward it is -- the brief's fall-left-or-right-of-the-part rule.
52const GR_SWEEP_Q10: i64 = 700
53// gravity blend: how fast growth direction turns downward per point index (q10 per step). At 340,
54// point 1 is mostly radial (lift off the scalp) and points 5..7 are mostly gravity (drape).
55const GR_GRAVITY_RAMP_Q10: i64 = 520
56// v2 cosmetology rules (operator's Infinigen-2 groom briefs, 2026-08-26):
57// nape zone: posterior roots admitted BELOW the ear line by this much of stature -- covers the
58// occiput down to the hairline's nape boundary (the shaved-back fix).
59const GR_NAPE_PERMIL: i64 = 45
60// layering: strand length scales down by up to this fraction (q10) at the crown -- long layers.
61const GR_LAYER_Q10: i64 = 300
62// waves: sine along growth, cycles per strand (q10 phase step per point) and amplitude as
63// permil of segment length. Large-scale + tight amplitude = waves, not frizz (the brief's rule).
64const GR_WAVE_STEP_Q10: i64 = 640
65const GR_WAVE_AMP_PERMIL: i64 = 80
66const GR_Q10: i64 = 1024
67// root-synthesis salts and jitter band (rule 11: named, never inline)
68// comb style parameters (the loose-down default; a style-preset lane owns richer values):
69// BACK = 350/1000 backward bias in the style vector (~19 deg comb-back), LIFT = 150/1000 normal
70// lift so the first segment clears the surface before the tangent flow takes over -- the small-lift
71// large-tangent split is the Infinigen comb_direction shape.
72const GR_COMB_BACK_Q10: i64 = 358
73const GR_COMB_LIFT_Q10: i64 = 154
74const GR_SYN_SALT_A: i64 = 77
75const GR_SYN_SALT_B: i64 = 177
76const GR_SYN_SALT_M: i64 = 277
77
78func gr_slen(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
79func gr_err(s: *u8) -> i64 { sys_write(2, s, gr_slen(s)); return 0 }
80func gr_out(s: *u8) -> i64 { sys_write(1, s, gr_slen(s)); return 0 }
81func gr_num(v: i64) -> i64 {
  if v == 0 { sys_write(1, "0" as *u8, 1); return 0 }
  var m: i64 = v
  if m < 0 { sys_write(1, "-" as *u8, 1); m = 0 - m }
  let t: *u8 = sys_mmap(32)
  var k: i64 = 0
  while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
  let o: *u8 = sys_mmap(32)
  var i: i64 = 0
  while i < k { o[i] = t[k - 1 - i]; i = i + 1 }
  sys_write(1, o, k)
  return 0
93}
94func gr_rd64(b: *u8, off: i64) -> i64 {
  var v: i64 = 0
  var i: i64 = 7
  while i >= 0 { v = v*256 + ((b[off + i] & 0xff) as i64); i = i - 1 }
  return v
99}
100func gr_wr64(b: *u8, off: i64, v: i64) -> i64 {
  var m: i64 = v
  var i: i64 = 0
  while i < 8 { b[off + i] = (m & 0xff) as u8; m = m >> 8; i = i + 1 }
  return 0
105}
106func gr_tageq(b: *u8, off: i64, t: *u8) -> i64 {
  var i: i64 = 0
  while i < 4 { if b[off + i] != t[i] { return 0 } i = i + 1 }
  return 1
110}
111func gr_isqrt(n: i64) -> i64 {
  if n <= 0 { return 0 }
  var x: i64 = n
  var y: i64 = (x + 1) / 2
  while y < x { x = y; y = (x + n/x) / 2 }
  return x
117}
118func gr_atoi(s: *u8) -> i64 {
  var v: i64 = 0
  var i: i64 = 0
  while s[i] >= (48 as u8) { if s[i] > (57 as u8) { return v } v = v*10 + ((s[i] as i64) - 48); i = i + 1 }
  return v
123}
124// deterministic hash (the estate's whash shape) for seeded thinning
125func gr_hash(a: i64, b: i64) -> i64 {
  var n: i64 = a*374761393 + b*668265263 + 1442695041
  n = (n ^ (n >> 13))*1274126177
  n = n ^ (n >> 16)
  if n < 0 { n = 0 - n }
  return n
131}
132
133func main(argc: i64, argv: *i64) -> i64 {
  if argc < 3 {
      gr_err("usage: nx_nxa_groom <in.nxa> <out.nxa> [length_permil] [strands] [seed]\n" as *u8)
      sys_exit(2)
      return 2
  }
  let inp: *u8 = argv[1] as *u8
  let outp: *u8 = argv[2] as *u8
  var lenp: i64 = GR_DEF_LEN_PERMIL
  var want: i64 = GR_DEF_STRANDS
  var seed: i64 = GR_DEF_SEED
  if argc > 3 { lenp = gr_atoi(argv[3] as *u8) }
  if argc > 4 { want = gr_atoi(argv[4] as *u8) }
  if argc > 5 { seed = gr_atoi(argv[5] as *u8) }
  if lenp < 60 { lenp = GR_DEF_LEN_PERMIL }
  if want < 100 { want = GR_DEF_STRANDS }
149
  let lp: *i64 = sys_mmap(16) as *i64
  let b: *u8 = sys_read_file(inp, lp)
  if (b as i64) == 0 { gr_err("GROOM-RED cannot read input\n" as *u8); sys_exit(1); return 1 }
  let flen: i64 = lp[0]
  if flen < GR_HDR { gr_err("GROOM-RED not an NXA\n" as *u8); sys_exit(3); return 3 }
  if gr_rd64(b, 0) != nxa_magic() { gr_err("GROOM-RED bad magic\n" as *u8); sys_exit(3); return 3 }
  let ns: i64 = gr_rd64(b, 16)
  if ns < 1 { gr_err("GROOM-RED bad section count\n" as *u8); sys_exit(3); return 3 }
  if ns >= GR_MAXSEC { gr_err("GROOM-RED toc full\n" as *u8); sys_exit(3); return 3 }
159
  var vo: i64 = 0 - 1
  var tro: i64 = 0 - 1
  var hsi: i64 = 0 - 1
  var s: i64 = 0
  while s < ns {
      let e: i64 = GR_HDR + s*GR_TOCE
      if gr_tageq(b, e, "VERT" as *u8) == 1 { vo = gr_rd64(b, e + 8) }
      if gr_tageq(b, e, "TRIS" as *u8) == 1 { tro = gr_rd64(b, e + 8) }
      if gr_tageq(b, e, "HSTR" as *u8) == 1 { hsi = s }
      s = s + 1
  }
  if tro < 0 { gr_err("GROOM-RED no TRIS section: barycentric root sampling needs the faces
172" as *u8); sys_exit(3); return 3 }
  if vo < 0 { gr_err("GROOM-RED no VERT\n" as *u8); sys_exit(3); return 3 }
  let nv: i64 = gr_rd64(b, vo)
175
  // ---- axes from extents (the nx_nxa_dyna derivation) ----
  var mn0: i64 = 0
  var mx0: i64 = 0
  var mn1: i64 = 0
  var mx1: i64 = 0
  var mn2: i64 = 0
  var mx2: i64 = 0
  var first: i64 = 1
  var i: i64 = 0
  while i < nv {
      let c0: i64 = gr_rd64(b, vo + 8 + (i*3)*8)
      let c1: i64 = gr_rd64(b, vo + 8 + (i*3 + 1)*8)
      let c2: i64 = gr_rd64(b, vo + 8 + (i*3 + 2)*8)
      if first == 1 { mn0 = c0; mx0 = c0; mn1 = c1; mx1 = c1; mn2 = c2; mx2 = c2; first = 0 }
      if c0 < mn0 { mn0 = c0 }
      if c0 > mx0 { mx0 = c0 }
      if c1 < mn1 { mn1 = c1 }
      if c1 > mx1 { mx1 = c1 }
      if c2 < mn2 { mn2 = c2 }
      if c2 > mx2 { mx2 = c2 }
      i = i + 1
  }
  let e0: i64 = mx0 - mn0
  let e1: i64 = mx1 - mn1
  let e2: i64 = mx2 - mn2
  var sa: i64 = 2
  if e0 >= e1 { if e0 >= e2 { sa = 0 } }
  if e1 > e0 { if e1 >= e2 { sa = 1 } }
  var la: i64 = 0
  var aa: i64 = 1
  if sa == 0 { la = 1; aa = 2; if e2 > e1 { la = 2; aa = 1 } }
  if sa == 1 { la = 0; aa = 2; if e2 > e0 { la = 2; aa = 0 } }
  if sa == 2 { la = 0; aa = 1; if e1 > e0 { la = 1; aa = 0 } }
  var span: i64 = e2
  var stop: i64 = mx2
  if sa == 0 { span = e0; stop = mx0 }
  if sa == 1 { span = e1; stop = mx1 }
  if span <= 0 { gr_err("GROOM-RED degenerate span\n" as *u8); sys_exit(3); return 3 }
  gr_out("  axes: stature=" as *u8); gr_num(sa)
  gr_out(" lateral=" as *u8); gr_num(la)
  gr_out(" anterior=" as *u8); gr_num(aa)
  gr_out(" span=" as *u8); gr_num(span); gr_out("\n" as *u8)
218
  // ---- head band: crown down GR_HEADBAND_PERMIL of stature; centroid = head centre ----
  let bandlo: i64 = stop - span*GR_HEADBAND_PERMIL/1000
  var hcx: i64 = 0
  var hcy: i64 = 0
  var hcz: i64 = 0
  var hcn: i64 = 0
  i = 0
  while i < nv {
      let pst: i64 = gr_rd64(b, vo + 8 + (i*3 + sa)*8)
      if pst >= bandlo {
          hcx = hcx + gr_rd64(b, vo + 8 + (i*3)*8)
          hcy = hcy + gr_rd64(b, vo + 8 + (i*3 + 1)*8)
          hcz = hcz + gr_rd64(b, vo + 8 + (i*3 + 2)*8)
          hcn = hcn + 1
      }
      i = i + 1
  }
  if hcn < 8 { gr_err("GROOM-RED no head band vertices\n" as *u8); sys_exit(3); return 3 }
  let cx: i64 = hcx/hcn
  let cy: i64 = hcy/hcn
  let cz: i64 = hcz/hcn
  gr_out("  head band verts=" as *u8); gr_num(hcn)
  gr_out(" centre=" as *u8); gr_num(cx); gr_out("/" as *u8); gr_num(cy); gr_out("/" as *u8); gr_num(cz)
  gr_out("\n" as *u8)
243
  // anterior sign, FOURTH derivation -- ORIENTATION IS A CONVENTION, CROSS-CHECKED, NEVER GUESSED.
  // History, kept so nobody re-walks it: v1 (denser side = face) was CORRECT; v2 (bigger extreme
  // extent = nose) inverted it -- the dense face mesh drags the band centroid toward itself so the
  // sparse occiput measures the LARGER extent; v3 (narrow tip) did not discriminate over the full
  // band (6059 vs 8066). Three heuristics, three answers ends the guessing: the estate rig
  // convention is ANTERIOR-NEGATIVE = FACE (the bust and ref9d both hold it), the mesh-density
  // count must AGREE (faces carry more mesh detail), and on disagreement this organ REFUSES loudly
  // instead of grooming a head it cannot orient.
  var antpos: i64 = 0
  var antneg: i64 = 0
  i = 0
  while i < nv {
      let pst: i64 = gr_rd64(b, vo + 8 + (i*3 + sa)*8)
      if pst >= bandlo {
          var pav: i64 = gr_rd64(b, vo + 8 + (i*3 + aa)*8)
          if aa == 0 { pav = pav - cx }
          if aa == 1 { pav = pav - cy }
          if aa == 2 { pav = pav - cz }
          if pav > 0 { antpos = antpos + 1 } else { antneg = antneg + 1 }
      }
      i = i + 1
  }
  if antneg <= antpos { gr_err("GROOM-RED orientation ambiguous: mesh density disagrees with the anterior-negative rig convention\n" as *u8); sys_exit(3); return 3 }
  let fsign: i64 = 0 - 1
  gr_out("  face sign=" as *u8); gr_num(fsign)
  gr_out(" (convention anterior-negative; density agrees: neg=" as *u8); gr_num(antneg)
  gr_out(" pos=" as *u8); gr_num(antpos); gr_out(")\n" as *u8)
271
  // ---- ROOTS BY AREA-WEIGHTED BARYCENTRIC FACE SAMPLING (the published method) ----
  // This is how Blender particle hair and the Infinigen creature hair chain place roots: sample
  // the scalp REGION's triangles, area-weighted, with uniform barycentric coordinates -- every
  // root lies ON a face by construction, so no synthesis, no interior points, no reprojection.
  // The three prior hand-rolled placements (vert-keep + chord-blend, small-chord, hash-offset)
  // are superseded; each was refused by the anatomy gate before this form.
  // Region rule per FACE CENTROID (same anatomy as before): above the hairline floor on the
  // stature axis (nape floor lower on the posterior side), outside the face cone.
  var cht: i64 = cz
  if sa == 0 { cht = cx }
  if sa == 1 { cht = cy }
  let ntri: i64 = gr_rd64(b, tro)
  if ntri < 4 { gr_err("GROOM-RED empty TRIS
285" as *u8); sys_exit(3); return 3 }
  let sfidx: *i64 = sys_mmap(ntri*8 + 64) as *i64
  let sfsum: *i64 = sys_mmap(ntri*8 + 64) as *i64
  var nsf: i64 = 0
  var asum: i64 = 0
  var t9: i64 = 0
  while t9 < ntri {
      let ia: i64 = gr_rd64(b, tro + 8 + (t9*3)*8)
      let ib: i64 = gr_rd64(b, tro + 8 + (t9*3 + 1)*8)
      let ic: i64 = gr_rd64(b, tro + 8 + (t9*3 + 2)*8)
      if ia < nv { if ib < nv { if ic < nv {
      let ax: i64 = gr_rd64(b, vo + 8 + (ia*3)*8)
      let ay: i64 = gr_rd64(b, vo + 8 + (ia*3 + 1)*8)
      let az: i64 = gr_rd64(b, vo + 8 + (ia*3 + 2)*8)
      let bx: i64 = gr_rd64(b, vo + 8 + (ib*3)*8)
      let by: i64 = gr_rd64(b, vo + 8 + (ib*3 + 1)*8)
      let bz: i64 = gr_rd64(b, vo + 8 + (ib*3 + 2)*8)
      let ccx: i64 = gr_rd64(b, vo + 8 + (ic*3)*8)
      let ccy: i64 = gr_rd64(b, vo + 8 + (ic*3 + 1)*8)
      let ccz: i64 = gr_rd64(b, vo + 8 + (ic*3 + 2)*8)
      let gx: i64 = (ax + bx + ccx)/3
      let gy: i64 = (ay + by + ccy)/3
      let gz: i64 = (az + bz + ccz)/3
      var gst: i64 = gz
      if sa == 0 { gst = gx }
      if sa == 1 { gst = gy }
      var gant: i64 = gz - cz
      if aa == 0 { gant = gx - cx }
      if aa == 1 { gant = gy - cy }
      var floor9: i64 = cht
      if gant*fsign < 0 { floor9 = cht - span*GR_NAPE_PERMIL/1000 }
      if gst >= floor9 {
          let rgx: i64 = gx - cx
          let rgy: i64 = gy - cy
          let rgz: i64 = gz - cz
          let grl: i64 = gr_isqrt(rgx*rgx + rgy*rgy + rgz*rgz)
          if grl > 0 { if gant*fsign*1000 < grl*GR_FACE_PERMIL {
              // area weight: |cross(B-A, C-A)| -- proportionality is all the sampler needs
              let ux: i64 = bx - ax
              let uy: i64 = by - ay
              let uz: i64 = bz - az
              let vx: i64 = ccx - ax
              let vy: i64 = ccy - ay
              let vz: i64 = ccz - az
              let crx: i64 = uy*vz - uz*vy
              let cry: i64 = uz*vx - ux*vz
              let crz: i64 = ux*vy - uy*vx
              let ar9: i64 = gr_isqrt(crx*crx + cry*cry + crz*crz)
              if ar9 > 0 {
                  sfidx[nsf] = t9
                  asum = asum + ar9
                  sfsum[nsf] = asum
                  nsf = nsf + 1
              }
          } }
      }
      } } }
      t9 = t9 + 1
  }
  if nsf < 32 { gr_err("GROOM-RED scalp face set too small
345" as *u8); sys_exit(3); return 3 }
  let roots: *i64 = sys_mmap(want*3*8 + 64) as *i64
  let nrm: *i64 = sys_mmap(want*3*8 + 64) as *i64
  var nr: i64 = 0
  while nr < want {
      // area-weighted face draw, then uniform barycentric (u = 1 - sqrt(r1), v = r2*sqrt(r1))
      let hdraw: i64 = gr_hash(seed + GR_SYN_SALT_A, nr) % asum
      var lo9: i64 = 0
      var fi9: i64 = nsf - 1
      var scan: i64 = 0
      var found: i64 = 0
      while scan < nsf {
          if found == 0 { if sfsum[scan] > hdraw { fi9 = scan; found = 1 } }
          scan = scan + 1
      }
      let tt: i64 = sfidx[fi9]
      let ia: i64 = gr_rd64(b, tro + 8 + (tt*3)*8)
      let ib: i64 = gr_rd64(b, tro + 8 + (tt*3 + 1)*8)
      let ic: i64 = gr_rd64(b, tro + 8 + (tt*3 + 2)*8)
      let ax: i64 = gr_rd64(b, vo + 8 + (ia*3)*8)
      let ay: i64 = gr_rd64(b, vo + 8 + (ia*3 + 1)*8)
      let az: i64 = gr_rd64(b, vo + 8 + (ia*3 + 2)*8)
      let bx: i64 = gr_rd64(b, vo + 8 + (ib*3)*8)
      let by: i64 = gr_rd64(b, vo + 8 + (ib*3 + 1)*8)
      let bz: i64 = gr_rd64(b, vo + 8 + (ib*3 + 2)*8)
      let ccx: i64 = gr_rd64(b, vo + 8 + (ic*3)*8)
      let ccy: i64 = gr_rd64(b, vo + 8 + (ic*3 + 1)*8)
      let ccz: i64 = gr_rd64(b, vo + 8 + (ic*3 + 2)*8)
      let r1: i64 = gr_hash(seed + GR_SYN_SALT_B, nr) % GR_Q10
      let r2: i64 = gr_hash(seed + GR_SYN_SALT_M, nr) % GR_Q10
      let sq1: i64 = gr_isqrt(r1*GR_Q10)
      let bu: i64 = GR_Q10 - sq1
      let bv: i64 = r2*sq1/GR_Q10
      let bw: i64 = GR_Q10 - bu - bv
      roots[nr*3] = (ax*bu + bx*bv + ccx*bw)/GR_Q10
      roots[nr*3 + 1] = (ay*bu + by*bv + ccy*bw)/GR_Q10
      roots[nr*3 + 2] = (az*bu + bz*bv + ccz*bw)/GR_Q10
      // launch frame from the FACE NORMAL (outward-oriented), not from a radial approximation
      let ux: i64 = bx - ax
      let uy: i64 = by - ay
      let uz: i64 = bz - az
      let vx: i64 = ccx - ax
      let vy: i64 = ccy - ay
      let vz: i64 = ccz - az
      var fnx: i64 = uy*vz - uz*vy
      var fny: i64 = uz*vx - ux*vz
      var fnz: i64 = ux*vy - uy*vx
      let fnl: i64 = gr_isqrt(fnx*fnx + fny*fny + fnz*fnz)
      if fnl > 0 { fnx = fnx*GR_Q10/fnl; fny = fny*GR_Q10/fnl; fnz = fnz*GR_Q10/fnl } else { fnz = GR_Q10 }
      let odot: i64 = fnx*(roots[nr*3] - cx) + fny*(roots[nr*3 + 1] - cy) + fnz*(roots[nr*3 + 2] - cz)
      if odot < 0 { fnx = 0 - fnx; fny = 0 - fny; fnz = 0 - fnz }
      nrm[nr*3] = fnx
      nrm[nr*3 + 1] = fny
      nrm[nr*3 + 2] = fnz
      nr = nr + 1
  }
  if nr < want { gr_err("GROOM-RED PARTIAL WORK REFUSED: fewer roots than requested
402" as *u8); sys_exit(3); return 3 }
  gr_out("  scalp faces=" as *u8); gr_num(nsf)
  gr_out(" of " as *u8); gr_num(ntri)
  gr_out(" area-sampled roots=" as *u8); gr_num(nr); gr_out("
406" as *u8)
407
  // ---- grow strands ----
  let total_len: i64 = span*lenp/1000
  let hw: *i64 = sys_mmap((8 + nr*GR_WORDS*8) + 64) as *i64
  hw[0] = nr
  var r: i64 = 0
  while r < nr {
      var px: i64 = roots[r*3]
      var py: i64 = roots[r*3 + 1]
      var pz: i64 = roots[r*3 + 2]
      // COMB-FIELD LAUNCH (the Infinigen comb_direction form): a style vector -- down the
      // stature axis with a backward bias away from the face -- PROJECTED ONTO THE TANGENT PLANE
      // of the root's face normal, plus a small normal lift. The pure-normal launch this replaces
      // was the dandelion-puff defect (operator screenshots 2026-08-27): strands left the scalp
      // perpendicular, skin showed between roots, and the crown veil drifted over the face.
      // Combed-tangent is how a groom LIES ON the scalp and flows back.
      let nx9: i64 = nrm[r*3]
      let ny9: i64 = nrm[r*3 + 1]
      let nz9: i64 = nrm[r*3 + 2]
      var sxv: i64 = 0
      var syv: i64 = 0
      var szv: i64 = 0
      if sa == 0 { sxv = 0 - GR_Q10 }
      if sa == 1 { syv = 0 - GR_Q10 }
      if sa == 2 { szv = 0 - GR_Q10 }
      let backq: i64 = (0 - fsign)*GR_COMB_BACK_Q10
      if aa == 0 { sxv = sxv + backq }
      if aa == 1 { syv = syv + backq }
      if aa == 2 { szv = szv + backq }
      let sdn: i64 = (sxv*nx9 + syv*ny9 + szv*nz9)/GR_Q10
      var dx: i64 = sxv - nx9*sdn/GR_Q10 + nx9*GR_COMB_LIFT_Q10/GR_Q10
      var dy: i64 = syv - ny9*sdn/GR_Q10 + ny9*GR_COMB_LIFT_Q10/GR_Q10
      var dz: i64 = szv - nz9*sdn/GR_Q10 + nz9*GR_COMB_LIFT_Q10/GR_Q10
      let dln: i64 = gr_isqrt(dx*dx + dy*dy + dz*dz)
      if dln > 0 { dx = dx*GR_Q10/dln; dy = dy*GR_Q10/dln; dz = dz*GR_Q10/dln } else { dz = 0 - GR_Q10 }
      // LAYERING: spawn height above the nape line scales length down (crown shortest)
      var rst9: i64 = roots[r*3 + sa]
      if sa == 0 { rst9 = roots[r*3] }
      if sa == 1 { rst9 = roots[r*3 + 1] }
      if sa == 2 { rst9 = roots[r*3 + 2] }
      let napebase9: i64 = cht - span*GR_NAPE_PERMIL/1000
      var crown_q10: i64 = 0
      let headspan9: i64 = stop - napebase9
      if headspan9 > 0 { crown_q10 = (rst9 - napebase9)*GR_Q10/headspan9 }
      if crown_q10 < 0 { crown_q10 = 0 }
      if crown_q10 > GR_Q10 { crown_q10 = GR_Q10 }
      let slen9: i64 = total_len*(GR_Q10 - crown_q10*GR_LAYER_Q10/GR_Q10)/GR_Q10
      // scalp-hugging spacing: seg_i = slen*(i+2)/35 (sum over 7 segments = slen)
      let segbase9: i64 = slen9/35
      let r0x: i64 = px - cx
      let r0y: i64 = py - cy
      let r0z: i64 = pz - cz
      var r0len: i64 = gr_isqrt(r0x*r0x + r0y*r0y + r0z*r0z)
      // face-wardness (Q10, 0 when back-facing) and the root's lateral side sign
      var rant0: i64 = r0z
      if aa == 0 { rant0 = r0x }
      if aa == 1 { rant0 = r0y }
      var rlat0: i64 = r0y
      if la == 0 { rlat0 = r0x }
      if la == 2 { rlat0 = r0z }
      var facew: i64 = 0
      if r0len > 0 { facew = rant0*fsign*GR_Q10/r0len }
      if facew < 0 { facew = 0 }
      var lsgn: i64 = 1
      if rlat0 < 0 { lsgn = 0 - 1 }
      if r0len < 1 { r0len = 1 }
      // wave phase seeded per strand so locks differ without frizz
      let wph9: i64 = gr_hash(seed, r) % GR_Q10
      var p: i64 = 0
      while p < GR_PTS {
          let base: i64 = 1 + r*GR_WORDS + p*3
          hw[base] = px
          hw[base + 1] = py
          hw[base + 2] = pz
          // blend toward gravity (down the stature axis) as the strand extends
          var g: i64 = p*GR_GRAVITY_RAMP_Q10
          if g > GR_Q10 { g = GR_Q10 }
          var gx: i64 = 0
          var gy: i64 = 0
          var gz: i64 = 0
          if sa == 0 { gx = 0 - GR_Q10 }
          if sa == 1 { gy = 0 - GR_Q10 }
          if sa == 2 { gz = 0 - GR_Q10 }
          var sx: i64 = (dx*(GR_Q10 - g) + gx*g)/GR_Q10
          var sy: i64 = (dy*(GR_Q10 - g) + gy*g)/GR_Q10
          var sz: i64 = (dz*(GR_Q10 - g) + gz*g)/GR_Q10
          // COSMETOLOGY RULE (operator brief): hair never falls TOWARD the face -- clamp the
          // growth direction's anterior component at zero once it points face-ward, so front
          // roots sweep back and sideways instead of curtaining the eyes.
          // SIGN CORRECTED (operator: "back entirely empty, like reversed"): a face-ward
          // component has the SAME sign as fsign (front lies at fsign-signed anterior), so the
          // clamp fires on product > 0. The inverted form clamped BACK-ward flow -- every
          // strand could only drape forward: face curtained, occiput bare.
          if aa == 0 { if sx*fsign > 0 { sx = 0 } }
          if aa == 1 { if sy*fsign > 0 { sy = 0 } }
          if aa == 2 { if sz*fsign > 0 { sz = 0 } }
          // side-sweep: face-adjacent strands flow toward their own side
          let sw9: i64 = facew*GR_SWEEP_Q10/GR_Q10*lsgn
          if la == 0 { sx = sx + sw9 }
          if la == 1 { sy = sy + sw9 }
          if la == 2 { sz = sz + sw9 }
          let sl: i64 = gr_isqrt(sx*sx + sy*sy + sz*sz)
          if sl > 0 { sx = sx*GR_Q10/sl; sy = sy*GR_Q10/sl; sz = sz*GR_Q10/sl }
          // WAVES: clean sine on the LATERAL axis (integer sine via triangle approx of the
          // phase -- smooth at 8 points), amplitude a small fraction of segment length
          let seg: i64 = segbase9*(p + 2)
          let ph9: i64 = (wph9 + p*GR_WAVE_STEP_Q10) % (2*GR_Q10)
          var tri9: i64 = ph9
          if tri9 > GR_Q10 { tri9 = 2*GR_Q10 - tri9 }
          let wav9: i64 = (tri9*2 - GR_Q10)*GR_WAVE_AMP_PERMIL/1000
          var wx9: i64 = 0
          var wy9: i64 = 0
          var wz9: i64 = 0
          if la == 0 { wx9 = wav9 }
          if la == 1 { wy9 = wav9 }
          if la == 2 { wz9 = wav9 }
          px = px + (sx + wx9)*seg/GR_Q10
          py = py + (sy + wy9)*seg/GR_Q10
          pz = pz + (sz + wz9)*seg/GR_Q10
          // SCALP CONFORMANCE (data-space plot 2026-08-26 showed the groom as a detached
          // curtain floating behind the head): while above head-centre height, clamp the
          // point to the skull shell -- distance from head centre <= the ROOT's own radius
          // (+15 percent breathing room, a named tolerance). Strands wrap the skull and only
          // hang free below the centre line, like combed hair on a real head.
          if pz > cht {
              let qx: i64 = px - cx
              let qy: i64 = py - cy
              let qz: i64 = pz - cz
              let qd: i64 = gr_isqrt(qx*qx + qy*qy + qz*qz)
              let rmax: i64 = r0len*104/100  // 104%: the 115% slack read as hair FLOATING off the scalp (operator 2026-08-27); one mesh-cell of clearance is all a lying groom needs
              if qd > rmax { if qd > 0 {
                  px = cx + qx*rmax/qd
                  py = cy + qy*rmax/qd
                  pz = cz + qz*rmax/qd
              } }
          }
          p = p + 1
      }
      r = r + 1
  }
  let dwords: i64 = 1 + nr*GR_WORDS
  gr_out("  strands=" as *u8); gr_num(nr)
  gr_out(" length=" as *u8); gr_num(total_len)
  gr_out(" seg=" as *u8); gr_num(seg); gr_out("\n" as *u8)
551
  // ---- rebuild the file with HSTR replaced (nx_nxa_dyna machinery) ----
  var nsec: i64 = ns
  if hsi < 0 { nsec = ns + 1 }
  let toclen: i64 = GR_HDR + nsec*GR_TOCE
  var total: i64 = toclen
  var s2: i64 = 0
  while s2 < ns {
      if s2 != hsi {
          let e2s: i64 = GR_HDR + s2*GR_TOCE
          total = total + gr_rd64(b, e2s + 16)*8
      }
      s2 = s2 + 1
  }
  total = total + dwords*8
  let nb: *u8 = sys_mmap(total + 4096)
  if (nb as i64) == 0 { gr_err("GROOM-RED alloc\n" as *u8); sys_exit(1); return 1 }
  gr_wr64(nb, 0, nxa_magic())
  gr_wr64(nb, 8, NXA_VER)
  gr_wr64(nb, 16, nsec)
  var wo: i64 = toclen
  var ti: i64 = 0
  var s3: i64 = 0
  while s3 < ns {
      if s3 != hsi {
          let e3s: i64 = GR_HDR + s3*GR_TOCE
          let oldoff: i64 = gr_rd64(b, e3s + 8)
          let wl: i64 = gr_rd64(b, e3s + 16)
          let te: i64 = GR_HDR + ti*GR_TOCE
          gr_wr64(nb, te, gr_rd64(b, e3s))
          gr_wr64(nb, te + 8, wo)
          gr_wr64(nb, te + 16, wl)
          var k2: i64 = 0
          while k2 < wl*8 { nb[wo + k2] = b[oldoff + k2]; k2 = k2 + 1 }
          let pw: *i64 = ((nb as i64) + wo) as *i64
          gr_wr64(nb, te + 24, nxa_check2(1, pw, wl))
          wo = wo + wl*8
          ti = ti + 1
      }
      s3 = s3 + 1
  }
  let dstart: i64 = wo
  var w3: i64 = 0
  while w3 < dwords { gr_wr64(nb, wo, hw[w3]); wo = wo + 8; w3 = w3 + 1 }
  let dte: i64 = GR_HDR + ti*GR_TOCE
  gr_wr64(nb, dte, nxa_tag4("HSTR" as *u8))
  gr_wr64(nb, dte + 8, dstart)
  gr_wr64(nb, dte + 16, dwords)
  let dpw: *i64 = ((nb as i64) + dstart) as *i64
  gr_wr64(nb, dte + 24, nxa_check2(1, dpw, dwords))
  let tbp: *i64 = ((nb as i64) + GR_HDR) as *i64
  gr_wr64(nb, 24, nxa_check2(1, tbp, nsec*4))
603
  let fd: i64 = sys_openat_wr(outp, GR_MODE)
  if fd < 0 { gr_err("GROOM-RED cannot open output\n" as *u8); sys_exit(1); return 1 }
  var w2: i64 = 0
  while w2 < wo {
      let kk: i64 = sys_write(fd, ((nb as i64) + w2) as *u8, wo - w2)
      if kk <= 0 { sys_close(fd); gr_err("GROOM-RED short write\n" as *u8); sys_exit(1); return 1 }
      w2 = w2 + kk
  }
  sys_close(fd)
  gr_out("GROOM-GREEN strands=" as *u8); gr_num(nr)
  gr_out(" length_permil=" as *u8); gr_num(lenp)
  gr_out(" bytes=" as *u8); gr_num(wo)
  gr_out("\n  <- full-scalp procedural groom: generated, seeded, parameterized -- no asset.\n" as *u8)
  sys_exit(0)
  return 0
619}
nx_nxa_groom.nx source

`nx_nxa_groom.nx` source
