code wiki / _hdl_build / nx_morph_gate.nx
nx_morph_gate.nx source
↩ module page · 143 lines · 5854 B
1// nx_morph_gate.nx -- gate for MORPHS-AS-DATA (Elara bar E3).
2// T1 zero weights -> output mesh BYTE-IDENTICAL to base (non-destructive, no drift)
3// T2 weight 256 -> exact deltas applied; weight 128 -> exact halves (integer law)
4// T3 two morphs COMPOSE additively (both full = the sum of both delta sets)
5// T4 PACK ROUND-TRIP (the mod-economy artifact): save morph -> NXM1 blob -> load into a FRESH bank -> apply
6// -> mesh IDENTICAL to the original morph's result; corrupted magic REJECTED
7// T5 determinism + STL: the morphed mesh exports binary STL (morphed AND printable -- one mesh, reuse law)
8// license_tier: ORIGINAL expect_exit: 0
9import "nx_syscalls.nx"
10import "nx_mesh3.nx"
11import "nx_morph.nx"
12
13func hw(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
14func pn(v: i64) -> i64 {
15 let b: *u8 = sys_mmap(32) as *u8
16 var x: i64 = v
17 var neg: i64 = 0
18 if x < 0 { neg = 1; x = 0 - x }
19 var i: i64 = 31
20 if x == 0 { b[i] = 48 as u8; i = i - 1 }
21 while x > 0 { b[i] = (48 + x % 10) as u8; x = x / 10; i = i - 1 }
22 if neg == 1 { b[i] = 45 as u8; i = i - 1 }
23 sys_write(1, (b as i64 + i + 1) as *u8, 31 - i)
24 return 0
25}
26func meshsum(mesh: i64) -> i64 {
27 let h: *i64 = m3_hdr(mesh)
28 var s: i64 = 0
29 var i: i64 = 0
30 while i < h[0] {
31 let v: *i64 = m3_vert(mesh, i)
32 s = s * 31 + v[0]
33 s = s * 31 + v[1]
34 s = s * 31 + v[2]
35 i = i + 1
36 }
37 return s
38}
39
40func main() -> i64 {
41 var fails: i64 = 0
42 // base mesh: the canonical box (8 verts)
43 let mb: i64 = sys_mmap(m3_bytes()) as i64
44 m3_init(mb)
45 m3_box(mb, 0, 0, 0, 400, 400, 400)
46 // bank with two morphs: "taller" (top 4 verts +200y) and "wider" (all 8 verts +-150x by sign)
47 let bank: i64 = sys_mmap(mo_bytes()) as i64
48 mo_init(bank)
49 let mT: i64 = mo_begin(bank, 1001)
50 var i: i64 = 0
51 while i < 8 {
52 let v: *i64 = m3_vert(mb, i)
53 if v[1] > 0 { mo_add_delta(bank, mT, i, 0, 200, 0) }
54 i = i + 1
55 }
56 let mW: i64 = mo_begin(bank, 1002)
57 i = 0
58 while i < 8 {
59 let v: *i64 = m3_vert(mb, i)
60 var sx: i64 = 150
61 if v[0] < 0 { sx = 0 - 150 }
62 mo_add_delta(bank, mW, i, sx, 0, 0)
63 i = i + 1
64 }
65 let wts: *i64 = sys_mmap(64) as *i64
66
67 // T1 zero weights
68 let mo0: i64 = sys_mmap(m3_bytes()) as i64
69 wts[0] = 0
70 wts[1] = 0
71 mo_apply(bank, mb, mo0, wts)
72 var t1: i64 = 1
73 if meshsum(mo0) != meshsum(mb) { t1 = 0 }
74 let h0: *i64 = m3_hdr(mo0)
75 if h0[0] != 8 { t1 = 0 }
76 if h0[1] != 12 { t1 = 0 }
77 if t1 == 1 { hw("T1 PASS zero weights -> output IDENTICAL to base (8 verts, 12 tris)\n" as *u8) }
78 else { hw("T1 FAIL\n" as *u8); fails = fails + 1 }
79
80 // T2 full + half weights, exact
81 let mo1: i64 = sys_mmap(m3_bytes()) as i64
82 wts[0] = 256
83 wts[1] = 0
84 mo_apply(bank, mb, mo1, wts)
85 var t2: i64 = 1
86 let vtop: *i64 = m3_vert(mo1, 4) // v4 = (-,-,+z)... check a known top vert: box verts 2,3,6,7 have +y
87 let v2: *i64 = m3_vert(mo1, 2)
88 if v2[1] != 600 { t2 = 0 } // 400 + 200
89 wts[0] = 128
90 mo_apply(bank, mb, mo1, wts)
91 let v2h: *i64 = m3_vert(mo1, 2)
92 if v2h[1] != 500 { t2 = 0 } // 400 + 100
93 if t2 == 1 { hw("T2 PASS slider exact: w=256 -> +200 (y=600), w=128 -> +100 (y=500)\n" as *u8) }
94 else { hw("T2 FAIL y256=" as *u8); pn(v2[1]); hw(" y128=" as *u8); pn(v2h[1]); hw("\n" as *u8); fails = fails + 1 }
95
96 // T3 composition
97 let mo2: i64 = sys_mmap(m3_bytes()) as i64
98 wts[0] = 256
99 wts[1] = 256
100 mo_apply(bank, mb, mo2, wts)
101 let v2c: *i64 = m3_vert(mo2, 2) // +y vert with x>0: expect y=600 AND x=550
102 var t3: i64 = 1
103 if v2c[1] != 600 { t3 = 0 }
104 if v2c[0] != 550 { t3 = 0 }
105 if t3 == 1 { hw("T3 PASS morphs COMPOSE additively: taller+wider -> (550,600) on the +x+y vert\n" as *u8) }
106 else { hw("T3 FAIL v=(" as *u8); pn(v2c[0]); hw("," as *u8); pn(v2c[1]); hw(")\n" as *u8); fails = fails + 1 }
107
108 // T4 pack round-trip + corrupt rejection
109 let blob: *u8 = sys_mmap(4096) as *u8
110 let blen: i64 = mo_save(bank, mT, blob)
111 let bank2: i64 = sys_mmap(mo_bytes()) as i64
112 mo_init(bank2)
113 let lm: i64 = mo_load(bank2, blob, blen)
114 var t4: i64 = 1
115 if lm < 0 { t4 = 0 }
116 let mo3: i64 = sys_mmap(m3_bytes()) as i64
117 let wts2: *i64 = sys_mmap(64) as *i64
118 wts2[0] = 256
119 mo_apply(bank2, mb, mo3, wts2)
120 wts[0] = 256
121 wts[1] = 0
122 mo_apply(bank, mb, mo1, wts)
123 if meshsum(mo3) != meshsum(mo1) { t4 = 0 }
124 blob[0] = 90 as u8 // corrupt the magic
125 let bad: i64 = mo_load(bank2, blob, blen)
126 if bad != 0 - 1 { t4 = 0 }
127 if t4 == 1 { hw("T4 PASS NXM1 pack round-trip: save->load->apply IDENTICAL (" as *u8); pn(blen); hw("B blob = the CID-shippable morph artifact); corrupt magic REJECTED\n" as *u8) }
128 else { hw("T4 FAIL\n" as *u8); fails = fails + 1 }
129
130 // T5 determinism + STL export of the morphed mesh
131 let mo4: i64 = sys_mmap(m3_bytes()) as i64
132 mo_apply(bank, mb, mo4, wts)
133 var t5: i64 = 1
134 if meshsum(mo4) != meshsum(mo1) { t5 = 0 }
135 let stl: i64 = m3_write_stl(mo4, "knowledge/nx_morphed_box.stl" as *u8)
136 if stl != 84 + 12 * 50 { t5 = 0 }
137 if t5 == 1 { hw("T5 PASS deterministic re-apply + morphed mesh exports STL (" as *u8); pn(stl); hw("B) -- morphed AND printable, one mesh\n" as *u8) }
138 else { hw("T5 FAIL stl=" as *u8); pn(stl); hw("\n" as *u8); fails = fails + 1 }
139
140 if fails == 0 { hw("VERDICT GREEN: morphs-as-data 5/5 -- sliders exact, composition additive, NXM1 pack round-trips (the mod economy's character content), STL-compatible\n" as *u8) }
141 else { hw("VERDICT RED fails=" as *u8); pn(fails); hw("\n" as *u8) }
142 return fails
143}