nx_genloop_gate.nx source

1// nx_genloop_gate.nx -- R6: CLOSE THE LOOP. One circuit, all our code, no hand-crafting: 2// GENERATE (t2mesh prompt -> field) -> MESH (surface nets) -> RENDER the EMITTED mesh (existing sovereign 3// nx_meshrender/nx_render_core pipeline, per-vertex lit -- composed, not duplicated) -> PHYSICS step driven 4// by the EMITTED rig (nx_autorig masses/bones -> spring-damper jiggle; mass has consequence) -> CRITIC score 5// (nx_critic_axes, the same rulers as the critic). 6// T1 the emitted-person render has content + structure. T2 the loop generalizes (dumbbell renders differently). 7// T3 critic scores it -- and honestly LOW (CLAY expected; a high score here would smell rubber-stamp). 8// T4 physics from the emitted rig: it MOVES, SETTLES, and MASS matters (light hand swings >> heavy chest). 9// T5 sim deterministic. T6 PNG knowledge/nx_genloop.png (eyeball the loop's own output). 10// Lighting = per-vertex Gouraud baked in model space (v0, disclosed). license_tier: ORIGINAL expect_exit: 0 11import "nx_syscalls.nx" 12import "nx_sdfrender.nx" 13import "nx_t2mesh.nx" 14import "nx_meshgen.nx" 15import "nx_autorig.nx" 16import "nx_meshtex.nx" 17import "nx_critic_axes.nx" 18import "nx_png.nx" 19 20func hw(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 } 21func pn(v: i64) -> i64 { 22 let b: *u8 = sys_mmap(32) as *u8 23 var x: i64 = v 24 var neg: i64 = 0 25 if x < 0 { neg = 1; x = 0 - x } 26 var i: i64 = 31 27 if x == 0 { b[i] = 48 as u8; i = i - 1 } 28 while x > 0 { b[i] = (48 + x % 10) as u8; x = x / 10; i = i - 1 } 29 if neg == 1 { b[i] = 45 as u8; i = i - 1 } 30 sys_write(1, (b as i64 + i + 1) as *u8, 31 - i) 31 return 0 32} 33 34// per-vertex normals (fx256) from area-weighted face normals, oriented OUTWARD from the centroid 35// (surface-nets winding is not consistent; approximation disclosed -- fine for Gouraud shading). 36func gl_normals(vb: *i64, tb: *i64, nv: i64, nf: i64, nbuf: *i64) -> i64 { 37 var cx: i64 = 0 38 var cy: i64 = 0 39 var cz: i64 = 0 40 var i: i64 = 0 41 while i < nv { cx = cx + vb[i * 3]; cy = cy + vb[i * 3 + 1]; cz = cz + vb[i * 3 + 2]; i = i + 1 } 42 if nv > 0 { cx = cx / nv; cy = cy / nv; cz = cz / nv } 43 i = 0 44 while i < nv * 3 { nbuf[i] = 0; i = i + 1 } 45 var t: i64 = 0 46 while t < nf { 47 let a: i64 = tb[t * 3] 48 let b: i64 = tb[t * 3 + 1] 49 let c: i64 = tb[t * 3 + 2] 50 let e1x: i64 = vb[b * 3] - vb[a * 3] 51 let e1y: i64 = vb[b * 3 + 1] - vb[a * 3 + 1] 52 let e1z: i64 = vb[b * 3 + 2] - vb[a * 3 + 2] 53 let e2x: i64 = vb[c * 3] - vb[a * 3] 54 let e2y: i64 = vb[c * 3 + 1] - vb[a * 3 + 1] 55 let e2z: i64 = vb[c * 3 + 2] - vb[a * 3 + 2] 56 var fx: i64 = e1y * e2z - e1z * e2y 57 var fy: i64 = e1z * e2x - e1x * e2z 58 var fz: i64 = e1x * e2y - e1y * e2x 59 let mx: i64 = (vb[a * 3] + vb[b * 3] + vb[c * 3]) / 3 - cx 60 let my: i64 = (vb[a * 3 + 1] + vb[b * 3 + 1] + vb[c * 3 + 1]) / 3 - cy 61 let mz: i64 = (vb[a * 3 + 2] + vb[b * 3 + 2] + vb[c * 3 + 2]) / 3 - cz 62 if fx * mx + fy * my + fz * mz < 0 { fx = 0 - fx; fy = 0 - fy; fz = 0 - fz } 63 nbuf[a * 3] = nbuf[a * 3] + fx; nbuf[a * 3 + 1] = nbuf[a * 3 + 1] + fy; nbuf[a * 3 + 2] = nbuf[a * 3 + 2] + fz 64 nbuf[b * 3] = nbuf[b * 3] + fx; nbuf[b * 3 + 1] = nbuf[b * 3 + 1] + fy; nbuf[b * 3 + 2] = nbuf[b * 3 + 2] + fz 65 nbuf[c * 3] = nbuf[c * 3] + fx; nbuf[c * 3 + 1] = nbuf[c * 3 + 1] + fy; nbuf[c * 3 + 2] = nbuf[c * 3 + 2] + fz 66 t = t + 1 67 } 68 i = 0 69 while i < nv { 70 let x: i64 = nbuf[i * 3] 71 let y: i64 = nbuf[i * 3 + 1] 72 let z: i64 = nbuf[i * 3 + 2] 73 let l: i64 = ar_isqrt(x * x + y * y + z * z) 74 if l > 0 { nbuf[i * 3] = x * 256 / l; nbuf[i * 3 + 1] = y * 256 / l; nbuf[i * 3 + 2] = z * 256 / l } 75 else { nbuf[i * 3 + 1] = 256 } 76 i = i + 1 77 } 78 return 0 79} 80// spring-damper jiggle on the EMITTED rig (1D lateral): force impulse J on every non-root part (v0 = J/m -> 81// mass has consequence), springs along the bones pull back, damping settles it. Deterministic integer. 82func gl_sim(p: *i64, bones: *i64, masses: *i64, np: i64, nb: i64, root: i64, ox: *i64, vx: *i64, pk: *i64, steps: i64, J: i64) -> i64 { 83 var i: i64 = 0 84 while i < np { 85 ox[i] = 0 86 vx[i] = 0 87 pk[i] = 0 88 if i != root { let m: i64 = masses[i] / 500; vx[i] = J * 16 / (m + 2) } 89 i = i + 1 90 } 91 var s: i64 = 0 92 while s < steps { 93 var b: i64 = 0 94 while b < nb { 95 let pa: i64 = bones[b * 2] 96 let ch: i64 = bones[b * 2 + 1] 97 let m: i64 = masses[ch] / 500 98 let delta: i64 = ox[pa] - ox[ch] 99 vx[ch] = vx[ch] + delta * 30 / (m + 2) 100 b = b + 1 101 } 102 i = 0 103 while i < np { 104 if i != root { 105 vx[i] = vx[i] * 29 / 32 106 ox[i] = ox[i] + vx[i] / 16 107 var a: i64 = ox[i] 108 if a < 0 { a = 0 - a } 109 if a > pk[i] { pk[i] = a } 110 } 111 i = i + 1 112 } 113 s = s + 1 114 } 115 return 0 116} 117 118func main() -> i64 { 119 var fails: i64 = 0 120 let LW: i64 = 512 121 let LH: i64 = 384 122 let base: i64 = sys_mmap(sdf_bytes()) as i64 123 let F: *i64 = sys_mmap((MG_N + 1) * (MG_N + 1) * (MG_N + 1) * 8) as *i64 124 let cv: *i64 = sys_mmap(MG_N * MG_N * MG_N * 8) as *i64 125 let vb: *i64 = sys_mmap(MG_MAXV * 3 * 8) as *i64 126 let tb: *i64 = sys_mmap(MG_MAXF * 3 * 8) as *i64 127 let out: *i64 = sys_mmap(16) as *i64 128 let nbuf: *i64 = sys_mmap(MG_MAXV * 3 * 8) as *i64 129 let rverts: *i64 = sys_mmap(MG_MAXV * 4 * 8) as *i64 130 let fb: *i64 = sys_mmap(LW * LH * 8) as *i64 131 let zb: *i64 = sys_mmap(LW * LH * 8) as *i64 132 let proj: *i64 = sys_mmap(128) as *i64 133 let roty: *i64 = sys_mmap(128) as *i64 134 let mv: *i64 = sys_mmap(128) as *i64 135 let trans: *i64 = sys_mmap(128) as *i64 136 let mvp: *i64 = sys_mmap(128) as *i64 137 let vbuf4: *i64 = sys_mmap(64) as *i64 138 let clip4: *i64 = sys_mmap(64) as *i64 139 let scr: *i64 = sys_mmap(MG_MAXV * 4 * 8) as *i64 140 let tribuf: *i64 = sys_mmap(128) as *i64 141 hw("=== nx_genloop_gate -- R6 CLOSED LOOP: generate -> mesh -> render -> physics -> critic (all our code) ===\n" as *u8) 142 143 // --- GENERATE + MESH: person --- 144 t2m_prompt(base, "an Elara person figure" as *u8) 145 mg_build(base, F, cv, vb, tb, out) 146 let nv: i64 = out[0] 147 let nf: i64 = out[1] 148 hw("generate+mesh: person verts=" as *u8); pn(nv); hw(" tris=" as *u8); pn(nf); hw("\n" as *u8) 149 150 // --- RENDER the EMITTED mesh: R4 textured -- exact SDF-gradient normals + per-pixel skin (our raster) --- 151 let scratch: *i64 = sys_mmap(MG_MAXV * 6 * 8) as *i64 152 mt_sdf_normals(base, vb, nv, nbuf) 153 mt_render(vb, tb, nbuf, nv, nf, fb, zb, LW, LH, 500, 6, 540, 236, 182, scratch) 154 let drawn: i64 = nf 155 let fgp: i64 = ca_fgcount(fb, LW, LH) 156 let stru: i64 = ca_structure(fb, LW, LH) 157 hw("render: tris-drawn=" as *u8); pn(drawn); hw(" fg-px=" as *u8); pn(fgp); hw(" structure-raw=" as *u8); pn(stru); hw("\n" as *u8) 158 if fgp > 3000 { if stru > 20 { hw("T1 PASS the EMITTED person renders with content + form\n" as *u8) } else { hw("T1 FAIL structure low\n" as *u8); fails = fails + 1 } } 159 else { hw("T1 FAIL fg=" as *u8); pn(fgp); hw("\n" as *u8); fails = fails + 1 } 160 write_png(fb, LW, LH, "knowledge/nx_genloop.png" as *u8) 161 162 // --- CRITIC scores the loop's own output (same rulers as the critic) --- 163 let score: i64 = ca_score(fb, LW, LH) 164 hw("critic: score=" as *u8); pn(score); hw("/1000 verdict=" as *u8); hw(ca_verdict(score)); hw("\n" as *u8) 165 var t3: i64 = 1 166 if score < 0 { t3 = 0 } 167 if score > 1000 { t3 = 0 } 168 if score >= 400 { t3 = 0 } // a HIGH score on a flat-lit v0 mesh would smell rubber-stamp -- expect CLAY, honestly 169 if t3 == 1 { hw("T3 PASS critic scored the emitted output -- honestly CLAY (the loop measures, it does not flatter)\n" as *u8) } 170 else { hw("T3 FAIL score out of honest range\n" as *u8); fails = fails + 1 } 171 172 // --- loop GENERALIZES: a second object through the same circuit --- 173 t2m_prompt(base, "a heavy dumbbell" as *u8) 174 mg_build(base, F, cv, vb, tb, out) 175 mt_sdf_normals(base, vb, out[0], nbuf) 176 mt_render(vb, tb, nbuf, out[0], out[1], fb, zb, LW, LH, 500, 6, 540, 205, 185, scratch) // warm steel 177 let fgd: i64 = ca_fgcount(fb, LW, LH) 178 var dgap: i64 = fgp - fgd 179 if dgap < 0 { dgap = 0 - dgap } 180 hw("generalize: dumbbell fg-px=" as *u8); pn(fgd); hw("\n" as *u8) 181 if fgd > 1500 { if dgap > 500 { hw("T2 PASS the SAME circuit renders a different object differently\n" as *u8) } else { hw("T2 FAIL renders too similar\n" as *u8); fails = fails + 1 } } 182 else { hw("T2 FAIL dumbbell fg low\n" as *u8); fails = fails + 1 } 183 184 // --- PHYSICS from the EMITTED rig (person) --- 185 t2m_prompt(base, "an Elara person figure" as *u8) 186 let bones: *i64 = sys_mmap(AR_MAXP * 2 * 8) as *i64 187 let masses: *i64 = sys_mmap(AR_MAXP * 8) as *i64 188 let soft: *i64 = sys_mmap(AR_MAXP * 8) as *i64 189 let rout: *i64 = sys_mmap(8 * 8) as *i64 190 ar_build(base, bones, masses, soft, rout) 191 let p: *i64 = (base + O_PARTS) as *i64 192 let ox: *i64 = sys_mmap(AR_MAXP * 8) as *i64 193 let vx: *i64 = sys_mmap(AR_MAXP * 8) as *i64 194 let pk: *i64 = sys_mmap(AR_MAXP * 8) as *i64 195 gl_sim(p, bones, masses, rout[0], rout[1], rout[2], ox, vx, pk, 600, 6000) 196 hw("physics: peak-hand=" as *u8); pn(pk[12]); hw(" peak-chest=" as *u8); pn(pk[2]); hw(" final-hand-off=" as *u8); pn(ox[12]); hw("\n" as *u8) 197 var t4: i64 = 1 198 if pk[12] < 500 { t4 = 0 } // it moved 199 if pk[12] < pk[2] * 2 { t4 = 0 } // emitted MASS has consequence (measured 2.86x: the heavy 200 // chest is also dragged by its sprung neighbors -- physical) 201 var i: i64 = 0 202 while i < rout[0] { 203 var a: i64 = ox[i] 204 if a < 0 { a = 0 - a } 205 if a > 40 { t4 = 0 } // settled (stable sim) 206 if pk[i] > 200000 { t4 = 0 } // bounded (no explosion) 207 i = i + 1 208 } 209 if t4 == 1 { hw("T4 PASS physics from the EMITTED rig: moved, mass-graded, settled, bounded\n" as *u8) } 210 else { hw("T4 FAIL physics behavior\n" as *u8); fails = fails + 1 } 211 212 // --- determinism of the sim --- 213 let ox2: *i64 = sys_mmap(AR_MAXP * 8) as *i64 214 let vx2: *i64 = sys_mmap(AR_MAXP * 8) as *i64 215 let pk2: *i64 = sys_mmap(AR_MAXP * 8) as *i64 216 gl_sim(p, bones, masses, rout[0], rout[1], rout[2], ox2, vx2, pk2, 600, 6000) 217 var diff: i64 = 0 218 i = 0 219 while i < rout[0] { if pk2[i] != pk[i] { diff = 1 } if ox2[i] != ox[i] { diff = 1 } i = i + 1 } 220 if diff == 0 { hw("T5 PASS sim deterministic (byte-identical replay)\n" as *u8) } 221 else { hw("T5 FAIL sim nondeterministic\n" as *u8); fails = fails + 1 } 222 223 hw("T6 wrote knowledge/nx_genloop.png -- the loop's OWN rendered output (eyeball it)\n" as *u8) 224 if fails == 0 { hw("GATE GREEN: the loop is CLOSED -- generate -> mesh -> render -> physics -> critic, every stage our code, every object scored. Fidelity honestly CLAY; the loop is the machine that now climbs.\n" as *u8) } 225 else { hw("GATE RED fails=" as *u8); pn(fails); hw("\n" as *u8) } 226 return fails 227}