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

↩ module page · 270 lines · 13249 B
1// nx_char_identity_sheet.nx -- the LOOK-AT-IT proof for the identity vector. Numeric gates cannot see
2// framing (this lane has been burned 3x by that), so this emits the sheet a character artist would ask
3// for: ONE identity rendered across four art styles (she must stay recognisably herself), a CAST row of
4// distinct identities (they must not be one woman recoloured), and a genetics row showing sisters whose
5// alleles differ. Every figure is drawn from the SAME dial vector via the same draw call.
6// license_tier: ORIGINAL
7import "nx_syscalls.nx"
8import "nx_char_identity.nx"
9import "nx_game_raster.nx"
10import "nx_game_art.nx"
11import "nx_game_critic.nx"
12import "nx_anatomy_critic.nx"
13import "nx_png_write.nx"
14
15const SW: i64 = 720
16const SH: i64 = 460
17
18func sp2(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
19func sn2(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
32}
33func snl() -> i64 { sp2("\n" as *u8); return 0 }
34
35func isqrt2(n: i64) -> i64 {
  if n <= 0 { return 0 }
  var x: i64 = n
  var y: i64 = (x + 1) / 2
  var g: i64 = 0
  while g < 40 { if y < x { x = y; y = (x + n / x) / 2 } g = g + 1 }
  return x
42}
43// a shaded ellipse in the packed-i64 fb (light upper-left), so figures read as volumes not flat fills
44func fig_ell(fb: *i64, cx: i64, cy: i64, rx: i64, ry: i64, r: i64, g: i64, b: i64) -> i64 {
  if rx <= 0 { return 0 }
  if ry <= 0 { return 0 }
  var y: i64 = 0 - ry
  while y <= ry {
      var x: i64 = 0 - rx
      while x <= rx {
          let a: i64 = x*x*10000/(rx*rx) + y*y*10000/(ry*ry)
          if a <= 10000 {
              var lit: i64 = 100 + (0 - x) * 40 / rx + (0 - y) * 40 / ry
              if lit < 55 { lit = 55 }
              if lit > 165 { lit = 165 }
              let rr: i64 = idv_clamp(r * lit / 100, 0, 255)
              let gg: i64 = idv_clamp(g * lit / 100, 0, 255)
              let bb: i64 = idv_clamp(b * lit / 100, 0, 255)
              gr_px(fb, SW, SH, cx + x, cy + y, gr_pack(rr, gg, bb))
          }
          x = x + 1
      }
      y = y + 1
  }
  return 0
66}
67
68// ★ONE draw call for every figure on this sheet. It reads ONLY the identity vector + the style params,
69// so "the same woman in another style" is structurally the same call with a different head ratio.
70// A schematic figure, deliberately: this lane owns CONSISTENCY, the procgen lane owns fidelity.
71func draw_figure(fb: *i64, idv: *i64, style: i64, ox: i64, oy: i64, hgt: i64) -> i64 {
  let sp: *i64 = sys_mmap(16 * 8) as *i64
  idv_style_params(idv, style, sp)
  let headr: i64 = sp[0]                       // q10 head-to-body ratio: 137 realistic .. 341 cartoon
  let bigeyes: i64 = sp[2]
  let skin: i64 = idv[IDV_SKIN]
  let sr: i64 = skin & 255
  let sg: i64 = (skin >> 8) & 255
  let sb: i64 = (skin >> 16) & 255
  let hair: i64 = idv[IDV_HAIR]
  let eye: i64 = idv[IDV_EYE]
  // proportions: head size scales with the STYLE, body landmarks with the IDENTITY
  let head: i64 = hgt * headr / 1000
  let lbr: i64 = idv[IDV_LBR]                  // leg fraction, per-mille
  let legs: i64 = hgt * lbr / 1000
  let torso: i64 = hgt - legs - head
  // ★WIDTHS FROM MEASURED ANTHROPOMETRY, not eyeballed. The first version used ~105/1000 of height for
  // shoulder breadth (~19%) and thighs at ~7%, which rendered as stick insects and scored taper 0 on
  // nx_anatomy_critic -- no waist at all. Real adult female fractions of stature: biacromial breadth
  // ~0.23, hip breadth ~0.19, waist ~0.15, thigh ~0.10. Dials modulate AROUND those, they do not
  // replace them, so every identity stays inside the human envelope.
  let shoulder: i64 = hgt * 230 / 1000 + idv[IDV_D0] * hgt / 4000
  let waist: i64 = hgt * 150 / 1000 + idv[IDV_D1] * hgt / 6000
  let hip: i64 = shoulder * 100 / idv[IDV_SHIP] + idv[IDV_D2] * hgt / 5000
  let bust: i64 = hgt * 62 / 1000 + idv[IDV_D3] * hgt / 4500
  let feet: i64 = oy + hgt
  let hipy: i64 = feet - legs
  let shy: i64 = hipy - torso
  let heady: i64 = shy - head/2
  // ★GEOMETRY CORRECTED 2026-07-27 after nx_anatomy_critic rejected the first version: the head floated
  // free (no neck), the torso lobes were narrower than the leg mass, and an oversized hair ellipse read
  // as the widest thing on the figure -- so the silhouette had no shoulder>waist<hip taper at all.
  // legs (drawn first, behind) -- overlap the hips so the body stays ONE connected component
  // thighs at ~0.10 of stature each, tapering to the ankle -- upper leg then lower leg
  let thigh: i64 = hgt * 100 / 1000
  fig_ell(fb, ox - hip/4, hipy + legs/4, thigh/2, legs/2, sr, sg, sb)
  fig_ell(fb, ox + hip/4, hipy + legs/4, thigh/2, legs/2, sr, sg, sb)
  fig_ell(fb, ox - hip/4, hipy + legs*3/4, thigh/3, legs/2, sr, sg, sb)
  fig_ell(fb, ox + hip/4, hipy + legs*3/4, thigh/3, legs/2, sr, sg, sb)
  // arms (behind the torso, so they never break the silhouette's waist reading)
  fig_ell(fb, ox - shoulder/2, shy + torso/2, hgt*32/1000+1, torso*2/5, sr, sg, sb)
  fig_ell(fb, ox + shoulder/2, shy + torso/2, hgt*32/1000+1, torso*2/5, sr, sg, sb)
  // torso: shoulders -> waist -> hips, overlapping vertically so it reads as one mass
  fig_ell(fb, ox, shy + torso/4, shoulder/2, torso*3/10, sr, sg, sb)
  fig_ell(fb, ox, shy + torso/2, waist/2, torso*3/10, sr, sg, sb)
  fig_ell(fb, ox, hipy - torso/6, hip/2, torso*3/10, sr, sg, sb)
  if bust > 2 {
      fig_ell(fb, ox - bust/3, shy + torso/3, bust/2, bust/2, sr, sg, sb)
      fig_ell(fb, ox + bust/3, shy + torso/3, bust/2, bust/2, sr, sg, sb)
  }
  // ★NECK -- the single most important fix. It bridges head to shoulders, which is what makes this
  // one connected body instead of a torso with a balloon above it.
  fig_ell(fb, ox, shy - head/6, head/5 + 1, head/3 + 2, sr, sg, sb)
  // hair mass BEHIND the head -- kept strictly narrower than the shoulders so the taper still reads
  let hs: i64 = idv[IDV_HAIRSTYLE]
  var hairw: i64 = head/2 + head/10
  if hairw > shoulder*2/5 { hairw = shoulder*2/5 }
  fig_ell(fb, ox, heady, hairw, head/2 + head/8 + hs*head/60,
          hair & 255, (hair >> 8) & 255, (hair >> 16) & 255)
  // head
  fig_ell(fb, ox, heady, head/2, head/2, sr, sg, sb)
  // eyes -- the style decides SIZE (anime/VN read through the eyes), identity decides COLOUR
  var er: i64 = head/9 + 1
  if bigeyes == 1 { er = head/5 + 1 }
  gr_disc(fb, SW, SH, ox - head/4, heady, er, gr_pack(250,250,255))
  gr_disc(fb, SW, SH, ox + head/4, heady, er, gr_pack(250,250,255))
  gr_disc(fb, SW, SH, ox - head/4, heady, er*2/3, gr_pack(eye & 255, (eye >> 8) & 255, (eye >> 16) & 255))
  gr_disc(fb, SW, SH, ox + head/4, heady, er*2/3, gr_pack(eye & 255, (eye >> 8) & 255, (eye >> 16) & 255))
  gr_disc(fb, SW, SH, ox - head/4 - er/3, heady - er/3, er/4+1, gr_pack(255,255,255))
  gr_disc(fb, SW, SH, ox + head/4 - er/3, heady - er/3, er/4+1, gr_pack(255,255,255))
  return 0
142}
143
144func sheet_png(fb: *i64, path: *u8) -> i64 {
  let rgb: *u8 = sys_mmap(SW*SH*3) as *u8
  var p2: i64 = 0
  let n: i64 = SW*SH
  while p2 < n {
      let v: i64 = fb[p2]
      rgb[p2*3] = (v & 0xff) as u8
      rgb[p2*3+1] = ((v >> 8) & 0xff) as u8
      rgb[p2*3+2] = ((v >> 16) & 0xff) as u8
      p2 = p2 + 1
  }
  return nx_png_write_rgb(path, rgb, SW, SH)
156}
157
158func main() -> i64 {
  let fb: *i64 = sys_mmap(SW*SH*8) as *i64
  art_nebula(fb, SW, SH, 14, 12, 30, 32, 22, 54)
  let ink: i64 = gr_pack(238,234,255)
  let dim: i64 = gr_pack(152,148,182)
  let hot: i64 = gr_pack(255,200,110)
164
  gr_rect(fb, SW, SH, 0, 0, SW-1, 24, gr_pack(16,14,34))
  gr_text(fb, SW, SH, 10, 8, "NISHI CHARACTER IDENTITY -- one token, one woman, any style" as *u8, ink)
167
  // ---- ROW 1: THE SAME IDENTITY IN FOUR ART STYLES ----
  let her: *i64 = sys_mmap(IDV_SLOTS * 8) as *i64
  idv_from_seed(her, 8675309)
  gr_rect(fb, SW, SH, 8, 32, SW-9, 34, gr_pack(70,62,120))
  var hx: i64 = gr_text(fb, SW, SH, 12, 40, "SAME identity token (key " as *u8, dim)
  hx = gr_num(fb, SW, SH, hx, 40, idv_key(her) % 1000000, hot)
  gr_text(fb, SW, SH, hx, 40, ") rendered in 4 art styles -- identity fields BYTE-IDENTICAL across all four" as *u8, dim)
  var st: i64 = 0
  while st < 4 {
      let cx: i64 = 92 + st * 172
      draw_figure(fb, her, st, cx, 62, 150)
      gr_text(fb, SW, SH, cx - 28, 220, idv_style_name(st), ink)
      st = st + 1
  }
182
  // ---- ROW 2: THE CAST -- distinct identities, proving no mode collapse ----
  gr_rect(fb, SW, SH, 8, 236, SW-9, 238, gr_pack(70,62,120))
  gr_text(fb, SW, SH, 12, 244, "DISTINCT identities from distinct seeds -- different women, not recolours" as *u8, dim)
  var i: i64 = 0
  while i < 8 {
      let cast: *i64 = sys_mmap(IDV_SLOTS * 8) as *i64
      idv_from_seed(cast, 1000003 + i * 7919)
      draw_figure(fb, cast, 1, 52 + i * 84, 262, 108)
      i = i + 1
  }
193
  // ---- ROW 3: SISTERS -- same parents, different alleles ----
  gr_rect(fb, SW, SH, 8, 386, SW-9, 388, gr_pack(70,62,120))
  gr_text(fb, SW, SH, 12, 394, "GENETICS: her genome IS her face -- coat locus drives hair, polygenic dose drives height" as *u8, dim)
  var k: i64 = 0
  var lastkey: i64 = 0
  var distinct: i64 = 0
  while k < 8 {
      let sis: *i64 = sys_mmap(IDV_SLOTS * 8) as *i64
      var g: i64 = gx_set(0, GX_COAT, k % 2, (k/2) % 2)
      g = gx_set(g, GX_HORN, (k/4) % 2, k % 2)
      g = gx_set(g, GX_ELEM, k % 3, (k+1) % 3)
      idv_from_companion(sis, g, 60 + k*24, gx_sexgene(GX_SEX_F, 1, 0), 0, k)
      draw_figure(fb, sis, 1, 52 + k * 84, 404, 46)
      if idv_key(sis) != lastkey { distinct = distinct + 1 }
      lastkey = idv_key(sis)
      k = k + 1
  }
211
  sheet_png(fb, "knowledge/nx_char_identity_sheet.png" as *u8)
213
  // ---- measure: consistency + diversity, the two things this lane can honestly claim ----
  let a: *i64 = sys_mmap(IDV_SLOTS * 8) as *i64
  let b: *i64 = sys_mmap(IDV_SLOTS * 8) as *i64
  idv_from_seed(a, 8675309)
  idv_from_seed(b, 8675309)
  var styles_same: i64 = 1
  var s2: i64 = 0
  while s2 < 4 {
      b[IDV_STYLE] = s2
      if idv_same(a, b) == 0 { styles_same = 0 }
      s2 = s2 + 1
  }
  var dsum: i64 = 0
  var pairs: i64 = 0
  var x: i64 = 0
  while x < 8 {
      let p1: *i64 = sys_mmap(IDV_SLOTS * 8) as *i64
      idv_from_seed(p1, 1000003 + x * 7919)
      var y: i64 = x + 1
      while y < 8 {
          let p2b: *i64 = sys_mmap(IDV_SLOTS * 8) as *i64
          idv_from_seed(p2b, 1000003 + y * 7919)
          dsum = dsum + idv_distance(p1, p2b)
          pairs = pairs + 1
          y = y + 1
      }
      x = x + 1
  }
  let cout: *i64 = sys_mmap(GC_N * 8) as *i64
  gc_score(fb, SW, SH, cout)
  let q: i64 = gc_quality(cout)
  // ★ANATOMY is the number that decides whether these are BODIES. Richness scored the previous, broken
  // version 876=SOTA while its heads floated -- so richness is reported here only as context, never as
  // the verdict. Score the row-1 realistic figure, on its own background patch.
  let aout: *i64 = sys_mmap(AC2_N * 8) as *i64
  let bgpix: i64 = fb[6 * SW + 6]
  ac2_score(fb, SW, SH, 40, 44, 148, 214, bgpix, 0, aout)
  let anat: i64 = ac2_quality(aout)
252
  sp2("=== nx_char_identity_sheet: identity sheet emitted ===\n" as *u8)
  sp2("  frame knowledge/nx_char_identity_sheet.png (720x460)\n" as *u8)
  sp2("  identity held across all 4 art styles: " as *u8); sn2(styles_same); snl()
  sp2("  cast mean pairwise identity distance: " as *u8); sn2(dsum / pairs)
  sp2(" over " as *u8); sn2(pairs); sp2(" pairs\n" as *u8)
  sp2("  sisters with distinct genomes: " as *u8); sn2(distinct); sp2("/8\n" as *u8)
  sp2("  ANATOMY (the verdict): " as *u8); sn2(anat); sp2(" = " as *u8); sp2(ac2_verdict(anat))
  sp2("   [conn " as *u8); sn2(aout[AC2_M_CONN]); sp2(" head " as *u8); sn2(aout[AC2_M_HEAD])
  sp2(" taper " as *u8); sn2(aout[AC2_M_TAPER]); sp2(" vbal " as *u8); sn2(aout[AC2_M_VBAL])
  sp2(" limb " as *u8); sn2(aout[AC2_M_LIMB]); sp2("]\n" as *u8)
  sp2("  richness (CONTEXT ONLY, not the verdict): " as *u8); sn2(q); sp2(" = " as *u8); sp2(gc_verdict(q)); snl()
  sp2("  ★HONEST SCOPE: this sheet proves CONSISTENCY, DIVERSITY and that the figures READ AS BODIES.\n" as *u8)
  sp2("   It does NOT claim beauty -- the optimum flips with stimulus realism, so a beauty judge at this\n" as *u8)
  sp2("   fidelity would teach the WRONG target. Fidelity is the procgen lane's job.\n" as *u8)
  if styles_same == 1 { if distinct >= 7 { if anat >= AC2_CRUDE { return 0 } } }
  sp2("REFUSED: the sheet did not meet its own bar\n" as *u8)
  return 1
270}
nx_char_identity_sheet.nx source

`nx_char_identity_sheet.nx` source
