nx_clipcheck.nx source
↩ module page · 479 lines · 21277 B
1// nx_clipcheck.nx -- THE ANIMATION CLIPPING RULER (debt 1786578438; operator 2026-08-12: evaluate
2// art/realism/quality/CLIPPING). Measures, per ANIM key of a chn-2 NXA clip, how deep tracked
3// limb joints penetrate (a) the TORSO CAPSULE and (b) the FLOOR plane -- the two gross clipping
4// classes the eye reports as "arm through chest" and "foot through ground". Joint world position
5// per key = bind + dt (the wire's dt lanes ARE world displacement, mm -> 0.01mm x100), exactly the
6// player's apply contract -- no quat math needed for JOINT CENTERS.
7//
8// DECLARED IMPRECISION (imprecision named or the next reader trusts it as exact):
9// - torso = ONE vertical capsule at the spine-band centroid, radius CC_TORSO_R (data below), span
10// 40..80 permil of stature; limbs = points with radius CC_LIMB_R. Real flesh is neither.
11// - ELIGIBILITY: only joints whose BIND already sits OUTSIDE torso_r+limb_r+grace are measured
12// (wrists/elbows/fingertips/ankles) -- hips/shoulders bind INSIDE the capsule and would be
13// permanent false positives (the bind pose is the clean control by construction).
14// - v1 measures limb-vs-TORSO and vs-FLOOR only, NOT limb-vs-limb.
15//
16// THE BVH LANE (2026-08-13, debt 1786598036) -- the MOCAP-SELF-CLEARANCE CONTROL, the
17// two-instruments law applied to the retarget: the SAME capsule measure over the mocap SOURCE
18// skeleton (FK via nx_bvhfk_lib -- the proven incumbent, never a re-implementation). If the
19// source clips the same capsule at the same keys, the retarget is faithful and the residual is
20// ruler coarseness; if the source is clean, the gap belongs to the emitter. DECLARED:
21// - the reference NXA supplies the STATURE BRIDGE (BVH declares no unit; source positions are
22// scaled so both skeletons share a stature) -- proportions are the subject, not absolute size.
23// - axes are MEASURED from the rest pose: up = bone-length-weighted alignment (a T-pose span
24// exceeds its height, so extent misdetects up); side = widest remaining extent; ambiguous
25// alignment REFUSES rather than guessing gravity.
26// - root POSITIONAL channels are ZEROED per frame: the nxa emitter lane is rotations-only /
27// in-place BY DESIGN, so the control mirrors its subject. Rest pose (all channels zero) is the
28// bind analog for eligibility. Keys were emitted 1:1 from frames, so key == frame.
29// - measures every parser-exposed joint whose rest pose sits outside capsule+grace (the NXA lane
30// measures tracked joints; both predicates are "rest/bind outside").
31// usage: nx_clipcheck <clip.nxa> [detail <key> <joint>] | bvh <clip.bvh> <ref.nxa> [up=x|y|z]
32// exit: 0 CLEAN (worst <= CC_TOL_MM) | 1 CLIP (worst key+joint NAMED) | 4 refuse (parse)
33// license_tier: ORIGINAL No hw writes (Rule 26).
34import "nx_syscalls.nx"
35import "nx_nxa.nx"
36import "nx_clipcap_lib.nx"
37import "nx_bvh_lib.nx"
38import "nx_bvhfk_lib.nx"
39const CC_MAGIC_1000000: i64 = 1000000
40const CC_MAGIC_32767: i64 = 32767
41const CC_MAGIC_65536: i64 = 65536
42const CC_TOL_MM: i64 = 10 // verdict tolerance, mm; capsule GEOMETRY lives in nx_clipcap_lib
43
44func cc_slen(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
45func cc_puts(s: *u8) -> i64 { sys_write(1, s, cc_slen(s)); return 0 }
46func cc_pn(v: i64) -> i64 {
47 if v == 0 { sys_write(1, "0" as *u8, 1); return 0 }
48 var m: i64 = v
49 if m < 0 { sys_write(1, "-" as *u8, 1); m = 0 - m }
50 let t: *u8 = sys_mmap(32)
51 var k: i64 = 0
52 while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
53 let o: *u8 = sys_mmap(32)
54 var i: i64 = 0
55 while i < k { o[i] = t[k - 1 - i]; i = i + 1 }
56 sys_write(1, o, k)
57 return 0
58}
59func cc_atoi(s: *u8) -> i64 {
60 var v: i64 = 0
61 var i: i64 = 0
62 while s[i] != (0 as u8) {
63 let c: i64 = s[i] as i64
64 if c >= 48 { if c <= 57 { v = v*10 + (c - 48) } }
65 i = i + 1
66 }
67 return v
68}
69func cc_streq(a: *u8, b: *u8) -> i64 {
70 var i: i64 = 0
71 while a[i] != (0 as u8) {
72 if a[i] != b[i] { return 0 }
73 i = i + 1
74 }
75 if b[i] != (0 as u8) { return 0 }
76 return 1
77}
78func cc_sgn16(w: i64) -> i64 {
79 var v: i64 = w & 0xffff
80 if v > CC_MAGIC_32767 { v = v - CC_MAGIC_65536 }
81 return v
82}
83// cc_pseg + capsule derivation come from nx_clipcap_lib (one ruler estate-wide)
84// measure ONE joint position against torso+floor; updates R in place.
85// R layout: [0]=worst_torso [1]=wt_key [2]=wt_joint [3]=worst_floor [4]=wf_key [5]=wf_joint
86// [6]=eligible_tracks [7]=keys_measured [8]=keys_torso_clip [9]=keys_floor_clip
87// axis/floor params in AX: [0]=ax [1]=ay [2]=z1 [3]=z2 [4]=floor_z
88func cc_meas(px: i64, py: i64, pz: i64, j: i64, key: i64, AX: *i64, R: *i64) -> i64 {
89 let d: i64 = cc_pseg(px, py, pz, AX[0], AX[1], AX[2], AX[3])
90 let pen: i64 = (CC_TORSO_R + CC_LIMB_R) - d
91 if pen > 0 {
92 R[8] = R[8] + 1
93 if pen > R[0] { R[0] = pen; R[1] = key; R[2] = j }
94 }
95 let fpen: i64 = AX[4] - (pz - CC_LIMB_R)
96 if fpen > 0 {
97 R[9] = R[9] + 1
98 if fpen > R[3] { R[3] = fpen; R[4] = key; R[5] = j }
99 }
100 R[7] = R[7] + 1
101 return 0
102}
103// scan a chn-2 NXA clip; fills R (see cc_meas) ; rc 0 ok / 4 refuse-with-reason-printed
104func cc_scan_nxa(path: *u8, R: *i64) -> i64 {
105 var z: i64 = 0
106 while z < 10 { R[z] = 0; z = z + 1 }
107 let lp: *i64 = sys_mmap(16) as *i64
108 let b: *u8 = sys_read_file(path, lp)
109 if (b as i64) == 0 { cc_puts("CLIPCHECK REFUSED: cannot read clip\n" as *u8); return 4 }
110 let flen: i64 = lp[0]
111 let W: *i64 = b as *i64
112 let sow: i64 = nxa_find(b, flen, nxa_tag4("SKEL" as *u8))
113 if sow < 1 { cc_puts("CLIPCHECK REFUSED: SKEL missing\n" as *u8); return 4 }
114 let ao: i64 = nxa_find(b, flen, nxa_tag4("ANIM" as *u8))
115 if ao < 1 { cc_puts("CLIPCHECK REFUSED: ANIM missing\n" as *u8); return 4 }
116 // capsule from binds via the SHARED definition (nx_clipcap_lib -- one ruler estate-wide)
117 let AX: *i64 = sys_mmap(8*8) as *i64
118 if cc_axis_skel(W, sow, AX) < 0 { cc_puts("CLIPCHECK REFUSED: no spine-band joints\n" as *u8); return 4 }
119 // ANIM walk
120 let ntr: i64 = W[ao]
121 var o: i64 = ao + 1
122 var tr: i64 = 0
123 while tr < ntr {
124 let tj: i64 = W[o]
125 let chn: i64 = W[o+1]
126 let nk: i64 = W[o+2]
127 o = o + 3
128 if chn == 2 {
129 // eligibility: BIND outside the capsule + grace (hips/shoulders excluded by construction)
130 let bd: i64 = cc_pseg(W[sow+1+tj*8+1], W[sow+1+tj*8+2], W[sow+1+tj*8+3], AX[0], AX[1], AX[2], AX[3])
131 if bd > CC_TORSO_R + CC_LIMB_R + CC_GRACE {
132 R[6] = R[6] + 1
133 var k: i64 = 0
134 while k < nk {
135 let w1: i64 = W[o + k*2 + 1]
136 let dgx: i64 = cc_sgn16(w1 >> 16)
137 let dgy: i64 = cc_sgn16(w1 >> 32)
138 let dgz: i64 = cc_sgn16(w1 >> 48)
139 cc_meas(W[sow+1+tj*8+1] + dgx*100, W[sow+1+tj*8+2] + dgy*100, W[sow+1+tj*8+3] + dgz*100, tj, k, AX, R)
140 k = k + 1
141 }
142 }
143 o = o + nk*2
144 } else {
145 // chn 0/1 legacy strides (32B/40B per key) skipped exactly as the player skips them
146 var kb: i64 = nk*4
147 if chn == 1 { kb = nk*5 }
148 o = o + kb
149 }
150 tr = tr + 1
151 }
152 return 0
153}
154
155// ===== BVH SELF-CLEARANCE CONTROL (see header) ====================================
156// The SAME capsule measure over the mocap source: parse via nx_bvh_lib, FK via nx_bvhfk_lib,
157// stature bridged to the reference NXA, root positional channels zeroed (rotations-only subject).
158func cc_scan_bvh(bpath: *u8, npath: *u8, upHint: i64, R: *i64) -> i64 {
159 var z: i64 = 0
160 while z < 10 { R[z] = 0; z = z + 1 }
161 // reference stature from the NXA binds (0.01mm)
162 let lp: *i64 = sys_mmap(16) as *i64
163 let nb: *u8 = sys_read_file(npath, lp)
164 if (nb as i64) == 0 { cc_puts("BVH-CONTROL REFUSED: cannot read ref nxa\n" as *u8); return 4 }
165 let W: *i64 = nb as *i64
166 let sow: i64 = nxa_find(nb, lp[0], nxa_tag4("SKEL" as *u8))
167 if sow < 1 { cc_puts("BVH-CONTROL REFUSED: ref SKEL missing\n" as *u8); return 4 }
168 let AXn: *i64 = sys_mmap(8*8) as *i64
169 if cc_axis_skel(W, sow, AXn) < 0 { cc_puts("BVH-CONTROL REFUSED: ref no spine band\n" as *u8); return 4 }
170 let statn: i64 = AXn[5]
171 if statn <= 0 { cc_puts("BVH-CONTROL REFUSED: ref stature zero\n" as *u8); return 4 }
172 // parse the BVH source
173 let bl: *i64 = sys_mmap(16) as *i64
174 let bb: *u8 = sys_read_file(bpath, bl)
175 if (bb as i64) == 0 { cc_puts("BVH-CONTROL REFUSED: cannot read bvh\n" as *u8); return 4 }
176 let H: *i64 = sys_mmap(B_H_WORDS * 8) as *i64
177 let names: *u8 = sys_mmap(B_MAX_JOINTS * B_NAMEW)
178 let parent: *i64 = sys_mmap(B_MAX_JOINTS * 8) as *i64
179 let nchan: *i64 = sys_mmap(B_MAX_JOINTS * 8) as *i64
180 let chan0: *i64 = sys_mmap(B_MAX_JOINTS * 8) as *i64
181 let off: *i64 = sys_mmap(B_MAX_JOINTS * 24) as *i64
182 let chtype: *i64 = sys_mmap(B_MAX_CHAN * 8) as *i64
183 let vals: *i64 = sys_mmap(B_MAX_CHAN * 8) as *i64
184 let rot: *i64 = sys_mmap(B_MAX_JOINTS * 9 * 8) as *i64
185 let pos: *i64 = sys_mmap(B_MAX_JOINTS * 3 * 8) as *i64
186 if b_parse(bb, bl[0], H, names, parent, nchan, chan0, off, chtype) < 0 {
187 cc_puts("BVH-CONTROL REFUSED: bvh parse\n" as *u8)
188 return 4
189 }
190 let bnj: i64 = H[B_H_NJOINT]
191 let nf: i64 = H[B_H_NFRAME]
192 // REST pose (all channels zero) = the bind analog
193 var zc: i64 = 0
194 while zc < B_MAX_CHAN { vals[zc] = 0; zc = zc + 1 }
195 fk_eval(H, parent, nchan, chan0, off, chtype, vals, rot, pos)
196 let rest: *i64 = sys_mmap(B_MAX_JOINTS * 3 * 8) as *i64
197 var cj: i64 = 0
198 while cj < bnj*3 { rest[cj] = pos[cj]; cj = cj + 1 }
199 // axis mapping MEASURED from the rest pose. UP by BONE-LENGTH-WEIGHTED ALIGNMENT, not
200 // extent: a T-pose's arm SPAN can exceed its height, so extent misdetects up on exactly the
201 // skeletons this control exists for (caught live on the CMU salsa source, 2026-08-13 -- the
202 // first census ran with the capsule on its side). Legs + spine, the longest bones, align
203 // with gravity in any humanoid rest pose: acc[axis] = sum over bones of |segment.axis|
204 // peaks on the true up. Extent still chooses SIDE (span is the widest remaining direction).
205 // Ambiguity REFUSES with both candidates named, never guesses.
206 let mn: *i64 = sys_mmap(3*8) as *i64
207 let mx: *i64 = sys_mmap(3*8) as *i64
208 var a0: i64 = 0
209 while a0 < 3 { mn[a0] = rest[a0]; mx[a0] = rest[a0]; a0 = a0 + 1 }
210 var j1: i64 = 0
211 while j1 < bnj {
212 var a1: i64 = 0
213 while a1 < 3 {
214 let v: i64 = rest[j1*3 + a1]
215 if v < mn[a1] { mn[a1] = v }
216 if v > mx[a1] { mx[a1] = v }
217 a1 = a1 + 1
218 }
219 j1 = j1 + 1
220 }
221 let acc: *i64 = sys_mmap(3*8) as *i64
222 acc[0] = 0
223 acc[1] = 0
224 acc[2] = 0
225 var jb: i64 = 0
226 while jb < bnj {
227 let pb: i64 = parent[jb]
228 if pb >= 0 {
229 var ab: i64 = 0
230 while ab < 3 {
231 var dseg: i64 = rest[jb*3 + ab] - rest[pb*3 + ab]
232 if dseg < 0 { dseg = 0 - dseg }
233 acc[ab] = acc[ab] + dseg
234 ab = ab + 1
235 }
236 }
237 jb = jb + 1
238 }
239 var up: i64 = 0
240 if upHint >= 0 { up = upHint }
241 if upHint < 0 {
242 if acc[1] > acc[up] { up = 1 }
243 if acc[2] > acc[up] { up = 2 }
244 if acc[up] <= 0 { cc_puts("BVH-CONTROL REFUSED: degenerate rest skeleton\n" as *u8); return 4 }
245 var second: i64 = 0
246 if up == 0 { second = 1 }
247 var a9: i64 = 0
248 while a9 < 3 {
249 if a9 != up { if acc[a9] > acc[second] { second = a9 } }
250 a9 = a9 + 1
251 }
252 if acc[second]*1000 >= acc[up]*950 {
253 cc_puts("BVH-CONTROL REFUSED: AMBIGUOUS-UP bone-alignment axis " as *u8); cc_pn(up)
254 cc_puts(" acc=" as *u8); cc_pn(acc[up])
255 cc_puts(" vs axis " as *u8); cc_pn(second)
256 cc_puts(" acc=" as *u8); cc_pn(acc[second])
257 cc_puts(" -- within 5 percent, refusing to guess gravity; pass up=x|y|z VERIFIED from the data (e.g. nx_bvhfk pos: head vs feet)\n" as *u8)
258 return 4
259 }
260 }
261 var side: i64 = 0
262 if up == 0 { side = 1 }
263 var sbe: i64 = mx[side] - mn[side]
264 var a3: i64 = 0
265 while a3 < 3 {
266 if a3 != up { if mx[a3] - mn[a3] > sbe { sbe = mx[a3] - mn[a3]; side = a3 } }
267 a3 = a3 + 1
268 }
269 let mid: i64 = 3 - up - side
270 let statb: i64 = mx[up] - mn[up]
271 if statb <= 0 { cc_puts("BVH-CONTROL REFUSED: bvh stature zero\n" as *u8); return 4 }
272 R[10] = up
273 R[11] = side
274 R[12] = statn*CC_MAGIC_1000000/statb
275 R[13] = nf
276 R[14] = bnj
277 // midline origin = the ROOT's rest side/mid; floor = rest min up
278 let rsx: i64 = rest[side]
279 let rsy: i64 = rest[mid]
280 // capsule from REST via the same spine-band rule
281 var sbx: i64 = 0
282 var sby: i64 = 0
283 var sbn: i64 = 0
284 var j2: i64 = 0
285 while j2 < bnj {
286 let X: i64 = (rest[j2*3 + side] - rsx) * statn / statb
287 let Y: i64 = (rest[j2*3 + mid] - rsy) * statn / statb
288 var aX: i64 = X
289 if aX < 0 { aX = 0 - aX }
290 if aX < CC_MAGIC_3000 { sbx = sbx + X; sby = sby + Y; sbn = sbn + 1 }
291 j2 = j2 + 1
292 }
293 if sbn == 0 { cc_puts("BVH-CONTROL REFUSED: no spine-band joints\n" as *u8); return 4 }
294 let AX: *i64 = sys_mmap(8*8) as *i64
295 AX[0] = sbx / sbn
296 AX[1] = sby / sbn
297 AX[2] = statn*40/100
298 AX[3] = statn*80/100
299 AX[4] = 0
300 // eligibility from REST (the bind analog), same predicate
301 let elig: *i64 = sys_mmap(B_MAX_JOINTS * 8) as *i64
302 var j3: i64 = 0
303 while j3 < bnj {
304 let X: i64 = (rest[j3*3 + side] - rsx) * statn / statb
305 let Y: i64 = (rest[j3*3 + mid] - rsy) * statn / statb
306 let Z: i64 = (rest[j3*3 + up] - mn[up]) * statn / statb
307 elig[j3] = 0
308 if cc_pseg(X, Y, Z, AX[0], AX[1], AX[2], AX[3]) > CC_TORSO_R + CC_LIMB_R + CC_GRACE {
309 elig[j3] = 1
310 R[6] = R[6] + 1
311 }
312 j3 = j3 + 1
313 }
314 cc_puts("CLIPCHECK-BVH joints=" as *u8); cc_pn(bnj)
315 cc_puts(" frames=" as *u8); cc_pn(nf)
316 cc_puts(" up_axis=" as *u8); cc_pn(up)
317 cc_puts(" side_axis=" as *u8); cc_pn(side)
318 cc_puts(" scale_ppm=" as *u8); cc_pn(statn*CC_MAGIC_1000000/statb)
319 if upHint >= 0 { cc_puts(" up_src=hint" as *u8) }
320 if upHint < 0 { cc_puts(" up_src=auto" as *u8) }
321 cc_puts(" acc_x=" as *u8); cc_pn(acc[0])
322 cc_puts(" acc_y=" as *u8); cc_pn(acc[1])
323 cc_puts(" acc_z=" as *u8); cc_pn(acc[2])
324 cc_puts(" root_pos_zeroed=1\n" as *u8)
325 // per-frame scan; root positional channels ZEROED (rotations-only subject, see header)
326 var f: i64 = 0
327 while f < nf {
328 if b_frame_values(bb, bl[0], H, f, vals) < 0 { cc_puts("BVH-CONTROL REFUSED: frame read\n" as *u8); return 4 }
329 var c0: i64 = 0
330 while c0 < nchan[0] {
331 let code: i64 = chtype[chan0[0] + c0]
332 if code == B_CH_XPOS { vals[chan0[0] + c0] = 0 }
333 if code == B_CH_YPOS { vals[chan0[0] + c0] = 0 }
334 if code == B_CH_ZPOS { vals[chan0[0] + c0] = 0 }
335 c0 = c0 + 1
336 }
337 fk_eval(H, parent, nchan, chan0, off, chtype, vals, rot, pos)
338 var j4: i64 = 0
339 while j4 < bnj {
340 if elig[j4] == 1 {
341 let X: i64 = (pos[j4*3 + side] - rsx) * statn / statb
342 let Y: i64 = (pos[j4*3 + mid] - rsy) * statn / statb
343 let Z: i64 = (pos[j4*3 + up] - mn[up]) * statn / statb
344 cc_meas(X, Y, Z, j4, f, AX, R)
345 }
346 j4 = j4 + 1
347 }
348 f = f + 1
349 }
350 return 0
351}
352
353// cc_probe: print ONE (key, joint) position + axis distance -- the root-cause magnifier for a
354// worst-key finding (bind, dt, world pos, axis dist, penetration all shown; numbers not verdicts)
355func cc_probe(path: *u8, pkey: i64, pjoint: i64) -> i64 {
356 let lp: *i64 = sys_mmap(16) as *i64
357 let b: *u8 = sys_read_file(path, lp)
358 if (b as i64) == 0 { cc_puts("PROBE REFUSED: cannot read clip\n" as *u8); return 4 }
359 let flen: i64 = lp[0]
360 let W: *i64 = b as *i64
361 let sow: i64 = nxa_find(b, flen, nxa_tag4("SKEL" as *u8))
362 let ao: i64 = nxa_find(b, flen, nxa_tag4("ANIM" as *u8))
363 if sow < 1 { cc_puts("PROBE REFUSED: SKEL\n" as *u8); return 4 }
364 if ao < 1 { cc_puts("PROBE REFUSED: ANIM\n" as *u8); return 4 }
365 let AXp: *i64 = sys_mmap(8*8) as *i64
366 if cc_axis_skel(W, sow, AXp) < 0 { cc_puts("PROBE REFUSED: no spine band\n" as *u8); return 4 }
367 let axx: i64 = AXp[0]
368 let axy: i64 = AXp[1]
369 let ntr: i64 = W[ao]
370 var o: i64 = ao + 1
371 var tr: i64 = 0
372 while tr < ntr {
373 let tj: i64 = W[o]
374 let chn: i64 = W[o+1]
375 let nk: i64 = W[o+2]
376 o = o + 3
377 if chn == 2 {
378 if tj == pjoint { if pkey < nk {
379 let w1: i64 = W[o + pkey*2 + 1]
380 let dgx: i64 = cc_sgn16(w1 >> 16)
381 let dgy: i64 = cc_sgn16(w1 >> 32)
382 let dgz: i64 = cc_sgn16(w1 >> 48)
383 let px: i64 = W[sow+1+tj*8+1] + dgx*100
384 let py: i64 = W[sow+1+tj*8+2] + dgy*100
385 let pz: i64 = W[sow+1+tj*8+3] + dgz*100
386 let d: i64 = cc_pseg(px, py, pz, axx, axy, AXp[2], AXp[3])
387 cc_puts("PROBE joint=" as *u8); cc_pn(tj)
388 cc_puts(" key=" as *u8); cc_pn(pkey)
389 cc_puts("\n bind_mm=" as *u8); cc_pn(W[sow+1+tj*8+1]/100)
390 cc_puts("," as *u8); cc_pn(W[sow+1+tj*8+2]/100)
391 cc_puts("," as *u8); cc_pn(W[sow+1+tj*8+3]/100)
392 cc_puts("\n dt_mm=" as *u8); cc_pn(dgx)
393 cc_puts("," as *u8); cc_pn(dgy)
394 cc_puts("," as *u8); cc_pn(dgz)
395 cc_puts("\n world_mm=" as *u8); cc_pn(px/100)
396 cc_puts("," as *u8); cc_pn(py/100)
397 cc_puts("," as *u8); cc_pn(pz/100)
398 cc_puts("\n axis_mm=" as *u8); cc_pn(axx/100)
399 cc_puts("," as *u8); cc_pn(axy/100)
400 cc_puts(" axisdist_mm=" as *u8); cc_pn(d/100)
401 cc_puts(" pen_mm=" as *u8); cc_pn(((CC_TORSO_R + CC_LIMB_R) - d)/100)
402 cc_puts("\n" as *u8)
403 return 0
404 } }
405 o = o + nk*2
406 } else {
407 var kb: i64 = nk*4
408 if chn == 1 { kb = nk*5 }
409 o = o + kb
410 }
411 tr = tr + 1
412 }
413 cc_puts("PROBE: joint has no chn-2 track or key out of range\n" as *u8)
414 return 4
415}
416
417func main(argc: i64, argv: *i64) -> i64 {
418 if argc < 2 { cc_puts("usage: nx_clipcheck <clip.nxa> [detail <key> <joint>] | bvh <clip.bvh> <ref.nxa> [up=x|y|z]\n" as *u8); return 4 }
419 if argc >= 4 { if cc_streq(argv[1] as *u8, "bvh" as *u8) == 1 {
420 var upH: i64 = 0 - 1
421 if argc >= 5 {
422 let us: *u8 = argv[4] as *u8
423 if us[0] == (117 as u8) { if us[1] == (112 as u8) { if us[2] == (61 as u8) {
424 if us[3] == (120 as u8) { upH = 0 }
425 if us[3] == (121 as u8) { upH = 1 }
426 if us[3] == (122 as u8) { upH = 2 }
427 } } }
428 }
429 let RB: *i64 = sys_mmap(16*8) as *i64
430 let rcb: i64 = cc_scan_bvh(argv[2] as *u8, argv[3] as *u8, upH, RB)
431 if rcb != 0 { return rcb }
432 cc_puts("CLIPCHECK-BVH eligible_joints=" as *u8); cc_pn(RB[6])
433 cc_puts(" keys_measured=" as *u8); cc_pn(RB[7])
434 cc_puts(" torso_clip_keys=" as *u8); cc_pn(RB[8])
435 cc_puts(" floor_clip_keys=" as *u8); cc_pn(RB[9])
436 cc_puts("\nworst_torso_mm=" as *u8); cc_pn(RB[0]/100)
437 cc_puts(" at key=" as *u8); cc_pn(RB[1])
438 cc_puts(" joint=" as *u8); cc_pn(RB[2])
439 cc_puts("\nworst_floor_mm=" as *u8); cc_pn(RB[3]/100)
440 cc_puts(" at key=" as *u8); cc_pn(RB[4])
441 cc_puts(" joint=" as *u8); cc_pn(RB[5])
442 cc_puts("\n" as *u8)
443 var worstb: i64 = RB[0]
444 if RB[3] > worstb { worstb = RB[3] }
445 if worstb/100 > CC_TOL_MM {
446 cc_puts("verdict=CLIP\n" as *u8)
447 return 1
448 }
449 cc_puts("verdict=CLEAN\n" as *u8)
450 return 0
451 } }
452 if argc > 4 {
453 let pk: i64 = cc_atoi(argv[3] as *u8)
454 let pj: i64 = cc_atoi(argv[4] as *u8)
455 return cc_probe(argv[1] as *u8, pk, pj)
456 }
457 let R: *i64 = sys_mmap(16*8) as *i64
458 let rc: i64 = cc_scan_nxa(argv[1] as *u8, R)
459 if rc != 0 { return rc }
460 cc_puts("CLIPCHECK eligible_tracks=" as *u8); cc_pn(R[6])
461 cc_puts(" keys_measured=" as *u8); cc_pn(R[7])
462 cc_puts(" torso_clip_keys=" as *u8); cc_pn(R[8])
463 cc_puts(" floor_clip_keys=" as *u8); cc_pn(R[9])
464 cc_puts("\nworst_torso_mm=" as *u8); cc_pn(R[0]/100)
465 cc_puts(" at key=" as *u8); cc_pn(R[1])
466 cc_puts(" joint=" as *u8); cc_pn(R[2])
467 cc_puts("\nworst_floor_mm=" as *u8); cc_pn(R[3]/100)
468 cc_puts(" at key=" as *u8); cc_pn(R[4])
469 cc_puts(" joint=" as *u8); cc_pn(R[5])
470 cc_puts("\n" as *u8)
471 var worst: i64 = R[0]
472 if R[3] > worst { worst = R[3] }
473 if worst/100 > CC_TOL_MM {
474 cc_puts("verdict=CLIP\n" as *u8)
475 return 1
476 }
477 cc_puts("verdict=CLEAN\n" as *u8)
478 return 0
479}