code wiki / (root) / nx_garment_canonical_prepare_t135.nx
`nx_garment_canonical_prepare_t135.nx` source

↩ module page · 1506 lines · 68319 B
1import "nx_nxa_garment_bind_lib.nx"
2// nx_garment_gen_lib.nx -- CONFORMING GARMENT MESHES GENERATED FROM THE BODY SURFACE (2026-08-30,
3// gameengine gpe_garment_draw paint->mesh; operator: "the clothes are paint not objects").
4//
5// WHAT IT BUILDS. For every garment id of the engine's table (1 bikini top . 2 bikini bottom . 3 one-piece
6// . 4 sarong knot . 5 sundress bodice . 6 tee . 7 shorts . 8 skirt waistband . 9 evening bodice) a SHELL:
7// the body triangles the garment covers, offset along the body's own smooth vertex normals by fabric
8// thickness + wearing ease, its open boundary CLOSED by a hem strip (the fabric's edge face, so the cloth
9// has a visible thickness), a raised binding band one ring inside every opening (the elastic / folded
10// hem), a PUSH-OUT pass that walks any vertex the offset dropped into a fold back out until no body vertex
11// sits inside the fabric, and RIBBON STRAPS between anatomical anchors for the strapped ids. Every garment
12// vertex records the BODY VERTEX it was grown from, so the page skins it with that vertex's own joint
13// weights and it rides pose, gait and the soft-tissue fields exactly as the skin under it does
14// (layering by construction: a layer that rides its underlayer's field cannot be pierced by it).
15//
16// UNITS. Mesh units: 171530 per 1.78 m (the page's own pairing) => 96.37 units per mm. Heights are in
17// DECIMIL of the mesh's own measured stature ((z - zmin) * 10000 / H). Normals and blend weights are Q12.
18// Thickness and ease are DERIVED from micrometres in gmg_mat, with the source of each number beside it.
19//
20// SECTION EMITTED: "GARM" (one tag, one checksum) =
21//   header  [ver=20260830, nkinds, vstride=5, tstride=3, units_per_mm_x1000, dirstride=8, total_words, 0]
22//   dir     nkinds x [id, nverts, ntris, voff(words from section start), toff, thickness_units, ease_units, class]
23//   verts   [x, y, z, src_body_vertex, flag]   flag 0 shell . 1 hem . 2 strap
24//   tris    [a, b, c] local to the kind
25// Normals are NOT shipped: the page already accumulates area-weighted smooth normals for the skirt mesh
26// and does the same here (hem strips and straps carry their own copies of the shared vertices, so their
27// faces get their own normals). license_tier: ORIGINAL. No hw writes (Rule 26).
28import "nx_syscalls.nx"
29import "nx_nxa.nx"
30
31const GMG_Q: i64 = 4096
32const GMG_DM: i64 = 10000
33const GMG_UNITS_178: i64 = 171530
34const GMG_MM_178: i64 = 1780
35const GMG_UM_PER_MM: i64 = 1000
36const GMG_TWO_PI_MILLI: i64 = 6283
37const GMG_KINDS: i64 = 9
38const GMG_VSTRIDE: i64 = 5
39const GMG_TSTRIDE: i64 = 3
40const GMG_DIRSTRIDE: i64 = 8
41const GMG_HDR: i64 = 8
42const GMG_GARM_VER: i64 = 20260830
43const GMG_NBR_CAP: i64 = 32
44const GMG_BADJ_CAP: i64 = 4
45const GMG_OV_CAP: i64 = 16384
46const GMG_OT_CAP: i64 = 32768
47const GMG_SEC_CAP: i64 = 262144
48const GMG_STAT_N: i64 = 32
49const GMG_PUSH_PASSES: i64 = 8
50const GMG_SKEL_STRIDE: i64 = 8
51const GMG_SKIN_STRIDE: i64 = 8
52const GMG_DYN_FIELDS: i64 = 8
53const GMG_STRAP_K: i64 = 9
54const GMG_STRAP_CAP: i64 = 24
55const GMG_BIG: i64 = 4611686018427387903
56const GMG_ISQRT_HI: i64 = 3037000499
57const GMG_CROSS_SHIFT: i64 = 64
58const GMG_NRM_CAP: i64 = 1000000
59
60// flags
61const GMG_F_SHELL: i64 = 0
62const GMG_F_HEM: i64 = 1
63const GMG_F_STRAP: i64 = 2
64// material classes (the page's fabric BRDF keys on these)
65const GMG_M_SWIM: i64 = 1
66const GMG_M_WOVEN: i64 = 2
67const GMG_M_JERSEY: i64 = 3
68const GMG_M_SATIN: i64 = 4
69// refusals (negative returns; the program maps them to exit codes and NAMES them)
70const GMG_ERR_BADNXA: i64 = 0 - 5
71const GMG_ERR_REFUSED_THICK: i64 = 0 - 4
72const GMG_ERR_EMPTY: i64 = 0 - 6
73const GMG_ERR_CAP: i64 = 0 - 7
74
75// ---- anatomy (decimil of stature unless noted) -- every number names its source ----
76const GMG_TORSO_HALFW: i64 = 15000     // the page shader's own torso gate (|bind x| < 15000)
77const GMG_ARM_BIND_X: i64 = 12000      // a dominant joint this far off the midline is an arm joint
78const GMG_HEAD_DM: i64 = 8600          // above the chin line (.885 H) a dominant joint is a head joint
79const GMG_FRONT_Y: i64 = 0 - 1200      // the page's bust-side convention: front is y < -1200
80const GMG_YBLEND: i64 = 1200           // front/back blend half-width (units) for the leg/neck lines
81const GMG_HIP_DM: i64 = 5450           // hip band top (.545 H), the incumbent paint band's own edge
82const GMG_CROTCH_DM: i64 = 4750        // crotch .475 H (Drillis-Contini 1966)
83const GMG_KNEE_DM: i64 = 2850          // knee .285 H (Drillis-Contini 1966, the page's own gdJn(.285))
84const GMG_HIPJ_DM: i64 = 5200          // hip joint .52 H (Drillis-Contini) -- the anchor the page maps NIP through
85const GMG_EYE_DM: i64 = 9300           // eye line .93 H, the second anchor
86const GMG_NIP_RATIO_DM: i64 = 7200     // published nipple ratio .72 H before the per-mesh anchor mapping
87const GMG_HEADJ_PROBE_DM: i64 = 9500
88const GMG_BUST_HALF_DM: i64 = 550      // the nipple detail's own half-width (.055 H)
89const GMG_EASE_FADE_LO: i64 = 7400     // ease fades to zero over the bust->shoulder band so necklines hug
90const GMG_EASE_FADE_HI: i64 = 8000
91const GMG_MIDTHIGH_DM: i64 = 4025      // (hip .52 + knee .285) / 2 -- Drillis-Contini mid-thigh, the shorts hem
92const GMG_SHORTS_TOP_DM: i64 = 5600
93const GMG_TEE_NECK_DM: i64 = 8350      // crew neck front: .835 H (acromion .818 + a finger)
94const GMG_TEE_NECK_RISE: i64 = 300
95const GMG_SLEEVE_TOP_DM: i64 = 7400
96const GMG_SLEEVE_HALFW: i64 = 19000    // short-sleeve cap reach off the midline (units)
97const GMG_SLEEVE_BAND_LO: i64 = 7800
98const GMG_SLEEVE_BAND_HI: i64 = 8700
99const GMG_SLEEVE_X_LO: i64 = 12000
100const GMG_ONEPIECE_NECK_F: i64 = 7700  // one-piece scoop front .77 H
101const GMG_ONEPIECE_NECK_B: i64 = 7000  // one-piece back .70 H
102const GMG_STRAP_SHOULDER_DM: i64 = 8580
103const GMG_STRAP_BAND_TOL_DM: i64 = 120 // bikini back band half-height
104const GMG_SARONG_X: i64 = 13500        // the knot sits on the hip side
105const GMG_SARONG_DM: i64 = 6150
106const GMG_SARONG_R: i64 = 5000
107const GMG_WAIST_BAND_DM: i64 = 150     // skirt waistband half-height around the skirt's own top ring
108const GMG_SKIRT_TOP_TOL_DM: i64 = 300
109const GMG_STRAP_SEARCH_DM: i64 = 700
110const GMG_STRAP_AX_MAX: i64 = 14500
111const GMG_STRAP_AX_FRONT: i64 = 9000
112const GMG_STRAP_Y_FRONT: i64 = 0 - 9000
113const GMG_STRAP_AX_SHOULDER: i64 = 11400
114const GMG_STRAP_Y_SHOULDER: i64 = 2000
115const GMG_STRAP_AX_BACK: i64 = 8000
116const GMG_STRAP_Y_BACK: i64 = 9000
117const GMG_STRAP_HALFW_BIKINI_UM: i64 = 6000    // 12 mm bikini strap
118const GMG_STRAP_HALFW_DRESS_UM: i64 = 10000    // 20 mm dress / one-piece strap
119const GMG_SWIM_INNER_UM: i64 = 200             // a swim hem's inner edge is pressed to the skin (0.2 mm)
120const GMG_PUSH_MARGIN: i64 = 2
121const GMG_CLEAR_PERMIL: i64 = 900              // the clearance tooth's bar: 0.9 t (vertex-to-vertex is an
                                             // UPPER bound on vertex-to-surface -- declared imprecision)
123const GMG_CLEAR_REPORT_MULT: i64 = 4
124
125// ---- fabric table sources (all DECLARED until a bench swatch measures the real blanks; garment_twin.conf
126// carries the same honesty). Thickness: ASTM D1777 handbook classes -- nylon/elastane swim tricot ~0.55 mm,
127// cotton single jersey (160-180 g/m2) ~0.7 mm, cotton poplin ~0.35 mm, polyester charmeuse ~0.25 mm.
128// Ease: Aldrich, Metric Pattern Cutting for Women's Wear; Armstrong, Patternmaking for Fashion Design --
129// a basic tee carries ~7.5 cm of bust ease, a trouser/short block ~7.6 cm (3 in) of hip ease, an evening
130// (fitted) block ~6.4 cm (2.5 in); two-way-stretch swimwear is cut with NEGATIVE ease and sits at skin +
131// fabric, so its radial ease is zero. Hem: a swim opening carries a ~1.0 mm elastic under two plies; a
132// woven/jersey hem is a two-ply fold. Circumferential ease becomes radial ease by / 2 pi.
133const GMG_T_SWIM_UM: i64 = 550
134const GMG_T_JERSEY_UM: i64 = 700
135const GMG_T_WOVEN_UM: i64 = 350
136const GMG_T_SARONG_UM: i64 = 300
137const GMG_T_SATIN_UM: i64 = 250
138const GMG_ELASTIC_UM: i64 = 1000
139const GMG_EASE_TEE_UM: i64 = 75000
140const GMG_EASE_SHORTS_UM: i64 = 76200
141const GMG_EASE_DRESS_UM: i64 = 75000
142const GMG_EASE_EVENING_UM: i64 = 63500
143const GMG_EASE_KNOT_RADIAL_UM: i64 = 30000
144
145// ---- context slots (one *i64 block; pointers stored as i64) ----
146const GMG_C_B: i64 = 0
147const GMG_C_FLEN: i64 = 1
148const GMG_C_POS: i64 = 2
149const GMG_C_NV: i64 = 3
150const GMG_C_IDX: i64 = 4
151const GMG_C_NT: i64 = 5
152const GMG_C_NRM: i64 = 6
153const GMG_C_ZMN: i64 = 7
154const GMG_C_H: i64 = 8
155const GMG_C_HH: i64 = 9
156const GMG_C_AX: i64 = 10
157const GMG_C_VF: i64 = 11
158const GMG_C_NIP: i64 = 12
159const GMG_C_DYN: i64 = 13
160const GMG_C_ND: i64 = 14
161const GMG_C_GTH: i64 = 15
162const GMG_C_GAP: i64 = 16
163const GMG_C_YMID: i64 = 17
164const GMG_C_BIND: i64 = 18
165const GMG_C_NJ: i64 = 19
166const GMG_C_VMAP: i64 = 20
167const GMG_C_INNER: i64 = 21
168const GMG_C_SEL: i64 = 22
169const GMG_C_NBR: i64 = 23
170const GMG_C_NBC: i64 = 24
171const GMG_C_DEG: i64 = 25
172const GMG_C_OV: i64 = 26
173const GMG_C_ONV: i64 = 27
174const GMG_C_OT: i64 = 28
175const GMG_C_ONT: i64 = 29
176const GMG_C_CAND: i64 = 30
177const GMG_C_NCAND: i64 = 31
178const GMG_C_TRIS: i64 = 32
179const GMG_C_NTRIS: i64 = 33
180const GMG_C_THICK_PERMIL: i64 = 34
181const GMG_C_UPMK: i64 = 35
182const GMG_C_BSET: i64 = 36
183const GMG_C_RING: i64 = 37
184const GMG_C_BADJ: i64 = 38
185const GMG_C_BDEG: i64 = 39
186const GMG_C_STACK: i64 = 40
187const GMG_C_SEEN: i64 = 41
188const GMG_C_NOPUSH: i64 = 42
189const GMG_C_NBROVER: i64 = 43
190const GMG_C_AJ: i64 = 44
191const GMG_C_AW: i64 = 45
192const GMG_C_DST: i64 = 46            // the asset's own DYNA row stride (ref9d ships 12 words, not the 8 the
                                   // first cut demanded -- an exact-stride check read a present section as absent)
194const GMG_C_DIL: i64 = 47            // per-vertex pinch-dilation flags (see gmg_build steps 1-3)
195const GMG_C_SLOTS: i64 = 48
196const GMG_PINCH_PASSES: i64 = 4
197// vertex flag bits (GMG_C_VF)
198const GMG_VF_TOR: i64 = 1
199const GMG_VF_ARM: i64 = 2
200const GMG_VF_HEAD: i64 = 4
201// stat slots
202const GMG_S_NV: i64 = 0
203const GMG_S_NT: i64 = 1
204const GMG_S_SHELL: i64 = 2
205const GMG_S_HEM: i64 = 3
206const GMG_S_BEDGES: i64 = 4
207const GMG_S_PUSHED: i64 = 5
208const GMG_S_STRAPS: i64 = 6
209const GMG_S_MINCLEAR: i64 = 7
210const GMG_S_LOOPS: i64 = 8
211const GMG_S_OPEN: i64 = 9
212const GMG_S_SEL: i64 = 10
213const GMG_S_T: i64 = 11
214const GMG_S_TH: i64 = 12
215const GMG_S_EASE: i64 = 13
216const GMG_S_CLASS: i64 = 14
217const GMG_S_WITHIN: i64 = 15
218const GMG_S_SLF: i64 = 16
219const GMG_S_SLB: i64 = 17
220const GMG_S_SRF: i64 = 18
221const GMG_S_SRB: i64 = 19
222const GMG_S_NBROVER: i64 = 20
223const GMG_S_VOFF: i64 = 21
224const GMG_S_TOFF: i64 = 22
225const GMG_S_ID: i64 = 23
226const GMG_S_PINCHPASS: i64 = 24      // selection passes taken by the pinch dilation (1 = no pinch found)
227
228func gmg_puts(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
229func gmg_pn(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
242}
243func gmg_abs(v: i64) -> i64 { if v < 0 { return 0 - v } return v }
244func gmg_min(a: i64, b: i64) -> i64 { if a < b { return a } return b }
245func gmg_max(a: i64, b: i64) -> i64 { if a > b { return a } return b }
246// floor(sqrt(v)) by Newton from a power-of-two upper bound; v < 0 reads as 0
247func gmg_isqrt(v: i64) -> i64 {
  if v <= 0 { return 0 }
  var g: i64 = 1
  var grow: i64 = 1
  while grow == 1 {
      if g >= GMG_ISQRT_HI { grow = 0 } else {
          if g * g >= v { grow = 0 } else { g = g * 2 }
      }
  }
  var y: i64 = g
  var it: i64 = 0
  while it < 80 {
      let z: i64 = (y + v / y) / 2
      if z >= y { it = 80 } else { y = z }
      it = it + 1
  }
  return y
264}
265// smoothstep(a, b, x) in Q12: 0 below a, Q above b
266func gmg_sst(a: i64, b: i64, x: i64) -> i64 {
  if b <= a { if x >= b { return GMG_Q } return 0 }
  var t: i64 = (x - a) * GMG_Q / (b - a)
  if t < 0 { t = 0 }
  if t > GMG_Q { t = GMG_Q }
  return (t * t / GMG_Q) * (3 * GMG_Q - 2 * t) / GMG_Q
272}
273// micrometres -> mesh units through the page's own 1.78 m = 171530 pairing
274func gmg_um2u(um: i64) -> i64 { return um * GMG_UNITS_178 / (GMG_MM_178 * GMG_UM_PER_MM) }
275func gmg_circ2radial_um(circ_um: i64) -> i64 { return circ_um * 1000 / GMG_TWO_PI_MILLI }
276
277// gmg_mat: the fabric table per garment id. out[0] thickness units . out[1] hem (edge face) units .
278// out[2] radial ease units . out[3] material class. Thickness and hem scale with the ctx thick permil
279// (1000 = derived; 0 = the neg-control that must be REFUSED); ease never does.
280func gmg_mat(G: *i64, kind: i64, out: *i64) -> i64 {
  var t: i64 = 0
  var th: i64 = 0
  var e: i64 = 0
  var cl: i64 = 0
  if kind == 1 { t = GMG_T_SWIM_UM; th = 2 * GMG_T_SWIM_UM + GMG_ELASTIC_UM; e = 0; cl = GMG_M_SWIM }
  if kind == 2 { t = GMG_T_SWIM_UM; th = 2 * GMG_T_SWIM_UM + GMG_ELASTIC_UM; e = 0; cl = GMG_M_SWIM }
  if kind == 3 { t = GMG_T_SWIM_UM; th = 2 * GMG_T_SWIM_UM + GMG_ELASTIC_UM; e = 0; cl = GMG_M_SWIM }
  if kind == 4 { t = GMG_T_SARONG_UM; th = 2 * GMG_T_SARONG_UM; e = GMG_EASE_KNOT_RADIAL_UM; cl = GMG_M_WOVEN }
  if kind == 5 { t = GMG_T_WOVEN_UM; th = 2 * GMG_T_WOVEN_UM; e = gmg_circ2radial_um(GMG_EASE_DRESS_UM); cl = GMG_M_WOVEN }
  if kind == 6 { t = GMG_T_JERSEY_UM; th = 2 * GMG_T_JERSEY_UM; e = gmg_circ2radial_um(GMG_EASE_TEE_UM); cl = GMG_M_JERSEY }
  if kind == 7 { t = GMG_T_WOVEN_UM; th = 2 * GMG_T_WOVEN_UM; e = gmg_circ2radial_um(GMG_EASE_SHORTS_UM); cl = GMG_M_WOVEN }
  if kind == 8 { t = GMG_T_WOVEN_UM; th = 2 * GMG_T_WOVEN_UM; e = 0; cl = GMG_M_WOVEN }
  if kind == 9 { t = GMG_T_SATIN_UM; th = 2 * GMG_T_SATIN_UM; e = gmg_circ2radial_um(GMG_EASE_EVENING_UM); cl = GMG_M_SATIN }
  if cl == 0 { return 0 - 1 }
  let pm: i64 = G[GMG_C_THICK_PERMIL]
  out[0] = gmg_um2u(t) * pm / 1000
  out[1] = gmg_um2u(th) * pm / 1000
  out[2] = gmg_um2u(e)
  // the waistband's ease is MEASURED: the gap between the skirt's own top ring and the body
  if kind == 8 { out[2] = G[GMG_C_GAP] }
  out[3] = cl
  return 1
303}
304
305func gmg_pos(G: *i64) -> *i64 { return G[GMG_C_POS] as *i64 }
306func gmg_nrm(G: *i64) -> *i64 { return G[GMG_C_NRM] as *i64 }
307func gmg_hh(G: *i64) -> *i64 { return G[GMG_C_HH] as *i64 }
308func gmg_ax(G: *i64) -> *i64 { return G[GMG_C_AX] as *i64 }
309func gmg_vf(G: *i64) -> *u8 { return G[GMG_C_VF] as *u8 }
310func gmg_has(G: *i64, v: i64, bit: i64) -> i64 {
  let f: *u8 = gmg_vf(G)
  if ((f[v] as i64) & bit) != 0 { return 1 }
  return 0
314}
315
316// nearest joint to height f (decimil) with a midline preference (the page's near())
317func gmg_near_joint(G: *i64, fdm: i64) -> i64 {
  let bind: *i64 = G[GMG_C_BIND] as *i64
  let nj: i64 = G[GMG_C_NJ]
  let tz: i64 = G[GMG_C_ZMN] + fdm * G[GMG_C_H] / GMG_DM
  var bj: i64 = 0
  var bd: i64 = GMG_BIG
  var j: i64 = 0
  while j < nj {
      let d: i64 = gmg_abs(bind[j * 3 + 2] - tz) + 2 * gmg_abs(bind[j * 3])
      if d < bd { bd = d; bj = j }
      j = j + 1
  }
  return bj
330}
331
332// gmg_load: parse VERT/TRIS/SKEL/SKIN (+DYNA, +GVRT), measure the body, derive the landmarks, allocate the
333// scratch. Returns the context, or 0 with the refusal NAMED on stdout.
334func gmg_load(b: *u8, flen: i64) -> *i64 {
  let vwo: i64 = nxa_find(b, flen, nxa_tag4("VERT" as *u8))
  let two: i64 = nxa_find(b, flen, nxa_tag4("TRIS" as *u8))
  let swo: i64 = nxa_find(b, flen, nxa_tag4("SKEL" as *u8))
  let kwo: i64 = nxa_find(b, flen, nxa_tag4("SKIN" as *u8))
  if vwo < 0 { gmg_puts("GMG-REFUSED bad nxa: VERT\n" as *u8); return 0 as *i64 }
  if two < 0 { gmg_puts("GMG-REFUSED bad nxa: TRIS\n" as *u8); return 0 as *i64 }
  if swo < 0 { gmg_puts("GMG-REFUSED bad nxa: SKEL\n" as *u8); return 0 as *i64 }
  if kwo < 0 { gmg_puts("GMG-REFUSED bad nxa: SKIN\n" as *u8); return 0 as *i64 }
  let h: *i64 = b as *i64
  let nv: i64 = h[vwo]
  let nt: i64 = h[two]
  let nj: i64 = h[swo]
  let nsv: i64 = h[kwo]
  if nsv != nv { gmg_puts("GMG-REFUSED skin/vert desync\n" as *u8); return 0 as *i64 }
  if nv < 3 { gmg_puts("GMG-REFUSED empty mesh\n" as *u8); return 0 as *i64 }
  let G: *i64 = sys_mmap(GMG_C_SLOTS * 8) as *i64
  var s0: i64 = 0
  while s0 < GMG_C_SLOTS { G[s0] = 0; s0 = s0 + 1 }
  G[GMG_C_B] = b as i64
  G[GMG_C_FLEN] = flen
  let pos: *i64 = ((b as i64) + (vwo + 1) * 8) as *i64
  let idx: *i64 = ((b as i64) + (two + 1) * 8) as *i64
  G[GMG_C_POS] = pos as i64
  G[GMG_C_NV] = nv
  G[GMG_C_IDX] = idx as i64
  G[GMG_C_NT] = nt
  G[GMG_C_THICK_PERMIL] = 1000
  G[GMG_C_UPMK] = GMG_UNITS_178 * 1000 / GMG_MM_178
  // bind positions
  let bind: *i64 = sys_mmap(nj * 3 * 8 + 64) as *i64
  var j: i64 = 0
  while j < nj {
      let bw: i64 = swo + 1 + j * GMG_SKEL_STRIDE
      bind[j * 3] = h[bw + 1]
      bind[j * 3 + 1] = h[bw + 2]
      bind[j * 3 + 2] = h[bw + 3]
      j = j + 1
  }
  G[GMG_C_BIND] = bind as i64
  G[GMG_C_NJ] = nj
  // skin rows (joint ids + Q12 weights) -- the page copies these per garment vertex
  G[GMG_C_AJ] = ((b as i64) + (kwo + 1) * 8)
  G[GMG_C_AW] = 0
  // extents
  var zmn: i64 = GMG_BIG
  var zmx: i64 = 0 - GMG_BIG
  var v: i64 = 0
  while v < nv {
      let z: i64 = pos[v * 3 + 2]
      if z < zmn { zmn = z }
      if z > zmx { zmx = z }
      v = v + 1
  }
  var H: i64 = zmx - zmn
  if H < 1 { H = 1 }
  G[GMG_C_ZMN] = zmn
  G[GMG_C_H] = H
  // per-vertex height (decimil) and |x|
  let hh: *i64 = sys_mmap(nv * 8 + 64) as *i64
  let ax: *i64 = sys_mmap(nv * 8 + 64) as *i64
  var ys: i64 = 0
  var yc: i64 = 0
  v = 0
  while v < nv {
      hh[v] = (pos[v * 3 + 2] - zmn) * GMG_DM / H
      ax[v] = gmg_abs(pos[v * 3])
      if ax[v] < GMG_TORSO_HALFW { if hh[v] > 5000 { if hh[v] < 8000 { ys = ys + pos[v * 3 + 1]; yc = yc + 1 } } }
      v = v + 1
  }
  G[GMG_C_HH] = hh as i64
  G[GMG_C_AX] = ax as i64
  var ymid: i64 = 0
  if yc > 0 { ymid = ys / yc }
  G[GMG_C_YMID] = ymid
  // smooth vertex normals: area-weighted accumulation of face cross products (scaled down to keep
  // the sums small), normalised to Q12, then the torso-column outwardness guard: a normal pointing
  // INTO the column (against the radial from the axis) is flipped -- the mesh's winding is measured
  // 96 percent consistent on the reference body, and the 4 percent would drop a shell inside the skin.
  let acc: *i64 = sys_mmap(nv * 3 * 8 + 64) as *i64
  var z0: i64 = 0
  while z0 < nv * 3 { acc[z0] = 0; z0 = z0 + 1 }
  var e: i64 = 0
  while e < nt {
      let a: i64 = idx[e * 3]
      let bb: i64 = idx[e * 3 + 1]
      let c: i64 = idx[e * 3 + 2]
      let e1x: i64 = pos[bb * 3] - pos[a * 3]
      let e1y: i64 = pos[bb * 3 + 1] - pos[a * 3 + 1]
      let e1z: i64 = pos[bb * 3 + 2] - pos[a * 3 + 2]
      let e2x: i64 = pos[c * 3] - pos[a * 3]
      let e2y: i64 = pos[c * 3 + 1] - pos[a * 3 + 1]
      let e2z: i64 = pos[c * 3 + 2] - pos[a * 3 + 2]
      let fx: i64 = (e1y * e2z - e1z * e2y) / GMG_CROSS_SHIFT
      let fy: i64 = (e1z * e2x - e1x * e2z) / GMG_CROSS_SHIFT
      let fz: i64 = (e1x * e2y - e1y * e2x) / GMG_CROSS_SHIFT
      acc[a * 3] = acc[a * 3] + fx; acc[a * 3 + 1] = acc[a * 3 + 1] + fy; acc[a * 3 + 2] = acc[a * 3 + 2] + fz
      acc[bb * 3] = acc[bb * 3] + fx; acc[bb * 3 + 1] = acc[bb * 3 + 1] + fy; acc[bb * 3 + 2] = acc[bb * 3 + 2] + fz
      acc[c * 3] = acc[c * 3] + fx; acc[c * 3 + 1] = acc[c * 3 + 1] + fy; acc[c * 3 + 2] = acc[c * 3 + 2] + fz
      e = e + 1
  }
  let nrm: *i64 = sys_mmap(nv * 3 * 8 + 64) as *i64
  v = 0
  while v < nv {
      var nx: i64 = acc[v * 3]
      var ny: i64 = acc[v * 3 + 1]
      var nz: i64 = acc[v * 3 + 2]
      var m: i64 = gmg_max(gmg_abs(nx), gmg_max(gmg_abs(ny), gmg_abs(nz)))
      while m > GMG_NRM_CAP { nx = nx / 16; ny = ny / 16; nz = nz / 16; m = m / 16 }
      let ln: i64 = gmg_isqrt(nx * nx + ny * ny + nz * nz)
      if ln < 1 { nx = 0; ny = 0; nz = GMG_Q } else { nx = nx * GMG_Q / ln; ny = ny * GMG_Q / ln; nz = nz * GMG_Q / ln }
      if ax[v] < GMG_TORSO_HALFW { if hh[v] > 4000 { if hh[v] < 8000 {
          let rx: i64 = pos[v * 3]
          let ry: i64 = pos[v * 3 + 1] - ymid
          if nx * rx + ny * ry < 0 { nx = 0 - nx; ny = 0 - ny; nz = 0 - nz }
      } } }
      nrm[v * 3] = nx; nrm[v * 3 + 1] = ny; nrm[v * 3 + 2] = nz
      v = v + 1
  }
  G[GMG_C_NRM] = nrm as i64
  // dominant joint per vertex -> arm / head flags; torso-column flag
  let vf: *u8 = sys_mmap(nv + 64) as *u8
  let skin: *i64 = G[GMG_C_AJ] as *i64
  v = 0
  while v < nv {
      let row: i64 = v * GMG_SKIN_STRIDE
      var k: i64 = 0
      var q: i64 = 1
      while q < 4 { if skin[row + 4 + q] > skin[row + 4 + k] { k = q } q = q + 1 }
      var dj: i64 = skin[row + k]
      if dj < 0 { dj = 0 }
      if dj >= nj { dj = 0 }
      var f: i64 = 0
      if gmg_abs(bind[dj * 3]) > GMG_ARM_BIND_X { f = f | GMG_VF_ARM }
      if (bind[dj * 3 + 2] - zmn) * GMG_DM / H > GMG_HEAD_DM { f = f | GMG_VF_HEAD }
      if ax[v] < GMG_TORSO_HALFW { if (f & (GMG_VF_ARM | GMG_VF_HEAD)) == 0 { f = f | GMG_VF_TOR } }
      vf[v] = f as u8
      v = v + 1
  }
  G[GMG_C_VF] = vf as i64
  // NIP: the published .72 ratio mapped through THIS mesh's pelvis (.52) and head (.95) anchors -- the
  // page's own derivation, in permil-then-decimil so the two agree to the rounding
  let pj: i64 = gmg_near_joint(G, GMG_HIPJ_DM)
  let hj: i64 = gmg_near_joint(G, GMG_HEADJ_PROBE_DM)
  let pv: i64 = ((bind[pj * 3 + 2] - zmn) * 1000 + H / 2) / H * 10
  let hd: i64 = ((bind[hj * 3 + 2] - zmn) * 1000 + H / 2) / H * 10
  var nip: i64 = GMG_NIP_RATIO_DM
  let sl: i64 = (hd - pv) * GMG_Q / (GMG_EYE_DM - GMG_HIPJ_DM)
  if sl > GMG_Q * 4 / 10 { if sl < GMG_Q * 16 / 10 { nip = pv + sl * (GMG_NIP_RATIO_DM - GMG_HIPJ_DM) / GMG_Q } }
  G[GMG_C_NIP] = nip
  // DYNA anchors (optional): rows of 8 words [side,x,y,z,k,c,max,infl]
  let dwo: i64 = nxa_find(b, flen, nxa_tag4("DYNA" as *u8))
  if dwo >= 0 {
      let ndb: i64 = h[dwo]
      let dst: i64 = h[dwo + 1]
      if dst >= GMG_DYN_FIELDS { G[GMG_C_DYN] = ((b as i64) + (dwo + 2) * 8); G[GMG_C_ND] = ndb; G[GMG_C_DST] = dst }
  }
  // the skirt (GVRT) top ring: its height and its mean gap to the body -- the waistband's ease
  G[GMG_C_GTH] = 0 - 1
  G[GMG_C_GAP] = 0
  let gwo: i64 = nxa_find(b, flen, nxa_tag4("GVRT" as *u8))
  if gwo >= 0 {
      let gnv: i64 = h[gwo]
      let gp: *i64 = ((b as i64) + (gwo + 1) * 8) as *i64
      var gtop: i64 = 0 - GMG_BIG
      var i: i64 = 0
      while i < gnv { if gp[i * 3 + 2] > gtop { gtop = gp[i * 3 + 2] } i = i + 1 }
      let gth: i64 = (gtop - zmn) * GMG_DM / H
      var gsum: i64 = 0
      var gcnt: i64 = 0
      i = 0
      while i < gnv {
          if gmg_abs(gp[i * 3 + 2] - gtop) < 2 {
              var bd: i64 = GMG_BIG
              var u: i64 = 0
              while u < nv {
                  if gmg_abs(hh[u] - gth) <= GMG_SKIRT_TOP_TOL_DM {
                      let dx: i64 = pos[u * 3] - gp[i * 3]
                      let dy: i64 = pos[u * 3 + 1] - gp[i * 3 + 1]
                      let dz: i64 = pos[u * 3 + 2] - gp[i * 3 + 2]
                      let dd: i64 = dx * dx + dy * dy + dz * dz
                      if dd < bd { bd = dd }
                  }
                  u = u + 1
              }
              if bd < GMG_BIG { gsum = gsum + gmg_isqrt(bd); gcnt = gcnt + 1 }
          }
          i = i + 1
      }
      G[GMG_C_GTH] = gth
      if gcnt > 0 { G[GMG_C_GAP] = gsum / gcnt }
  }
  // scratch
  G[GMG_C_VMAP] = sys_mmap(nv * 8 + 64) as i64
  G[GMG_C_INNER] = sys_mmap(nv * 8 + 64) as i64
  G[GMG_C_SEL] = sys_mmap(nv + 64) as i64
  G[GMG_C_BSET] = sys_mmap(nv + 64) as i64
  G[GMG_C_RING] = sys_mmap(nv + 64) as i64
  G[GMG_C_SEEN] = sys_mmap(nv + 64) as i64
  G[GMG_C_DIL] = sys_mmap(nv + 64) as i64
  G[GMG_C_NBR] = sys_mmap(nv * GMG_NBR_CAP * 8 + 64) as i64
  G[GMG_C_NBC] = sys_mmap(nv * GMG_NBR_CAP * 8 + 64) as i64
  G[GMG_C_DEG] = sys_mmap(nv * 8 + 64) as i64
  G[GMG_C_BADJ] = sys_mmap(nv * GMG_BADJ_CAP * 8 + 64) as i64
  G[GMG_C_BDEG] = sys_mmap(nv * 8 + 64) as i64
  G[GMG_C_STACK] = sys_mmap(nv * 8 + 64) as i64
  G[GMG_C_CAND] = sys_mmap(nv * 8 + 64) as i64
  G[GMG_C_TRIS] = sys_mmap(nt * 8 + 64) as i64
  G[GMG_C_OV] = sys_mmap(GMG_OV_CAP * GMG_VSTRIDE * 8 + 64) as i64
  G[GMG_C_OT] = sys_mmap(GMG_OT_CAP * GMG_TSTRIDE * 8 + 64) as i64
  return G
545}
546
547// nearest body vertex to (x,y,z) inside a height band, torso/limb only (no arm, no head), |x| bounded
548func gmg_near_body(G: *i64, x: i64, y: i64, z: i64, hlo: i64, hhi: i64, axmax: i64) -> i64 {
  let pos: *i64 = gmg_pos(G)
  let hh: *i64 = gmg_hh(G)
  let ax: *i64 = gmg_ax(G)
  let vf: *u8 = gmg_vf(G)
  let nv: i64 = G[GMG_C_NV]
  var bi: i64 = 0 - 1
  var bd: i64 = GMG_BIG
  var v: i64 = 0
  while v < nv {
      var ok: i64 = 1
      if hh[v] < hlo { ok = 0 }
      if hh[v] > hhi { ok = 0 }
      if ax[v] > axmax { ok = 0 }
      if ((vf[v] as i64) & (GMG_VF_ARM | GMG_VF_HEAD)) != 0 { ok = 0 }
      if ok == 1 {
          let dx: i64 = pos[v * 3] - x
          let dy: i64 = pos[v * 3 + 1] - y
          let dz: i64 = pos[v * 3 + 2] - z
          let dd: i64 = dx * dx + dy * dy + dz * dz
          if dd < bd { bd = dd; bi = v }
      }
      v = v + 1
  }
  return bi
573}
574
575// the leg opening line (decimil) at vertex v: crotch .475 H front rising with |x| toward the hip, higher
576// cut at the back (.445 -> .50), blended front-to-back over the y midline
577func gmg_hleg(G: *i64, v: i64) -> i64 {
  let ax: *i64 = gmg_ax(G)
  let pos: *i64 = gmg_pos(G)
  var u: i64 = ax[v] * GMG_Q / GMG_TORSO_HALFW
  if u > GMG_Q { u = GMG_Q }
  let uu: i64 = u * u / GMG_Q
  let f: i64 = GMG_CROTCH_DM + 250 * uu / GMG_Q
  let bk: i64 = 4450 + 550 * uu / GMG_Q
  return f + (bk - f) * gmg_sst(0 - GMG_YBLEND, GMG_YBLEND, pos[v * 3 + 1]) / GMG_Q
586}
587// the one-piece / sundress neckline (decimil): scoop front .77 H rising to .82 at the shoulder, back .70
588func gmg_hneck(G: *i64, v: i64) -> i64 {
  let ax: *i64 = gmg_ax(G)
  let pos: *i64 = gmg_pos(G)
  var u: i64 = ax[v] * GMG_Q / GMG_TORSO_HALFW
  if u > GMG_Q { u = GMG_Q }
  let uu: i64 = u * u / GMG_Q
  let f: i64 = GMG_ONEPIECE_NECK_F + 500 * uu / GMG_Q
  let bk: i64 = GMG_ONEPIECE_NECK_B + 600 * uu / GMG_Q
  return f + (bk - f) * gmg_sst(0 - GMG_YBLEND, GMG_YBLEND, pos[v * 3 + 1]) / GMG_Q
597}
598// the tee crew neck (decimil): .835 H, rising .03 H toward the shoulder
599func gmg_hneck_tee(G: *i64, v: i64) -> i64 {
  let ax: *i64 = gmg_ax(G)
  var t: i64 = (ax[v] - 3000) * GMG_Q / 9000
  if t < 0 { t = 0 }
  if t > GMG_Q { t = GMG_Q }
  return GMG_TEE_NECK_DM + GMG_TEE_NECK_RISE * t / GMG_Q
605}
606func gmg_dyn_side(G: *i64, side: i64) -> i64 {
  let nd: i64 = G[GMG_C_ND]
  if nd == 0 { return 0 - 1 }
  let dyn: *i64 = G[GMG_C_DYN] as *i64
  let dst: i64 = G[GMG_C_DST]
  var d: i64 = 0
  while d < nd {
      if side < 0 { if dyn[d * dst] < 0 { return d } }
      if side > 0 { if dyn[d * dst] > 0 { return d } }
      d = d + 1
  }
  return 0 - 1
618}
619func gmg_in_dyn(G: *i64, v: i64, d: i64) -> i64 {
  if d < 0 { return 0 }
  let dyn: *i64 = G[GMG_C_DYN] as *i64
  let dst: i64 = G[GMG_C_DST]
  let pos: *i64 = gmg_pos(G)
  let dx: i64 = pos[v * 3] - dyn[d * dst + 1]
  let dy: i64 = pos[v * 3 + 1] - dyn[d * dst + 2]
  let dz: i64 = pos[v * 3 + 2] - dyn[d * dst + 3]
  let r: i64 = dyn[d * dst + 7]
  if dx * dx + dy * dy + dz * dz < r * r { return 1 }
  return 0
630}
631
632// gmg_region: does garment `kind` cover body vertex v?
633func gmg_region(G: *i64, kind: i64, v: i64) -> i64 {
  let hh: *i64 = gmg_hh(G)
  let ax: *i64 = gmg_ax(G)
  let pos: *i64 = gmg_pos(G)
  let h: i64 = hh[v]
  let tor: i64 = gmg_has(G, v, GMG_VF_TOR)
  let arm: i64 = gmg_has(G, v, GMG_VF_ARM)
  let head: i64 = gmg_has(G, v, GMG_VF_HEAD)
  let nip: i64 = G[GMG_C_NIP]
  if kind == 1 {
      if tor == 0 { return 0 }
      // the cups: the front bust regions inside the asset's OWN DYNA anchor radii; the back band: a
      // narrow ring at the underbust line (NIP - .055 H) all the way round
      if pos[v * 3 + 1] < GMG_FRONT_Y {
          if gmg_in_dyn(G, v, gmg_dyn_side(G, 0 - 1)) == 1 { return 1 }
          if gmg_in_dyn(G, v, gmg_dyn_side(G, 1)) == 1 { return 1 }
          // DYNA-less asset: the bust band itself stands in for the cups (declared fallback)
          if G[GMG_C_ND] == 0 { if gmg_abs(h - nip) < GMG_BUST_HALF_DM { return 1 } }
      }
      if gmg_abs(h - (nip - GMG_BUST_HALF_DM)) < GMG_STRAP_BAND_TOL_DM { return 1 }
      return 0
  }
  if kind == 2 { if tor == 1 { if h < 5500 { if h > gmg_hleg(G, v) { return 1 } } } return 0 }
  if kind == 3 { if tor == 1 { if h > gmg_hleg(G, v) { if h < gmg_hneck(G, v) { return 1 } } } return 0 }
  if kind == 9 { if tor == 1 { if h > gmg_hleg(G, v) { if h < gmg_hneck(G, v) { return 1 } } } return 0 }
  if kind == 4 {
      let dx: i64 = pos[v * 3] - GMG_SARONG_X
      let dy: i64 = pos[v * 3 + 1]
      let dz: i64 = pos[v * 3 + 2] - (G[GMG_C_ZMN] + GMG_SARONG_DM * G[GMG_C_H] / GMG_DM)
      if dx * dx + dy * dy + dz * dz < GMG_SARONG_R * GMG_SARONG_R { return 1 }
      return 0
  }
  if kind == 5 { if tor == 1 { if h > GMG_HIP_DM { if h < gmg_hneck(G, v) { return 1 } } } return 0 }
  if kind == 6 {
      if tor == 1 { if h > GMG_HIP_DM { if h < gmg_hneck_tee(G, v) { return 1 } } }
      if arm == 1 { if ax[v] < GMG_SLEEVE_HALFW { if h > GMG_SLEEVE_TOP_DM { return 1 } } }
      if ax[v] > GMG_SLEEVE_X_LO { if ax[v] < GMG_SLEEVE_HALFW { if h > GMG_SLEEVE_BAND_LO { if h < GMG_SLEEVE_BAND_HI { if head == 0 { return 1 } } } } }
      return 0
  }
  if kind == 7 { if ax[v] < GMG_TORSO_HALFW { if arm == 0 { if h > GMG_MIDTHIGH_DM { if h < GMG_SHORTS_TOP_DM { return 1 } } } } return 0 }
  if kind == 8 {
      if G[GMG_C_GTH] < 0 { return 0 }
      if tor == 1 { if gmg_abs(h - G[GMG_C_GTH]) < GMG_WAIST_BAND_DM { return 1 } }
      return 0
  }
  return 0
679}
680
681// radial ease at vertex v: the full ease below the bust, fading to zero across the bust->shoulder band so
682// necklines and straps sit on the body; the sarong knot and the waistband keep theirs everywhere
683func gmg_ease_at(G: *i64, kind: i64, mat: *i64, v: i64) -> i64 {
  let e: i64 = mat[2]
  if e == 0 { return 0 }
  if kind == 4 { return e }
  if kind == 8 { return e }
  let hh: *i64 = gmg_hh(G)
  return e * (GMG_Q - gmg_sst(GMG_EASE_FADE_LO, GMG_EASE_FADE_HI, hh[v])) / GMG_Q
690}
691
692// append one garment vertex grown from body vertex src at offset d along its normal; returns its index
693func gmg_addv(G: *i64, src: i64, d: i64, flag: i64) -> i64 {
  let onv: i64 = G[GMG_C_ONV]
  if onv >= GMG_OV_CAP { return 0 - 1 }
  let ov: *i64 = G[GMG_C_OV] as *i64
  let pos: *i64 = gmg_pos(G)
  let nrm: *i64 = gmg_nrm(G)
  let o: i64 = onv * GMG_VSTRIDE
  ov[o] = pos[src * 3] + nrm[src * 3] * d / GMG_Q
  ov[o + 1] = pos[src * 3 + 1] + nrm[src * 3 + 1] * d / GMG_Q
  ov[o + 2] = pos[src * 3 + 2] + nrm[src * 3 + 2] * d / GMG_Q
  ov[o + 3] = src
  ov[o + 4] = flag
  G[GMG_C_ONV] = onv + 1
  return onv
707}
708func gmg_addv_at(G: *i64, x: i64, y: i64, z: i64, src: i64, flag: i64) -> i64 {
  let onv: i64 = G[GMG_C_ONV]
  if onv >= GMG_OV_CAP { return 0 - 1 }
  let ov: *i64 = G[GMG_C_OV] as *i64
  let o: i64 = onv * GMG_VSTRIDE
  ov[o] = x; ov[o + 1] = y; ov[o + 2] = z; ov[o + 3] = src; ov[o + 4] = flag
  G[GMG_C_ONV] = onv + 1
  return onv
716}
717func gmg_addt(G: *i64, a: i64, b: i64, c: i64) -> i64 {
  let ont: i64 = G[GMG_C_ONT]
  if ont >= GMG_OT_CAP { return 0 - 1 }
  let ot: *i64 = G[GMG_C_OT] as *i64
  ot[ont * 3] = a; ot[ont * 3 + 1] = b; ot[ont * 3 + 2] = c
  G[GMG_C_ONT] = ont + 1
  return ont
724}
725
726// undirected edge table keyed under the LOWER vertex: count occurrences across the selected triangles
727func gmg_nbr_add(G: *i64, u0: i64, v0: i64) -> i64 {
  var u: i64 = u0
  var v: i64 = v0
  if v < u { u = v0; v = u0 }
  let nbr: *i64 = G[GMG_C_NBR] as *i64
  let nbc: *i64 = G[GMG_C_NBC] as *i64
  let deg: *i64 = G[GMG_C_DEG] as *i64
  var k: i64 = 0
  while k < deg[u] {
      if nbr[u * GMG_NBR_CAP + k] == v { nbc[u * GMG_NBR_CAP + k] = nbc[u * GMG_NBR_CAP + k] + 1; return 1 }
      k = k + 1
  }
  if deg[u] >= GMG_NBR_CAP { G[GMG_C_NBROVER] = G[GMG_C_NBROVER] + 1; return 0 }
  nbr[u * GMG_NBR_CAP + deg[u]] = v
  nbc[u * GMG_NBR_CAP + deg[u]] = 1
  deg[u] = deg[u] + 1
  return 1
744}
745func gmg_nbr_count(G: *i64, u0: i64, v0: i64) -> i64 {
  var u: i64 = u0
  var v: i64 = v0
  if v < u { u = v0; v = u0 }
  let nbr: *i64 = G[GMG_C_NBR] as *i64
  let nbc: *i64 = G[GMG_C_NBC] as *i64
  let deg: *i64 = G[GMG_C_DEG] as *i64
  var k: i64 = 0
  while k < deg[u] {
      if nbr[u * GMG_NBR_CAP + k] == v { return nbc[u * GMG_NBR_CAP + k] }
      k = k + 1
  }
  return 0
758}
759
760// one ribbon strap: front anchor -> shoulder top -> back anchor, sampled, each sample snapped to the
761// nearest body vertex in its height band and lifted by the hem thickness; two verts per sample across
762// the local tangent x normal, quads between samples. Returns the sample count; end heights into ends[0..1].
763func gmg_strap(G: *i64, mat: *i64, sx: i64, hF: i64, hB: i64, halfw: i64, ends: *i64) -> i64 {
  let pos: *i64 = gmg_pos(G)
  let nrm: *i64 = gmg_nrm(G)
  let hh: *i64 = gmg_hh(G)
  let zmn: i64 = G[GMG_C_ZMN]
  let H: i64 = G[GMG_C_H]
  let th: i64 = mat[1]
  // anchors (bind space)
  let ax0: i64 = sx * GMG_STRAP_AX_FRONT
  let ay0: i64 = GMG_STRAP_Y_FRONT
  let az0: i64 = zmn + hF * H / GMG_DM
  let bx0: i64 = sx * GMG_STRAP_AX_SHOULDER
  let by0: i64 = GMG_STRAP_Y_SHOULDER
  let bz0: i64 = zmn + GMG_STRAP_SHOULDER_DM * H / GMG_DM
  let cx0: i64 = sx * GMG_STRAP_AX_BACK
  let cy0: i64 = GMG_STRAP_Y_BACK
  let cz0: i64 = zmn + hB * H / GMG_DM
  let ring: *i64 = sys_mmap(GMG_STRAP_CAP * 4 * 8 + 64) as *i64
  var n: i64 = 0
  var seg: i64 = 0
  while seg < 2 {
      var i: i64 = 0
      if seg == 1 { i = 1 }
      while i <= GMG_STRAP_K {
          var px: i64 = 0
          var py: i64 = 0
          var pz: i64 = 0
          if seg == 0 {
              px = ax0 + (bx0 - ax0) * i / GMG_STRAP_K; py = ay0 + (by0 - ay0) * i / GMG_STRAP_K; pz = az0 + (bz0 - az0) * i / GMG_STRAP_K
          } else {
              px = bx0 + (cx0 - bx0) * i / GMG_STRAP_K; py = by0 + (cy0 - by0) * i / GMG_STRAP_K; pz = bz0 + (cz0 - bz0) * i / GMG_STRAP_K
          }
          let hq: i64 = (pz - zmn) * GMG_DM / H
          let v: i64 = gmg_near_body(G, px, py, pz, hq - GMG_STRAP_SEARCH_DM, hq + GMG_STRAP_SEARCH_DM, GMG_STRAP_AX_MAX)
          if v >= 0 { if n < GMG_STRAP_CAP {
              ring[n * 4] = v
              ring[n * 4 + 1] = pos[v * 3] + nrm[v * 3] * th / GMG_Q
              ring[n * 4 + 2] = pos[v * 3 + 1] + nrm[v * 3 + 1] * th / GMG_Q
              ring[n * 4 + 3] = pos[v * 3 + 2] + nrm[v * 3 + 2] * th / GMG_Q
              n = n + 1
          } }
          i = i + 1
      }
      seg = seg + 1
  }
  if n < 2 { return 0 }
  var i2: i64 = 0
  var prev: i64 = 0 - 1
  while i2 < n {
      let v: i64 = ring[i2 * 4]
      var jn: i64 = i2 + 1
      if jn > n - 1 { jn = n - 1 }
      var jp: i64 = i2 - 1
      if jp < 0 { jp = 0 }
      var tx: i64 = ring[jn * 4 + 1] - ring[jp * 4 + 1]
      var ty: i64 = ring[jn * 4 + 2] - ring[jp * 4 + 2]
      var tz: i64 = ring[jn * 4 + 3] - ring[jp * 4 + 3]
      var tl: i64 = gmg_isqrt(tx * tx + ty * ty + tz * tz)
      if tl < 1 { tl = 1 }
      tx = tx * GMG_Q / tl; ty = ty * GMG_Q / tl; tz = tz * GMG_Q / tl
      let nx: i64 = nrm[v * 3]
      let ny: i64 = nrm[v * 3 + 1]
      let nz: i64 = nrm[v * 3 + 2]
      var sxv: i64 = (ty * nz - tz * ny) / GMG_Q
      var syv: i64 = (tz * nx - tx * nz) / GMG_Q
      var szv: i64 = (tx * ny - ty * nx) / GMG_Q
      var sl: i64 = gmg_isqrt(sxv * sxv + syv * syv + szv * szv)
      if sl < 1 { sl = 1 }
      sxv = sxv * halfw / sl; syv = syv * halfw / sl; szv = szv * halfw / sl
      let a: i64 = gmg_addv_at(G, ring[i2 * 4 + 1] + sxv, ring[i2 * 4 + 2] + syv, ring[i2 * 4 + 3] + szv, v, GMG_F_STRAP)
      let c: i64 = gmg_addv_at(G, ring[i2 * 4 + 1] - sxv, ring[i2 * 4 + 2] - syv, ring[i2 * 4 + 3] - szv, v, GMG_F_STRAP)
      if a < 0 { return 0 - 1 }
      if c < 0 { return 0 - 1 }
      if prev >= 0 {
          gmg_addt(G, prev, prev + 1, a)
          gmg_addt(G, prev + 1, c, a)
      }
      prev = a
      i2 = i2 + 1
  }
  ends[0] = hh[ring[0]]
  ends[1] = hh[ring[(n - 1) * 4]]
  return n
846}
847
848// gmg_build: one garment kind into the OV/OT scratch (reset here). Returns nverts, 0 when the region
849// selects no triangle, negative on refusal. stat[] carries the counts the gate reads.
850func gmg_build(G: *i64, kind: i64, stat: *i64) -> i64 {
  var s: i64 = 0
  while s < GMG_STAT_N { stat[s] = 0; s = s + 1 }
  stat[GMG_S_ID] = kind
  let mat: *i64 = sys_mmap(4 * 8) as *i64
  if gmg_mat(G, kind, mat) < 0 { return GMG_ERR_EMPTY }
  let t: i64 = mat[0]
  let th: i64 = mat[1]
  stat[GMG_S_T] = t; stat[GMG_S_TH] = th; stat[GMG_S_EASE] = mat[2]; stat[GMG_S_CLASS] = mat[3]
  // A ZERO-THICKNESS GARMENT IS NOT A GARMENT: refused by name, never emitted as a coincident shell
  if t <= 0 { gmg_puts("GMG-REFUSED kind=" as *u8); gmg_pn(kind); gmg_puts(" zero-thickness: a shell coincident with the skin is paint, not an object\n" as *u8); return GMG_ERR_REFUSED_THICK }
  let pos: *i64 = gmg_pos(G)
  let nrm: *i64 = gmg_nrm(G)
  let idx: *i64 = G[GMG_C_IDX] as *i64
  let nv: i64 = G[GMG_C_NV]
  let nt: i64 = G[GMG_C_NT]
  let sel: *u8 = G[GMG_C_SEL] as *u8
  let bset: *u8 = G[GMG_C_BSET] as *u8
  let ring: *u8 = G[GMG_C_RING] as *u8
  let vmap: *i64 = G[GMG_C_VMAP] as *i64
  let inner: *i64 = G[GMG_C_INNER] as *i64
  let deg: *i64 = G[GMG_C_DEG] as *i64
  let cand: *i64 = G[GMG_C_CAND] as *i64
  let tris: *i64 = G[GMG_C_TRIS] as *i64
  G[GMG_C_ONV] = 0
  G[GMG_C_ONT] = 0
  G[GMG_C_NBROVER] = 0
  // 1-3. region -> covered triangles + edge table -> boundary, with PINCH DILATION: where two parts of a
  //      region touch at a single vertex (the bikini cups meeting the under-bust band, measured on the
  //      served body: cup bottom 703 dm, band top 701 dm) the union's boundary has a bow-tie vertex with
  //      four boundary edges and the hem cannot close there. Real fabric BRIDGES a pinch, so every vertex
  //      of every body triangle touching a pinch joins the region and the boundary is re-derived; bounded
  //      passes, and a pinch that survives them still FAILS the closed-hems tooth (never hidden).
  let nbr: *i64 = G[GMG_C_NBR] as *i64
  let nbc: *i64 = G[GMG_C_NBC] as *i64
  let bdeg0: *i64 = G[GMG_C_BDEG] as *i64
  let dil: *u8 = G[GMG_C_DIL] as *u8
  let mark: *u8 = G[GMG_C_SEEN] as *u8
  var v: i64 = 0
  while v < nv { dil[v] = 0 as u8; v = v + 1 }
  var ncand: i64 = 0
  var ntris: i64 = 0
  var nb: i64 = 0
  var pinch: i64 = 1
  var iter: i64 = 0
  var passes: i64 = 0
  while pinch > 0 {
      if iter >= GMG_PINCH_PASSES { pinch = 0 } else {
          ncand = 0
          v = 0
          while v < nv {
              sel[v] = 0 as u8; bset[v] = 0 as u8; ring[v] = 0 as u8; vmap[v] = 0 - 1; inner[v] = 0 - 1; deg[v] = 0; bdeg0[v] = 0; mark[v] = 0 as u8
              var inr: i64 = gmg_region(G, kind, v)
              if dil[v] == (1 as u8) { inr = 1 }
              if inr == 1 { sel[v] = 1 as u8; cand[ncand] = v; ncand = ncand + 1 }
              v = v + 1
          }
          G[GMG_C_NBROVER] = 0
          ntris = 0
          var e: i64 = 0
          while e < nt {
              let a: i64 = idx[e * 3]
              let b: i64 = idx[e * 3 + 1]
              let c: i64 = idx[e * 3 + 2]
              if sel[a] == (1 as u8) { if sel[b] == (1 as u8) { if sel[c] == (1 as u8) {
                  tris[ntris] = e; ntris = ntris + 1
                  gmg_nbr_add(G, a, b); gmg_nbr_add(G, b, c); gmg_nbr_add(G, c, a)
              } } }
              e = e + 1
          }
          nb = 0
          v = 0
          while v < nv {
              var k: i64 = 0
              while k < deg[v] {
                  if nbc[v * GMG_NBR_CAP + k] == 1 {
                      let w: i64 = nbr[v * GMG_NBR_CAP + k]
                      bset[v] = 1 as u8; bset[w] = 1 as u8; nb = nb + 1
                      bdeg0[v] = bdeg0[v] + 1; bdeg0[w] = bdeg0[w] + 1
                  }
                  k = k + 1
              }
              v = v + 1
          }
          pinch = 0
          v = 0
          while v < nv { if bdeg0[v] > 2 { pinch = pinch + 1; mark[v] = 1 as u8 } v = v + 1 }
          if pinch > 0 {
              e = 0
              while e < nt {
                  let a: i64 = idx[e * 3]
                  let b: i64 = idx[e * 3 + 1]
                  let c: i64 = idx[e * 3 + 2]
                  var hit: i64 = 0
                  if mark[a] == (1 as u8) { hit = 1 }
                  if mark[b] == (1 as u8) { hit = 1 }
                  if mark[c] == (1 as u8) { hit = 1 }
                  if hit == 1 { dil[a] = 1 as u8; dil[b] = 1 as u8; dil[c] = 1 as u8 }
                  e = e + 1
              }
          }
          iter = iter + 1
          passes = passes + 1
      }
  }
  G[GMG_C_NCAND] = ncand
  stat[GMG_S_SEL] = ncand
  stat[GMG_S_PINCHPASS] = passes
  G[GMG_C_NTRIS] = ntris
  stat[GMG_S_NBROVER] = G[GMG_C_NBROVER]
  if ntris == 0 { return 0 }
  stat[GMG_S_BEDGES] = nb
  v = 0
  while v < nv {
      var k: i64 = 0
      while k < deg[v] {
          let w: i64 = nbr[v * GMG_NBR_CAP + k]
          if bset[v] == (1 as u8) { ring[w] = 1 as u8 }
          if bset[w] == (1 as u8) { ring[v] = 1 as u8 }
          k = k + 1
      }
      v = v + 1
  }
  // 4. the shell: every covered triangle's vertices, offset by thickness (hem thickness at the opening,
  //    half-way one ring in = the raised binding band) plus the wearing ease
  var ti: i64 = 0
  while ti < ntris {
      let e2: i64 = tris[ti]
      var q: i64 = 0
      while q < 3 {
          let vv: i64 = idx[e2 * 3 + q]
          if vmap[vv] < 0 {
              var d: i64 = t
              if ring[vv] == (1 as u8) { d = (t + th) / 2 }
              if bset[vv] == (1 as u8) { d = th }
              d = d + gmg_ease_at(G, kind, mat, vv)
              let ix: i64 = gmg_addv(G, vv, d, GMG_F_SHELL)
              if ix < 0 { return GMG_ERR_CAP }
              vmap[vv] = ix
          }
          q = q + 1
      }
      if gmg_addt(G, vmap[idx[e2 * 3]], vmap[idx[e2 * 3 + 1]], vmap[idx[e2 * 3 + 2]]) < 0 { return GMG_ERR_CAP }
      ti = ti + 1
  }
  stat[GMG_S_SHELL] = G[GMG_C_ONV]
  let nshell: i64 = G[GMG_C_ONV]
  let ov: *i64 = G[GMG_C_OV] as *i64
  // 5. PUSH-OUT: in a concave fold the normal offset lands nearer a NEIGHBOURING skin vertex than its own;
  //    walk such vertices away from the offending vertex until no covered body vertex is inside the fabric
  var pushed: i64 = 0
  if G[GMG_C_NOPUSH] == 0 {
      var pass: i64 = 0
      var again: i64 = 1
      while pass < GMG_PUSH_PASSES {
          if again == 1 {
              again = 0
              var i: i64 = 0
              while i < nshell {
                  let o: i64 = i * GMG_VSTRIDE
                  let x: i64 = ov[o]
                  let y: i64 = ov[o + 1]
                  let z: i64 = ov[o + 2]
                  let src: i64 = ov[o + 3]
                  var bd: i64 = t * t
                  var bq: i64 = 0 - 1
                  var ci: i64 = 0
                  while ci < ncand {
                      let qv: i64 = cand[ci]
                      let dz: i64 = pos[qv * 3 + 2] - z
                      if gmg_abs(dz) < t {
                          let dx: i64 = pos[qv * 3] - x
                          if gmg_abs(dx) < t {
                              let dy: i64 = pos[qv * 3 + 1] - y
                              if gmg_abs(dy) < t {
                                  let dd: i64 = dx * dx + dy * dy + dz * dz
                                  if dd < bd { bd = dd; bq = qv }
                              }
                          }
                      }
                      ci = ci + 1
                  }
                  if bq >= 0 {
                      let dcur: i64 = gmg_isqrt(bd)
                      let k2: i64 = t - dcur + GMG_PUSH_MARGIN
                      var mx: i64 = nrm[src * 3]
                      var my: i64 = nrm[src * 3 + 1]
                      var mz: i64 = nrm[src * 3 + 2]
                      if bq != src { if dcur >= 1 {
                          mx = (x - pos[bq * 3]) * GMG_Q / dcur
                          my = (y - pos[bq * 3 + 1]) * GMG_Q / dcur
                          mz = (z - pos[bq * 3 + 2]) * GMG_Q / dcur
                      } }
                      ov[o] = x + mx * k2 / GMG_Q
                      ov[o + 1] = y + my * k2 / GMG_Q
                      ov[o + 2] = z + mz * k2 / GMG_Q
                      pushed = pushed + 1
                      again = 1
                  }
                  i = i + 1
              }
          }
          pass = pass + 1
      }
  }
  stat[GMG_S_PUSHED] = pushed
  // 6. hems: every boundary edge grows a strip from the shell edge down to the fabric's inner face
  var nhem: i64 = 0
  var e_in_swim: i64 = gmg_um2u(GMG_SWIM_INNER_UM)
  ti = 0
  while ti < ntris {
      let e2: i64 = tris[ti]
      var q: i64 = 0
      while q < 3 {
          let u: i64 = idx[e2 * 3 + q]
          var q1: i64 = q + 1
          if q1 > 2 { q1 = 0 }
          let w: i64 = idx[e2 * 3 + q1]
          if gmg_nbr_count(G, u, w) == 1 {
              if inner[u] < 0 {
                  var ein: i64 = e_in_swim
                  if mat[2] > 0 { ein = gmg_ease_at(G, kind, mat, u) }
                  inner[u] = gmg_addv(G, u, ein, GMG_F_HEM)
                  if inner[u] < 0 { return GMG_ERR_CAP }
              }
              if inner[w] < 0 {
                  var ein2: i64 = e_in_swim
                  if mat[2] > 0 { ein2 = gmg_ease_at(G, kind, mat, w) }
                  inner[w] = gmg_addv(G, w, ein2, GMG_F_HEM)
                  if inner[w] < 0 { return GMG_ERR_CAP }
              }
              // the strip carries COPIES so its faces get their own normals page-side
              let A: i64 = vmap[u]
              let B: i64 = vmap[w]
              let Bi: i64 = inner[w]
              let Ai: i64 = inner[u]
              let base: i64 = G[GMG_C_ONV]
              var cpy: i64 = 0
              while cpy < 4 {
                  var srcix: i64 = A
                  if cpy == 1 { srcix = B }
                  if cpy == 2 { srcix = Bi }
                  if cpy == 3 { srcix = Ai }
                  let so: i64 = srcix * GMG_VSTRIDE
                  if gmg_addv_at(G, ov[so], ov[so + 1], ov[so + 2], ov[so + 3], GMG_F_HEM) < 0 { return GMG_ERR_CAP }
                  cpy = cpy + 1
              }
              gmg_addt(G, base, base + 1, base + 2)
              gmg_addt(G, base, base + 2, base + 3)
              nhem = nhem + 1
          }
          q = q + 1
      }
      ti = ti + 1
  }
  stat[GMG_S_HEM] = nhem
  // 7. straps for the strapped ids
  var nstrap: i64 = 0
  if kind == 1 { nstrap = 1 }
  if kind == 3 { nstrap = 1 }
  if kind == 5 { nstrap = 1 }
  if kind == 9 { nstrap = 1 }
  if nstrap == 1 {
      nstrap = 0
      var hF: i64 = GMG_ONEPIECE_NECK_F
      var hB: i64 = GMG_ONEPIECE_NECK_B
      var hw: i64 = gmg_um2u(GMG_STRAP_HALFW_DRESS_UM)
      if kind == 1 { hF = G[GMG_C_NIP] + 500; hB = G[GMG_C_NIP] - GMG_BUST_HALF_DM; hw = gmg_um2u(GMG_STRAP_HALFW_BIKINI_UM) }
      let ends: *i64 = sys_mmap(4 * 8) as *i64
      let nL: i64 = gmg_strap(G, mat, 0 - 1, hF, hB, hw, ends)
      if nL < 0 { return GMG_ERR_CAP }
      if nL > 0 { nstrap = nstrap + 1; stat[GMG_S_SLF] = ends[0]; stat[GMG_S_SLB] = ends[1] }
      let nR: i64 = gmg_strap(G, mat, 1, hF, hB, hw, ends)
      if nR < 0 { return GMG_ERR_CAP }
      if nR > 0 { nstrap = nstrap + 1; stat[GMG_S_SRF] = ends[0]; stat[GMG_S_SRB] = ends[1] }
  }
  stat[GMG_S_STRAPS] = nstrap
  // 8. clearance: shell vertices vs every covered body vertex (the gate's tooth: none inside 0.9 t);
  //    the reported minimum is a FLOOR capped at 4 t (the search stops there)
  let bar: i64 = t * GMG_CLEAR_PERMIL / 1000
  let rep: i64 = t * GMG_CLEAR_REPORT_MULT
  var within: i64 = 0
  var minc: i64 = rep * rep
  var i3: i64 = 0
  while i3 < nshell {
      let o: i64 = i3 * GMG_VSTRIDE
      let x: i64 = ov[o]
      let y: i64 = ov[o + 1]
      let z: i64 = ov[o + 2]
      var best: i64 = rep * rep
      var ci: i64 = 0
      while ci < ncand {
          let qv: i64 = cand[ci]
          let dz: i64 = pos[qv * 3 + 2] - z
          if gmg_abs(dz) < rep {
              let dx: i64 = pos[qv * 3] - x
              if gmg_abs(dx) < rep {
                  let dy: i64 = pos[qv * 3 + 1] - y
                  if gmg_abs(dy) < rep {
                      let dd: i64 = dx * dx + dy * dy + dz * dz
                      if dd < best { best = dd }
                  }
              }
          }
          ci = ci + 1
      }
      if best < bar * bar { within = within + 1 }
      if best < minc { minc = best }
      i3 = i3 + 1
  }
  stat[GMG_S_WITHIN] = within
  stat[GMG_S_MINCLEAR] = gmg_isqrt(minc)
  // 9. boundary topology: closed hems = every boundary vertex has exactly two boundary edges and the
  //    boundary graph's components are all cycles
  let badj: *i64 = G[GMG_C_BADJ] as *i64
  let bdeg: *i64 = G[GMG_C_BDEG] as *i64
  let stack: *i64 = G[GMG_C_STACK] as *i64
  let seen: *u8 = G[GMG_C_SEEN] as *u8
  v = 0
  while v < nv { bdeg[v] = 0; seen[v] = 0 as u8; v = v + 1 }
  var over: i64 = 0
  v = 0
  while v < nv {
      var k: i64 = 0
      while k < deg[v] {
          if nbc[v * GMG_NBR_CAP + k] == 1 {
              let w: i64 = nbr[v * GMG_NBR_CAP + k]
              if bdeg[v] < GMG_BADJ_CAP { badj[v * GMG_BADJ_CAP + bdeg[v]] = w } else { over = over + 1 }
              bdeg[v] = bdeg[v] + 1
              if bdeg[w] < GMG_BADJ_CAP { badj[w * GMG_BADJ_CAP + bdeg[w]] = v } else { over = over + 1 }
              bdeg[w] = bdeg[w] + 1
          }
          k = k + 1
      }
      v = v + 1
  }
  var loops: i64 = 0
  var openc: i64 = 0
  v = 0
  while v < nv {
      if bdeg[v] > 0 { if seen[v] == (0 as u8) {
          loops = loops + 1
          var odd: i64 = 0
          var sp: i64 = 0
          stack[sp] = v; sp = sp + 1; seen[v] = 1 as u8
          while sp > 0 {
              sp = sp - 1
              let u: i64 = stack[sp]
              if bdeg[u] != 2 { odd = odd + 1 }
              var k: i64 = 0
              var kl: i64 = bdeg[u]
              if kl > GMG_BADJ_CAP { kl = GMG_BADJ_CAP }
              while k < kl {
                  let w: i64 = badj[u * GMG_BADJ_CAP + k]
                  if seen[w] == (0 as u8) { seen[w] = 1 as u8; stack[sp] = w; sp = sp + 1 }
                  k = k + 1
              }
          }
          if odd > 0 { openc = openc + 1 }
      } }
      v = v + 1
  }
  if over > 0 { openc = openc + 1 }
  stat[GMG_S_LOOPS] = loops
  stat[GMG_S_OPEN] = openc
  stat[GMG_S_NV] = G[GMG_C_ONV]
  stat[GMG_S_NT] = G[GMG_C_ONT]
  return G[GMG_C_ONV]
1218}
1219
1220// gmg_gen_all: every kind into one GARM section buffer (sec, GMG_SEC_CAP words). stats = 9 x GMG_STAT_N.
1221// Returns the section's word count, or a negative refusal (kind named on stdout).
1222func gmg_gen_all(G: *i64, sec: *i64, stats: *i64) -> i64 {
  let nk: i64 = GMG_KINDS
  var p: i64 = GMG_HDR + nk * GMG_DIRSTRIDE
  sec[0] = GMG_GARM_VER
  sec[1] = nk
  sec[2] = GMG_VSTRIDE
  sec[3] = GMG_TSTRIDE
  sec[4] = G[GMG_C_UPMK]
  sec[5] = GMG_DIRSTRIDE
  sec[6] = 0
  sec[7] = 0
  var k: i64 = 1
  while k <= nk {
      let st: *i64 = ((stats as i64) + (k - 1) * GMG_STAT_N * 8) as *i64
      let r: i64 = gmg_build(G, k, st)
      if r < 0 { gmg_puts("GMG-REFUSED kind=" as *u8); gmg_pn(k); gmg_puts(" build refused rc=" as *u8); gmg_pn(r); gmg_puts("\n" as *u8); return r }
      if r == 0 { gmg_puts("GMG-REFUSED kind=" as *u8); gmg_pn(k); gmg_puts(" selects no triangle (an id with no mesh would silently stay paint)\n" as *u8); return GMG_ERR_EMPTY }
      let onv: i64 = G[GMG_C_ONV]
      let ont: i64 = G[GMG_C_ONT]
      if p + onv * GMG_VSTRIDE + ont * GMG_TSTRIDE > GMG_SEC_CAP { gmg_puts("GMG-REFUSED section cap\n" as *u8); return GMG_ERR_CAP }
      let d: i64 = GMG_HDR + (k - 1) * GMG_DIRSTRIDE
      sec[d] = k
      sec[d + 1] = onv
      sec[d + 2] = ont
      sec[d + 3] = p
      let ov: *i64 = G[GMG_C_OV] as *i64
      var i: i64 = 0
      while i < onv * GMG_VSTRIDE { sec[p + i] = ov[i]; i = i + 1 }
      p = p + onv * GMG_VSTRIDE
      sec[d + 4] = p
      let ot: *i64 = G[GMG_C_OT] as *i64
      i = 0
      while i < ont * GMG_TSTRIDE { sec[p + i] = ot[i]; i = i + 1 }
      p = p + ont * GMG_TSTRIDE
      sec[d + 5] = st[GMG_S_T]
      sec[d + 6] = st[GMG_S_EASE]
      sec[d + 7] = st[GMG_S_CLASS]
      st[GMG_S_VOFF] = sec[d + 3]
      st[GMG_S_TOFF] = sec[d + 4]
      k = k + 1
  }
  sec[6] = p
  return p
1265}
1266
1267// one stats line per kind -- the receipt the program prints and the gate re-derives in-process
1268func gmg_print_stat(st: *i64) -> i64 {
  gmg_puts("GARM kind=" as *u8); gmg_pn(st[GMG_S_ID])
  gmg_puts(" class=" as *u8); gmg_pn(st[GMG_S_CLASS])
  gmg_puts(" verts=" as *u8); gmg_pn(st[GMG_S_NV])
  gmg_puts(" tris=" as *u8); gmg_pn(st[GMG_S_NT])
  gmg_puts(" shell=" as *u8); gmg_pn(st[GMG_S_SHELL])
  gmg_puts(" sel=" as *u8); gmg_pn(st[GMG_S_SEL])
  gmg_puts(" hem_quads=" as *u8); gmg_pn(st[GMG_S_HEM])
  gmg_puts(" boundary_edges=" as *u8); gmg_pn(st[GMG_S_BEDGES])
  gmg_puts(" loops=" as *u8); gmg_pn(st[GMG_S_LOOPS])
  gmg_puts(" open_chains=" as *u8); gmg_pn(st[GMG_S_OPEN])
  gmg_puts(" pushed=" as *u8); gmg_pn(st[GMG_S_PUSHED])
  gmg_puts(" straps=" as *u8); gmg_pn(st[GMG_S_STRAPS])
  gmg_puts(" t_units=" as *u8); gmg_pn(st[GMG_S_T])
  gmg_puts(" hem_units=" as *u8); gmg_pn(st[GMG_S_TH])
  gmg_puts(" ease_units=" as *u8); gmg_pn(st[GMG_S_EASE])
  gmg_puts(" within_09t=" as *u8); gmg_pn(st[GMG_S_WITHIN])
  gmg_puts(" minclear_floor=" as *u8); gmg_pn(st[GMG_S_MINCLEAR])
  gmg_puts(" strap_ends_dm=" as *u8); gmg_pn(st[GMG_S_SLF]); gmg_puts("/" as *u8); gmg_pn(st[GMG_S_SLB]); gmg_puts("/" as *u8); gmg_pn(st[GMG_S_SRF]); gmg_puts("/" as *u8); gmg_pn(st[GMG_S_SRB])
  gmg_puts(" nbr_overflow=" as *u8); gmg_pn(st[GMG_S_NBROVER])
  gmg_puts(" pinch_passes=" as *u8); gmg_pn(st[GMG_S_PINCHPASS])
  gmg_puts("\n" as *u8)
  return 0
1291}
1292
1293// gmg_write_nxa: copy every section of the input and append GARM (TOC rebuilt, checksums re-folded)
1294func gmg_write_nxa(b: *u8, flen: i64, sec: *i64, nwords: i64, outpath: *u8) -> i64 {
  let h: *i64 = b as *i64
  let ons: i64 = h[2]
  let otoc: *i64 = ((b as i64) + 32) as *i64
  // an input already carrying GARM is REPLACED, never doubled (idempotent re-runs)
  let gtag: i64 = nxa_tag4("GARM" as *u8)
  var keep: i64 = 0
  var ti: i64 = 0
  while ti < ons { if otoc[ti * 4] != gtag { keep = keep + 1 } ti = ti + 1 }
  let ns2: i64 = keep + 1
  let hdr: *i64 = sys_mmap(64) as *i64
  let toc: *i64 = sys_mmap(ns2 * 32 + 64) as *i64
  var o: i64 = 32 + ns2 * 32
  var w: i64 = 0
  ti = 0
  while ti < ons {
      if otoc[ti * 4] != gtag {
          toc[w * 4] = otoc[ti * 4]
          toc[w * 4 + 1] = o
          toc[w * 4 + 2] = otoc[ti * 4 + 2]
          toc[w * 4 + 3] = otoc[ti * 4 + 3]
          o = o + otoc[ti * 4 + 2] * 8
          w = w + 1
      }
      ti = ti + 1
  }
  toc[w * 4] = gtag
  toc[w * 4 + 1] = o
  toc[w * 4 + 2] = nwords
  toc[w * 4 + 3] = nxa_check2(1, sec, nwords)
  hdr[0] = nxa_magic()
  hdr[1] = NXA_VER
  hdr[2] = ns2
  hdr[3] = nxa_check2(1, toc, ns2 * 4)
  let fd: i64 = sys_openat_wr(outpath, MODE_0644)
  if fd < 0 { return 0 - 9 }
  sys_write(fd, hdr as *u8, 32)
  sys_write(fd, toc as *u8, ns2 * 32)
  ti = 0
  while ti < ons {
      if otoc[ti * 4] != gtag { sys_write(fd, ((b as i64) + otoc[ti * 4 + 1]) as *u8, otoc[ti * 4 + 2] * 8) }
      ti = ti + 1
  }
  sys_write(fd, sec as *u8, nwords * 8)
  sys_close(fd)
  return 0
1340}
1341
1342// Additive boundary contract v1: clip one source triangle by its vertex scalar samples.
1343// Output is at most four [bary0 numerator,bary1 numerator,bary2 numerator,denominator]
1344// records in original winding. Ratios are exact integers: no weight truncation or coordinate rounding.
1345// A consumer may interpolate already-deformed source vertices, preserving the current triangle surface;
1346// interpolating joint weights and then dual-quaternion skinning is NOT equivalent and is not implied.
1347// Material, source triangle identity and garment offset remain explicit caller-owned attributes.
1348const GMG_CLIP_RECORD_WORDS:i64=4
1349const GMG_CLIP_CAP_WORDS:i64=16
1350const GMG_CLIP_DISTANCE_MAX:i64=2147483647
1351const GMG_CLIP_E_INPUT:i64=0-30
1352const GMG_CLIP_E_CAP:i64=0-31
1353func gmg_clip_distance(a:i64,b:i64,c:i64,k:i64)->i64 {
if k==0{return a};if k==1{return b};return c
1355}
1356func gmg_clip_vertex(out:*i64,n:i64,k:i64)->i64 {
var i:i64=0;while i<3{out[n*4+i]=0;i=i+1};out[n*4+k]=1;out[n*4+3]=1;return n+1
1358}
1359func gmg_clip_crossing(out:*i64,n:i64,s:i64,e:i64,ds:i64,de:i64)->i64 {
let a:i64=gmg_abs(ds);let b:i64=gmg_abs(de)
var i:i64=0;while i<3{out[n*4+i]=0;i=i+1}
out[n*4+s]=b;out[n*4+e]=a;out[n*4+3]=a+b;return n+1
1363}
1364func gmg_clip_triangle_bary_v1(distance:*i64,out:*i64,cap_words:i64)->i64 {
if (distance as i64)==0||(out as i64)==0{return GMG_CLIP_E_INPUT}
if cap_words<GMG_CLIP_CAP_WORDS{return GMG_CLIP_E_CAP}
let a:i64=distance[0];let b:i64=distance[1];let c:i64=distance[2]
if a<0-GMG_CLIP_DISTANCE_MAX||a>GMG_CLIP_DISTANCE_MAX{return GMG_CLIP_E_INPUT}
if b<0-GMG_CLIP_DISTANCE_MAX||b>GMG_CLIP_DISTANCE_MAX{return GMG_CLIP_E_INPUT}
if c<0-GMG_CLIP_DISTANCE_MAX||c>GMG_CLIP_DISTANCE_MAX{return GMG_CLIP_E_INPUT}
var n:i64=0;var e:i64=0
while e<3 {
let s:i64=(e+2)%3;let ds:i64=gmg_clip_distance(a,b,c,s);let de:i64=gmg_clip_distance(a,b,c,e)
if ds<0&&de>0{n=gmg_clip_crossing(out,n,s,e,ds,de)}
if de>=0{n=gmg_clip_vertex(out,n,e)}
if ds>0&&de<0{n=gmg_clip_crossing(out,n,s,e,ds,de)}
e=e+1
}
if n<3{return 0}
return n
1381}
1382
1383// Repeated halfspace clipping composes ORIGINAL source-triangle barycentrics.
1384// Caller supplies disjoint input/output/scratch buffers; refusals leave output unchanged.
1385// Checked i64 arithmetic refuses unrepresentable exact ratios instead of rounding provenance.
1386const GMG_CLIP_E_RANGE:i64=0-32
1387const GMG_CLIP_I64_MAX:i64=9223372036854775807
1388func gmg_clip_product(a:i64,b:i64)->i64{return ngb_clip_product(a,b)}
1389func gmg_clip_gcd(a:i64,b:i64)->i64{return ngb_clip_gcd(a,b)}
1390func gmg_clip_scalar(d:*i64,r:*i64,result:*i64)->i64 {
let den:i64=r[3];if den<=0{return GMG_CLIP_E_INPUT}
var sum:i64=0;var v:i64=0;var k:i64=0
while k<3{
let n:i64=r[k];if n<0||n>den-sum{return GMG_CLIP_E_INPUT};sum=sum+n
if d[k]<0-GMG_CLIP_DISTANCE_MAX||d[k]>GMG_CLIP_DISTANCE_MAX{return GMG_CLIP_E_INPUT}
let p:i64=gmg_clip_product(n,gmg_abs(d[k]));if p<0{return GMG_CLIP_E_RANGE}
if d[k]>=0 {if v>GMG_CLIP_I64_MAX-p{return GMG_CLIP_E_RANGE};v=v+p}
else{if v<0-GMG_CLIP_I64_MAX+p{return GMG_CLIP_E_RANGE};v=v-p}
k=k+1
}
if sum!=den{return GMG_CLIP_E_INPUT};result[0]=v;return 0
1402}
1403func gmg_clip_polygon_bary_v1(d:*i64,input:*i64,n:i64,out:*i64,scratch:*i64,cap_words:i64)->i64 {
if n<3||n>7{return GMG_CLIP_E_INPUT}
if (d as i64)==0||(input as i64)==0||(out as i64)==0||(scratch as i64)==0{return GMG_CLIP_E_INPUT}
if input==out||input==scratch||out==scratch{return GMG_CLIP_E_INPUT}
if cap_words<(n+1)*4+2{return GMG_CLIP_E_CAP}
var count:i64=0;var e:i64=0
// Scratch capacity includes two named scalar workspace words after polygon capacity.
let scalar:*i64=((scratch as i64)+(cap_words-2)*8) as *i64
while e<n{
let s:i64=(e+n-1)%n;let a:*i64=((input as i64)+s*32) as *i64;let b:*i64=((input as i64)+e*32) as *i64
let ra:i64=gmg_clip_scalar(d,a,scalar);if ra<0{return ra}
let rb:i64=gmg_clip_scalar(d,b,((scalar as i64)+8) as *i64);if rb<0{return rb}
let ds:i64=scalar[0];let de:i64=scalar[1]
if (ds<0&&de>0)||(ds>0&&de<0){
 if count>=n+1{return GMG_CLIP_E_CAP}
 let ad:i64=gmg_abs(ds);let bd:i64=gmg_abs(de);var div:i64=0;var k:i64=0
 while k<4{
  let x:i64=gmg_clip_product(a[k],bd);let y:i64=gmg_clip_product(b[k],ad)
  if x<0||y<0{return GMG_CLIP_E_RANGE};if x>GMG_CLIP_I64_MAX-y{return GMG_CLIP_E_RANGE}
  let v:i64=x+y;scratch[count*4+k]=v;div=gmg_clip_gcd(div,v);k=k+1
 }
 if div<=0{return GMG_CLIP_E_INPUT};k=0;while k<4{scratch[count*4+k]=scratch[count*4+k]/div;k=k+1};count=count+1
}
if de>=0{if count>=n+1{return GMG_CLIP_E_CAP};var k:i64=0;while k<4{scratch[count*4+k]=b[k];k=k+1};count=count+1}
e=e+1
}
if count<3{return 0};var k:i64=0;while k<count*4{out[k]=scratch[k];k=k+1};return count
1430}
1431
1432// Twice polygon area in the canonical source triangle's (bary1,bary2) plane.
1433// Exact numerator/denominator; positive winding and <=1 means no inverted/expanded source coverage.
1434// Input records are already validated by the clipping boundary. Large common denominators refuse.
1435func gmg_clip_area_ratio_v1(poly:*i64,n:i64,result:*i64)->i64{return ngb_clip_area_ratio_v1(poly,n,result)}
1436
1437// GAT1 v1: additive source-surface attachments; legacy GARM is unchanged.
1438// Header 12 words: version,record_count,triangle_count,record_stride,VERT_check,TRIS_check,
1439// source_nv,source_nt,kind,total_words,triangle_stride,reserved.
1440// Record 8 words: source_face,bary0,bary1,bary2,denominator,normal_offset_units,material,flags.
1441// Triangle 3 words: attachment record indices. Coefficients remain exact i64 on disk.
1442const GMG_ATTACH_HDR:i64=12
1443const GMG_ATTACH_REC:i64=8
1444const GMG_ATTACH_COORD_MAX:i64=16777216
1445const GMG_ATTACH_E_SOURCE:i64=-40
1446const GMG_ATTACH_E_SHAPE:i64=-41
1447const GMG_ATTACH_E_GEOMETRY:i64=-42
1448// Exact integer coordinates and products of differences fit i64 under this boundary.
1449func gmg_attach_source_v1(b:*u8,n:i64)->i64{return ngb_attach_source_v1(b,n)}
1450func gmg_attach_face_v1(pos:*i64,idx:*i64,face:i64)->i64{return ngb_attach_face_v1(pos,idx,face)}
1451// Validate before consumer upload. Native NXA checks are integrity checks, not cryptographic authentication.
1452// Caller workspace: 14 i64 words, disjoint from section/source; no output mesh or device mutation here.
1453func gmg_attach_validate_v1(b:*u8,n:i64,s:*i64,nw:i64,work:*i64,work_words:i64)->i64{return ngb_attach_validate_v1(b,n,s,nw,work,work_words)}
1454
1455// Existing one-piece anatomical boundaries, now clipped exactly instead of whole-face selection.
1456// Caller-owned scratch: three 34-word polygons, two distance triples, four material words (112 total).
1457// out==0 measures required words. A nonzero output needs that capacity; only success is consumable.
1458func gmg_attach_onepiece_into_v1(G:*i64,out:*i64,cap:i64,scratch:*i64,sw:i64)->i64{
if (G as i64)==0||(scratch as i64)==0||sw<112{return GMG_ATTACH_E_SHAPE}
let b:*u8=G[GMG_C_B] as *u8;let flen:i64=G[GMG_C_FLEN];let valid:i64=gmg_attach_source_v1(b,flen);if valid<0{return valid}
let a:*i64=scratch;let p:*i64=((scratch as i64)+272) as *i64;let work:*i64=((scratch as i64)+544) as *i64
let d:*i64=((scratch as i64)+816) as *i64;let e:*i64=((scratch as i64)+840) as *i64;let mat:*i64=((scratch as i64)+864) as *i64
gmg_mat(G,3,mat);let off:i64=mat[0];let idx:*i64=G[GMG_C_IDX] as *i64;let hh:*i64=gmg_hh(G)
var totalv:i64=0;var totalt:i64=0;var pass:i64=0;var need:i64=0
while pass<2{var nv:i64=0;var nt:i64=0;var face:i64=0
while face<G[GMG_C_NT]{let v0:i64=idx[face*3];let v1:i64=idx[face*3+1];let v2:i64=idx[face*3+2]
 if gmg_has(G,v0,GMG_VF_TOR)==1&&gmg_has(G,v1,GMG_VF_TOR)==1&&gmg_has(G,v2,GMG_VF_TOR)==1{
  var k:i64=0;while k<3{let v:i64=idx[face*3+k];d[k]=hh[v]-gmg_hleg(G,v);e[k]=gmg_hneck(G,v)-hh[v];k=k+1}
  let n:i64=gmg_clip_triangle_bary_v1(d,a,16);if n<0{return n};var m:i64=0
  if n>0{m=gmg_clip_polygon_bary_v1(e,a,n,p,work,34);if m<0{return m}}
  if m>0{if gmg_attach_face_v1(G[GMG_C_POS] as *i64,idx,face)<0{return GMG_ATTACH_E_GEOMETRY}
   if pass==1{k=0;while k<m{let r:i64=GMG_ATTACH_HDR+(nv+k)*GMG_ATTACH_REC;out[r]=face;var j:i64=0;while j<4{out[r+1+j]=p[k*4+j];j=j+1};out[r+5]=off;out[r+6]=3;out[r+7]=0;k=k+1}
    k=1;while k<m-1{let t:i64=GMG_ATTACH_HDR+totalv*GMG_ATTACH_REC+nt*3;out[t]=nv;out[t+1]=nv+k;out[t+2]=nv+k+1;nt=nt+1;k=k+1}
   }else{nt=nt+m-2};nv=nv+m
  }
 };face=face+1
}
if pass==0{totalv=nv;totalt=nt;if totalv<3||totalt<1{return GMG_ATTACH_E_GEOMETRY}
 if totalv>(GMG_CLIP_I64_MAX-GMG_ATTACH_HDR)/GMG_ATTACH_REC{return GMG_CLIP_E_RANGE};need=GMG_ATTACH_HDR+totalv*GMG_ATTACH_REC
 if totalt>(GMG_CLIP_I64_MAX-need)/3{return GMG_CLIP_E_RANGE};need=need+totalt*3
 if (out as i64)==0{return need};if cap<need{return GMG_CLIP_E_CAP}
 let h:*i64=b as *i64;let ve:i64=nxa_section_entry(b,flen,nxa_tag4("VERT"));let te:i64=nxa_section_entry(b,flen,nxa_tag4("TRIS"))
 out[0]=1;out[1]=totalv;out[2]=totalt;out[3]=GMG_ATTACH_REC;out[4]=h[ve+3];out[5]=h[te+3]
 out[6]=G[GMG_C_NV];out[7]=G[GMG_C_NT];out[8]=3;out[9]=need;out[10]=3;out[11]=0
}else{if nv!=totalv||nt!=totalt{return GMG_ATTACH_E_SHAPE}};pass=pass+1
};return need
1487}
1488// Compose an additive section in the existing NXA container; preserve all other payload words.
1489// Disjoint buffers required. No filesystem side effects; caller publishes only validated output.
1490func gmg_attach_compose_into_v1(b:*u8,n:i64,s:*i64,nw:i64,out:*u8,cap:i64,work:*i64,ww:i64)->i64{
let valid:i64=gmg_attach_validate_v1(b,n,s,nw,work,ww);if valid<0{return valid}
if (out as i64)==0||out==b||(out as i64)==(s as i64){return GMG_ATTACH_E_SHAPE}
let h:*i64=b as *i64;let tag:i64=nxa_tag4("GAT1");let ns:i64=h[2];var keep:i64=0;var old:i64=0;var bytes:i64=0;var i:i64=0
while i<ns{let t:i64=4+i*4;let found:i64=nxa_section_entry(b,n,h[t]);if found!=t{return GMG_ATTACH_E_SOURCE}
if h[t]==tag{old=old+1}else{keep=keep+1;if h[t+2]>(GMG_CLIP_I64_MAX-bytes)/8{return GMG_CLIP_E_RANGE};bytes=bytes+h[t+2]*8};i=i+1
};if old>1{return GMG_ATTACH_E_SOURCE}
if nw>GMG_CLIP_I64_MAX/8{return GMG_CLIP_E_RANGE};let head:i64=32+(keep+1)*32
if bytes>GMG_CLIP_I64_MAX-head{return GMG_CLIP_E_RANGE};let base:i64=head+bytes
if nw>(GMG_CLIP_I64_MAX-base)/8{return GMG_CLIP_E_RANGE};let need:i64=base+nw*8;if cap<need{return GMG_CLIP_E_CAP}
let dst:*i64=out as *i64;dst[0]=nxa_magic();dst[1]=NXA_VER;dst[2]=keep+1
var at:i64=head/8;var w:i64=0;i=0;while i<ns{let t:i64=4+i*4;if h[t]!=tag{let dt:i64=4+w*4;dst[dt]=h[t];dst[dt+1]=at*8;dst[dt+2]=h[t+2];dst[dt+3]=h[t+3]
var j:i64=0;while j<h[t+2]{dst[at+j]=h[h[t+1]/8+j];j=j+1};at=at+h[t+2];w=w+1};i=i+1
}
let dt:i64=4+w*4;dst[dt]=tag;dst[dt+1]=at*8;dst[dt+2]=nw;dst[dt+3]=nxa_check2(1,s,nw)
i=0;while i<nw{dst[at+i]=s[i];i=i+1};dst[3]=nxa_check2(1,((out as i64)+32) as *i64,(keep+1)*4);return need
1506}
nx_garment_canonical_prepare_t135.nx source

`nx_garment_canonical_prepare_t135.nx` source
