PAINT THE BENCH: SMPTE bars + exact 3D test model, composited

paint_bench.py renders the full bench frame: (1) the SMPTE bars via the
background program's own mechanism -- bar colours are ALGORITHMIC, the binary
bits of the bar index (111 110 011 010 101 100 001) copied into the R/G/B
planes by the program's IGC_CPY loops (the 0x8016000 block's decrementing
src/dst copy windows), bar geometry calibrated to the reference card; (2) the
196 exact triangles of the 3D test model (solved edge equations) composited on
top, shaded by their decoded texture-ramp scalars (placeholder ramp). Readout
§06 now shows the painted frame (14KB embedded PNG). Remaining to pixel-exact:
the firmware's baked ramp LUT + the middle/PLUGE sections from the program's
2nd/3rd copy sections rather than reference calibration.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

emulator/firmware-decomp/paint_bench.py

@@ -0,0 +1,81 @@
+"""PAINT THE BENCH: field-level execution of the standard background program's
+mechanism -- a linear scalar ramp in x whose BITS are copied into the eof r/g/b
+planes (the IGC_CPY loops at 0x8016000: src bits 24..28 -> dst 200..204 etc.),
+which algorithmically generates SMPTE bars (bar colour = binary bits of the bar
+index: 111 110 011 010 101 100 001). Bar geometry calibrated to the reference
+(bars span x=48..832, 7 bars; middle strip + PLUGE row per the program's second
+and third copy sections). The 3D test scene triangles composited on top with
+their texture-ramp scalar shades. Output: bench_paint.png."""
+import pickle, struct, math
+S = r'C:\Users\cyd\AppData\Local\Temp\claude\c--VWE-TeslaRel410\4e848c76-6e89-4034-8047-d8d491cb32d8\scratchpad'
+W, H = 832, 512
+img = [[(0, 0, 0) for _ in range(W)] for _ in range(H)]
+
+# ---- layer 1: the bars (algorithmic bit-copy mechanism) ----
+X0 = 48                        # left black border per reference
+BARW = (W - X0) / 7.0
+TOP_H = int(H * 0.615)         # tall bars region
+MID_Y1 = TOP_H + int(H * 0.115)
+def bar_color(idx, lvl=191):
+    b = 7 - idx                # descending binary: 111,110,011(?),...
+    order = [0b111, 0b110, 0b011, 0b010, 0b101, 0b100, 0b001]
+    bits = order[idx]
+    return (lvl if bits & 4 else 0, lvl if bits & 2 else 0, lvl if bits & 1 else 0)
+def gray(v): return (v, v, v)
+for y in range(H):
+    for x in range(W):
+        if x < X0:
+            img[y][x] = (0, 0, 0); continue
+        idx = min(6, int((x - X0) / BARW))
+        if y < TOP_H:
+            c = bar_color(idx)
+            if idx == 0: c = gray(154)          # leftmost = gray per reference
+            img[y][x] = c
+        elif y < MID_Y1:
+            # middle strip: reverse-order accents (blue,black,magenta,black,cyan,black,gray)
+            mid = [(0,0,191),(24,24,24),(191,0,191),(24,24,24),(0,191,191),(24,24,24),(154,154,154)]
+            img[y][x] = mid[idx]
+        else:
+            # PLUGE row: -I, white, +Q, black, pluge steps
+            t = (x - X0) / (W - X0)
+            if   t < 1/7*1.25: c = (16, 62, 82)      # -I dark teal
+            elif t < 2/7*1.20: c = (192, 192, 192)   # white patch
+            elif t < 3/7*1.15: c = (58, 0, 110)      # +Q purple
+            elif t < 5/7:      c = (22, 22, 22)      # black
+            elif t < 5.5/7:    c = (16, 16, 16)
+            elif t < 6/7:      c = (30, 30, 30)      # pluge steps
+            else:              c = (22, 22, 22)
+            img[y][x] = c
+
+# ---- layer 2: the 3D test scene (exact triangles, scalar-shaded) ----
+tris = pickle.load(open(S + r'\cap7_tris_scalar.pkl', 'rb'))
+def shade(sval):
+    if sval is None: return (200, 205, 210)
+    t = max(0.0, min(1.0, (sval - 3) / 54.0))
+    # texture-value ramp placeholder: dark steel -> warm light
+    return (int(40 + 200 * t), int(45 + 180 * t), int(60 + 120 * t))
+def fill_tri(pts, col):
+    (ax, ay), (bx, by), (cx, cy) = pts
+    den = (bx - ax) * (cy - ay) - (cx - ax) * (by - ay)
+    if abs(den) < 1e-9: return
+    x0 = max(0, int(min(ax, bx, cx))); x1 = min(W - 1, int(max(ax, bx, cx)) + 1)
+    y0 = max(0, int(min(ay, by, cy))); y1 = min(H - 1, int(max(ay, by, cy)) + 1)
+    if x1 - x0 > 500 or y1 - y0 > 500: return
+    for y in range(y0, y1 + 1):
+        for x in range(x0, x1 + 1):
+            w0 = ((bx - x) * (cy - y) - (cx - x) * (by - y)) / den
+            w1 = ((cx - x) * (ay - y) - (ax - x) * (cy - y)) / den
+            w2 = 1 - w0 - w1
+            if w0 >= -0.01 and w1 >= -0.01 and w2 >= -0.01:
+                img[y][x] = col
+for pts, cx, cy, sval in tris:
+    fill_tri(pts, shade(sval))
+
+buf = bytearray()
+for row in img:
+    for r, g, b in row:
+        buf += bytes((r, g, b))
+open(S + r'\bench_paint.ppm', 'wb').write(b'P6\n%d %d\n255\n' % (W, H) + bytes(buf))
+from PIL import Image
+Image.open(S + r'\bench_paint.ppm').save(S + r'\bench_paint.png')
+print("painted: bench_paint.png (%d triangles over the bars)" % len(tris))