code wiki / _hdl_build / nx_explodelab_treegen.nx
nx_explodelab_treegen.nx source
↩ module page · 217 lines · 9303 B
1// nx_explodelab_treegen.nx -- GENERATOR for the ExplodeLab wasm surface (build generators, not hand-authored
2// artifacts): parses the REAL banked as1-oc-214.stp (nx_step_parse R1a), runs the SAME deterministic DFS
3// layout law as nx_explode3d_gate (ex3_oct/ex3_rad/ex3_dyv), and EMITS:
4// 1. runtime/nx_explodelab_tree.nx -- data module (part count + per-part kind/depth/home/dir accessors)
5// so the wasm surface needs NO file IO and NO STEP parser on the client.
6// 2. knowledge/explodelab_bom.txt -- BOM panel lines (idx, name, depth) for the HTML packager.
7// Re-run after R1b tessellation or a different STEP file. expect_exit: 0 license_tier: ORIGINAL
8import "nx_step_parse.nx"
9import "nx_explode3d.nx"
10const K_MAGIC_4194304: i64 = 4194304
11const K_MAGIC_524288: i64 = 524288
12const K_MAGIC_2048: i64 = 2048
13const K_MAGIC_1024: i64 = 1024
14const K_MAGIC_2200: i64 = 2200
15const K_MAGIC_16384: i64 = 16384
16
17func tw(fd: i64, s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(fd, s, n); return 0 }
18func tn(fd: i64, v: i64) -> i64 {
19 let bb: *u8 = sys_mmap(28)
20 var m: i64 = v
21 if m < 0 { tw(fd, "0 - " as *u8); m = 0 - m }
22 let t: *u8 = sys_mmap(28)
23 var k: i64 = 0
24 if m == 0 { t[0] = 48 as u8; k = 1 }
25 while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
26 var i: i64 = 0
27 while i < k { bb[i] = t[k - 1 - i]; i = i + 1 }
28 sys_write(fd, bb, k)
29 return 0
30}
31
32// write the PRODUCT arg0 inner string of entity prodidx to fd
33func tname(st: *i64, prodidx: i64, fd: i64, out2: *i64) -> i64 {
34 let buf: *u8 = st[0] as *u8
35 let okk: i64 = sp_arg_span(st, prodidx, 0, out2)
36 if okk == 0 { tw(fd, "?" as *u8); return 0 }
37 var v: i64 = out2[0]
38 let end: i64 = out2[0] + out2[1]
39 var sk: i64 = 1
40 while sk == 1 {
41 if v < end { let s: i64 = sp_isspace(buf[v] as i64); if s == 1 { v = v + 1 } else { sk = 0 } } else { sk = 0 }
42 }
43 if v >= end { tw(fd, "?" as *u8); return 0 }
44 if buf[v] != (39 as u8) { tw(fd, "?" as *u8); return 0 }
45 let s0: i64 = v + 1
46 var w: i64 = s0
47 var going: i64 = 1
48 while going == 1 {
49 if w < end { if buf[w] == (39 as u8) { going = 0 } else { w = w + 1 } } else { going = 0 }
50 }
51 let p: *u8 = ((buf as i64) + s0) as *u8
52 sys_write(fd, p, w - s0)
53 return 0
54}
55
56// emit one accessor function: name, values[] over n parts, default 0
57func temit(fd: i64, fname: *u8, vals: *i64, n: i64) -> i64 {
58 tw(fd, "func " as *u8); tw(fd, fname); tw(fd, "(i: i64) -> i64 {\n" as *u8)
59 var k: i64 = 0
60 while k < n {
61 tw(fd, " if i == " as *u8); tn(fd, k); tw(fd, " { return " as *u8); tn(fd, vals[k]); tw(fd, " }\n" as *u8)
62 k = k + 1
63 }
64 tw(fd, " return 0\n}\n" as *u8)
65 return 0
66}
67
68func main() -> i64 {
69 tw(1, "=== nx_explodelab_treegen -- bake the REAL as1 tree into the wasm data module ===\n" as *u8)
70 let buf: *u8 = sys_mmap(K_MAGIC_4194304)
71 let aid: *i64 = sys_mmap(K_MAGIC_524288) as *i64
72 let anm: *i64 = sys_mmap(K_MAGIC_524288) as *i64
73 let anl: *i64 = sys_mmap(K_MAGIC_524288) as *i64
74 let aao: *i64 = sys_mmap(K_MAGIC_524288) as *i64
75 let aal: *i64 = sys_mmap(K_MAGIC_524288) as *i64
76 let st: *i64 = sys_mmap(256) as *i64
77 let n: i64 = sp_read_file("knowledge/fetched/step_as1.stp" as *u8, buf, K_MAGIC_4194304)
78 if n <= 0 { tw(1, "MISSING step_as1.stp -- run nx_step_sample_fetch\n" as *u8); return 1 }
79 let ig0: i64 = sp_init(st, buf, n, aid, anm, anl, aao, aal)
80 let cnt: i64 = sp_scan(st)
81 let pe: *i64 = sys_mmap(K_MAGIC_2048) as *i64
82 let ce: *i64 = sys_mmap(K_MAGIC_2048) as *i64
83 let en: i64 = sp_nauo_collect(st, pe, ce, 256)
84 var rootpd: i64 = 0 - 1
85 var i: i64 = 0
86 while i < en {
87 let p: i64 = pe[i]
88 var ischild: i64 = 0
89 var j: i64 = 0
90 while j < en { if ce[j] == p { ischild = 1 } j = j + 1 }
91 if ischild == 0 { rootpd = p }
92 i = i + 1
93 }
94 if rootpd < 0 { tw(1, "NO root\n" as *u8); return 1 }
95
96 // DFS (same law as the gate) -> collect leaf parts
97 let a_kind: *i64 = sys_mmap(K_MAGIC_1024) as *i64
98 let a_dep: *i64 = sys_mmap(K_MAGIC_1024) as *i64
99 let a_hx: *i64 = sys_mmap(K_MAGIC_1024) as *i64
100 let a_hy: *i64 = sys_mmap(K_MAGIC_1024) as *i64
101 let a_hz: *i64 = sys_mmap(K_MAGIC_1024) as *i64
102 let a_dx: *i64 = sys_mmap(K_MAGIC_1024) as *i64
103 let a_dy: *i64 = sys_mmap(K_MAGIC_1024) as *i64
104 let a_dz: *i64 = sys_mmap(K_MAGIC_1024) as *i64
105 let a_prod: *i64 = sys_mmap(K_MAGIC_1024) as *i64
106 var np: i64 = 0
107
108 let s_pd: *i64 = sys_mmap(K_MAGIC_2048) as *i64
109 let s_dep: *i64 = sys_mmap(K_MAGIC_2048) as *i64
110 let s_x: *i64 = sys_mmap(K_MAGIC_2048) as *i64
111 let s_y: *i64 = sys_mmap(K_MAGIC_2048) as *i64
112 let s_z: *i64 = sys_mmap(K_MAGIC_2048) as *i64
113 let s_px: *i64 = sys_mmap(K_MAGIC_2048) as *i64
114 let s_py: *i64 = sys_mmap(K_MAGIC_2048) as *i64
115 let s_pz: *i64 = sys_mmap(K_MAGIC_2048) as *i64
116 let out2: *i64 = sys_mmap(16) as *i64
117 var sp2: i64 = 0
118 s_pd[0] = rootpd; s_dep[0] = 0
119 s_x[0] = 0; s_y[0] = K_MAGIC_2200; s_z[0] = 0
120 s_px[0] = 0; s_py[0] = 0; s_pz[0] = 0
121 sp2 = 1
122 while sp2 > 0 {
123 sp2 = sp2 - 1
124 let pd: i64 = s_pd[sp2]
125 let d: i64 = s_dep[sp2]
126 let px: i64 = s_x[sp2]
127 let py: i64 = s_y[sp2]
128 let pz: i64 = s_z[sp2]
129 let ppx: i64 = s_px[sp2]
130 let ppy: i64 = s_py[sp2]
131 let ppz: i64 = s_pz[sp2]
132 var haschild: i64 = 0
133 var k: i64 = 0
134 var e5: i64 = 0
135 while e5 < en {
136 if pe[e5] == pd {
137 haschild = 1
138 let cd: i64 = d + 1
139 let ig2: i64 = ex3_oct(k, out2)
140 let r: i64 = ex3_rad(cd)
141 let cx: i64 = px + (out2[0] * r) / K_MAGIC_16384
142 let cz: i64 = pz + (out2[1] * r) / K_MAGIC_16384
143 let cy: i64 = py + ex3_dyv(cd)
144 if sp2 < 250 {
145 s_pd[sp2] = ce[e5]; s_dep[sp2] = cd
146 s_x[sp2] = cx; s_y[sp2] = cy; s_z[sp2] = cz
147 s_px[sp2] = px; s_py[sp2] = py; s_pz[sp2] = pz
148 sp2 = sp2 + 1
149 }
150 k = k + 1
151 }
152 e5 = e5 + 1
153 }
154 if haschild == 0 {
155 let prodi: i64 = sp_pd_product(st, pd)
156 var kind: i64 = 0
157 if prodi >= 0 {
158 let i1: i64 = sp_prod_name_is(st, prodi, "nut" as *u8)
159 if i1 == 1 { kind = 1 }
160 let i2: i64 = sp_prod_name_is(st, prodi, "bolt" as *u8)
161 if i2 == 1 { kind = 2 }
162 let i3: i64 = sp_prod_name_is(st, prodi, "rod" as *u8)
163 if i3 == 1 { kind = 3 }
164 let i4: i64 = sp_prod_name_is(st, prodi, "plate" as *u8)
165 if i4 == 1 { kind = 4 }
166 let i5: i64 = sp_prod_name_is(st, prodi, "l-bracket" as *u8)
167 if i5 == 1 { kind = 5 }
168 }
169 a_kind[np] = kind
170 a_dep[np] = d
171 a_hx[np] = px
172 a_hy[np] = py
173 a_hz[np] = pz
174 a_dx[np] = px - ppx
175 a_dy[np] = py - ppy
176 a_dz[np] = pz - ppz
177 a_prod[np] = prodi
178 np = np + 1
179 }
180 }
181 tw(1, "parts=" as *u8); tn(1, np); tw(1, "\n" as *u8)
182 if np < 10 { tw(1, "RED too few parts\n" as *u8); return 1 }
183
184 // emit the data module
185 let fd: i64 = sys_openat_wr("runtime/nx_explodelab_tree.nx" as *u8, 0x1a4)
186 if fd < 0 { tw(1, "cannot write tree module\n" as *u8); return 1 }
187 tw(fd, "// nx_explodelab_tree.nx -- GENERATED by nx_explodelab_treegen from knowledge/fetched/step_as1.stp\n" as *u8)
188 tw(fd, "// (the REAL as1-oc-214 assembly: 18 leaf occurrences, depth-3 tree). DO NOT hand-edit; re-run the\n" as *u8)
189 tw(fd, "// generator after R1b tessellation or to target a different STEP file. kinds: 0 box 1 nut 2 bolt\n" as *u8)
190 tw(fd, "// 3 rod 4 plate 5 l-bracket. Positions Q14 (assembled layout law ex3_rad/ex3_dyv), dir = raw radial\n" as *u8)
191 tw(fd, "// from parent (normalized by ex3_part_begin). license_tier: ORIGINAL\n" as *u8)
192 tw(fd, "func exl_n() -> i64 { return " as *u8); tn(fd, np); tw(fd, " }\n" as *u8)
193 let e1: i64 = temit(fd, "exl_kind" as *u8, a_kind, np)
194 let e2: i64 = temit(fd, "exl_depth" as *u8, a_dep, np)
195 let e3: i64 = temit(fd, "exl_hx" as *u8, a_hx, np)
196 let e4: i64 = temit(fd, "exl_hy" as *u8, a_hy, np)
197 let e5b: i64 = temit(fd, "exl_hz" as *u8, a_hz, np)
198 let e6: i64 = temit(fd, "exl_dx" as *u8, a_dx, np)
199 let e7: i64 = temit(fd, "exl_dy" as *u8, a_dy, np)
200 let e8: i64 = temit(fd, "exl_dz" as *u8, a_dz, np)
201 sys_close(fd)
202
203 // emit the BOM text (idx name depth)
204 let bfd: i64 = sys_openat_wr("knowledge/explodelab_bom.txt" as *u8, 0x1a4)
205 if bfd < 0 { tw(1, "cannot write bom\n" as *u8); return 1 }
206 var b: i64 = 0
207 while b < np {
208 tn(bfd, b)
209 tw(bfd, " " as *u8)
210 let ig3: i64 = tname(st, a_prod[b], bfd, out2)
211 tw(bfd, " (depth " as *u8); tn(bfd, a_dep[b]); tw(bfd, ")\n" as *u8)
212 b = b + 1
213 }
214 sys_close(bfd)
215 tw(1, "wrote runtime/nx_explodelab_tree.nx + knowledge/explodelab_bom.txt\nGREEN\n" as *u8)
216 return 0
217}