code wiki / _hdl_build / nx_explodelab_material_gate.nx
`nx_explodelab_material_gate.nx` source

↩ module page · 224 lines · 7506 B
1// nx_explodelab_material_gate.nx -- teeth on R-V6 PER-PART MATERIALS + the DEPTH CUE.
2// A material system fails quietly in two ways: the table is filled in but every entry is effectively the
3// same (nothing differentiates, yet "materials" ships), or the per-vertex material id never reaches the
4// rasteriser so the table is dead data. Both look GREEN to any "does it render" check. So: prove the table
5// is differentiated, prove the id survives into the vertex data, prove metal and dielectric highlights
6// behave DIFFERENTLY, prove depth actually attenuates, and prove the frame changes when materials are
7// flattened to one. expect_exit: 0  license_tier: ORIGINAL
8import "nx_wasm_explodelab.nx"
9
10func ag_w(s: *u8) -> i64 {
  var n: i64 = 0
  while s[n] != (0 as u8) { n = n + 1 }
  sys_write(1, s, n)
  return 0
15}
16func ag_n(v: i64) -> i64 {
  let buf: *u8 = sys_mmap(64)
  var a: i64 = v
  var neg: i64 = 0
  if a < 0 {
      neg = 1
      a = 0 - a
  }
  var i: i64 = 31
  if a == 0 {
      buf[i] = 48 as u8
      i = i - 1
  }
  while a > 0 {
      buf[i] = (48 + (a % 10)) as u8
      a = a / 10
      i = i - 1
  }
  if neg == 1 {
      buf[i] = 45 as u8
      i = i - 1
  }
  sys_write(1, ((buf as i64) + i + 1) as *u8, 31 - i)
  return 0
40}
41func ag_tooth(name: *u8, pass: i64, fails: *i64) -> i64 {
  ag_w("  " as *u8)
  ag_w(name)
  ag_w(" -> " as *u8)
  if pass == 1 {
      ag_w("PASS\n" as *u8)
      return 0
  }
  ag_w("FAIL\n" as *u8)
  fails[0] = fails[0] + 1
  return 0
52}
53func ag_chk(base: i64) -> i64 {
  let fb: *i64 = (base + 0) as *i64
  var x: i64 = 0
  var i: i64 = 0
  let n: i64 = ww() * hh()
  while i < n {
      x = x + fb[i] * (1 + (i % 7))
      i = i + 1
  }
  return x
63}
64// how many of the 5 material fields differ between two kinds
65func ag_diff(k1: i64, k2: i64) -> i64 {
  var d: i64 = 0
  var f: i64 = 0
  while f < 5 {
      if exl_mat(k1, f) != exl_mat(k2, f) { d = d + 1 }
      f = f + 1
  }
  return d
73}
74
75func main() -> i64 {
  ag_w("=== nx_explodelab_material_gate -- per-part materials + depth cue ===\n" as *u8)
  let fails: *i64 = sys_mmap(8) as *i64
  fails[0] = 0
  let base: i64 = sys_mmap(mem_bytes()) as i64
  start_at(base)
  let st: *i64 = st_ptr(base)
  st[6] = 1
  st[10] = 1
  st[2] = 0
  let e: *i64 = e_ptr(base)
  let nrm: *i64 = (base + O_NRM) as *i64
  let vst: *i64 = (base + O_VST) as *i64
  let vct: *i64 = (base + O_VCT) as *i64
  let nv: i64 = e[1]
90
  // ---- T1 the table is genuinely DIFFERENTIATED (steel vs cast vs aluminium)
  let d_sc: i64 = ag_diff(1, 4)
  let d_sa: i64 = ag_diff(1, 5)
  let d_ca: i64 = ag_diff(4, 5)
  ag_w("  field diffs: steel/cast=" as *u8)
  ag_n(d_sc)
  ag_w("  steel/alu=" as *u8)
  ag_n(d_sa)
  ag_w("  cast/alu=" as *u8)
  ag_n(d_ca)
  ag_w(" of 5\n" as *u8)
  var t1: i64 = 0
  if d_sc >= 3 { if d_sa >= 3 { if d_ca >= 3 { t1 = 1 } } }
  ag_tooth("T1 materials are genuinely distinct (>=3 of 5 fields differ between each pair)" as *u8, t1, fails)
105
  // ---- T2 the per-vertex material id reaches the vertex data, and the smooth bit SURVIVED the packing
  var wrongkind: i64 = 0
  var anysmooth: i64 = 0
  var p: i64 = 0
  let np: i64 = exl_n()
  while p < np {
      let k: i64 = exl_kind(p)
      var v: i64 = vst[p]
      let vend: i64 = vst[p] + vct[p]
      while v < vend {
          if nrm[v * 4 + 3] / 2 != k { wrongkind = wrongkind + 1 }
          if (nrm[v * 4 + 3] % 2) == 1 { anysmooth = anysmooth + 1 }
          v = v + 1
      }
      p = p + 1
  }
  var t2: i64 = 0
  if wrongkind == 0 { if anysmooth > 0 { t2 = 1 } }
  ag_w("    (verts with wrong material id=" as *u8)
  ag_n(wrongkind)
  ag_w("  still-smooth=" as *u8)
  ag_n(anysmooth)
  ag_w(" of " as *u8)
  ag_n(nv)
  ag_w(")\n" as *u8)
  ag_tooth("T2 material id packs into the vertex WITHOUT destroying the smooth-shading bit" as *u8, t2, fails)
132
  // ---- T3 METAL vs DIELECTRIC: a metal tints its highlight by its own albedo, a dielectric adds white.
  // With a saturated RED albedo the metal highlight must lift red far more than blue; the dielectric
  // must lift them equally.
  let red: i64 = 4278190080 + 200
  let met: i64 = exl_shade2(red, 128, 200, 1, 256)
  let die: i64 = exl_shade2(red, 128, 200, 0, 256)
  let mr: i64 = met % 256
  let mb: i64 = (met / 65536) % 256
  let dr: i64 = die % 256
  let db: i64 = (die / 65536) % 256
  ag_w("    (metal r=" as *u8)
  ag_n(mr)
  ag_w(" b=" as *u8)
  ag_n(mb)
  ag_w("   dielectric r=" as *u8)
  ag_n(dr)
  ag_w(" b=" as *u8)
  ag_n(db)
  ag_w(")\n" as *u8)
  var t3: i64 = 0
  if mr - mb > 40 { if db - dr == 0 - (dr - db) { if db >= 100 { t3 = 1 } } }
  ag_tooth("T3 metal tints its specular by albedo; dielectric stays white" as *u8, t3, fails)
155
  // ---- T4 specular tightness really tightens: for a partial cosine, broad > medium > tight
  let s0: i64 = exl_specp(200, 0)
  let s1: i64 = exl_specp(200, 1)
  let s2v: i64 = exl_specp(200, 2)
  var t4: i64 = 0
  if s0 > s1 { if s1 > s2v { t4 = 1 } }
  ag_w("    (cos=200 -> broad " as *u8)
  ag_n(s0)
  ag_w(" med " as *u8)
  ag_n(s1)
  ag_w(" tight " as *u8)
  ag_n(s2v)
  ag_w(")\n" as *u8)
  ag_tooth("T4 specular tightness is monotonic (broad > medium > tight)" as *u8, t4, fails)
170
  // ---- T5 DEPTH CUE attenuates: same vertex, same material, deeper z -> darker
  let scr: *i64 = (base + O_SCR) as *i64
  let ig: i64 = render_at(base)
  // ⚠set BOTH depths explicitly. Using the vertex's real (large) projected depth as the "near" case made
  // both ends clamp to the same fog floor -- the tooth then compared two identical values and called the
  // feature dead. Same one-variable discipline as everywhere else in this arc.
  let zsave: i64 = scr[2]
  scr[2] = 0
  let near: i64 = exl_corner_col((base + O_WV) as *i64, nrm, scr, 0, 0, 0, NRM_Q, 0, 1000)
  scr[2] = 1000
  let far: i64 = exl_corner_col((base + O_WV) as *i64, nrm, scr, 0, 0, 0, NRM_Q, 0, 1000)
  scr[2] = zsave
  var t5: i64 = 0
  if (far % 256) < (near % 256) { t5 = 1 }
  ag_w("    (near r=" as *u8)
  ag_n(near % 256)
  ag_w("  far r=" as *u8)
  ag_n(far % 256)
  ag_w(")\n" as *u8)
  ag_tooth("T5 DEPTH CUE: the same surface renders darker further away" as *u8, t5, fails)
191
  // ---- T6 NON-VACUITY: flatten every vertex to ONE material and the frame must change
  let real: i64 = ag_chk(base)
  var i2: i64 = 0
  while i2 < nv {
      nrm[i2 * 4 + 3] = (nrm[i2 * 4 + 3] % 2) + 2
      i2 = i2 + 1
  }
  let ig2: i64 = render_at(base)
  let flat: i64 = ag_chk(base)
  var t6: i64 = 0
  if flat != real { t6 = 1 }
  ag_tooth("T6 NON-VACUITY: flattening all parts to one material CHANGES the frame" as *u8, t6, fails)
204
  // ---- T7 determinism after a clean rebuild
  start_at(base)
  st[6] = 1
  st[10] = 1
  st[2] = 0
  let ig3: i64 = render_at(base)
  var t7: i64 = 0
  if ag_chk(base) == real { t7 = 1 }
  ag_tooth("T7 deterministic: rebuild reproduces the material frame exactly" as *u8, t7, fails)
214
  ag_w("\nfails=" as *u8)
  ag_n(fails[0])
  ag_w("\n" as *u8)
  if fails[0] == 0 {
      ag_w("GREEN -- materials 7/7 (steel/cast/aluminium distinct, metal tint, depth cue live)\n" as *u8)
      return 0
  }
  ag_w("RED\n" as *u8)
  return 1
224}
nx_explodelab_material_gate.nx source

`nx_explodelab_material_gate.nx` source
