render3d: cut-out padding on every core - tex_dilate's rows per pass through Job.parallel_for, bytes unchanged

Within a pass a row writes only its own still-masked texels and reads only neighbours already let go,
which no row writes that pass, so the result is the single-threaded one. The worker takes a DilateJob
of plain buffers and allocates nothing. tex_dilate_bytes (safe_api) and examples/rendering/dilate.ludic,
which checks it against the old loop on RGB and RGBA atlases of sizes that do not divide (DILATE OK).

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

examples/rendering/dilate.ludic

@@ -0,0 +1,77 @@
+# dilate.ludic - render3d's cut-out padding, now a pass's rows on every core, gives exactly the
+# bytes the one-thread version gave: the old loop is kept here as the oracle, over a patterned atlas
+#
+#   bin/ludic build examples/rendering/dilate.ludic --headless && ./build/dilate_headless   (prints DILATE OK)
+program Dilate {
+  numbers float
+  import "ludic.render3d/r3d.ludic"
+
+  # the dilate as it was, one row after another
+  function oracle(px: []byte, w: int, h: int, c: int, thresh: int, passes: int) -> void {
+    let mask = buffer(w * h)
+    for i in 0 .. w * h { let o = i * c;  if px[o] + px[o + 1] + px[o + 2] < thresh { mask[i] = 1 } else { mask[i] = 0 } }
+    let next = buffer(w * h)
+    for pass in 0 .. passes {
+      for q in 0 .. w * h { next[q] = mask[q] }
+      for y in 0 .. h {
+        for x in 0 .. w {
+          let k = y * w + x
+          if mask[k] == 1 {
+            var r = 0;  var g = 0;  var b = 0;  var n = 0
+            if x > 0 and mask[k - 1] == 0 { let o = (k - 1) * c;  r += px[o];  g += px[o + 1];  b += px[o + 2];  n += 1 }
+            if x < w - 1 and mask[k + 1] == 0 { let o = (k + 1) * c;  r += px[o];  g += px[o + 1];  b += px[o + 2];  n += 1 }
+            if y > 0 and mask[k - w] == 0 { let o = (k - w) * c;  r += px[o];  g += px[o + 1];  b += px[o + 2];  n += 1 }
+            if y < h - 1 and mask[k + w] == 0 { let o = (k + w) * c;  r += px[o];  g += px[o + 1];  b += px[o + 2];  n += 1 }
+            if n > 0 { let o = k * c;  px[o] = r / n;  px[o + 1] = g / n;  px[o + 2] = b / n;  next[k] = 0 }
+          }
+        }
+      }
+      for q in 0 .. w * h { mask[q] = next[q] }
+    }
+  }
+
+  # blades and blobs of colour on black, different in every row and column
+  function atlas(w: int, h: int, c: int) -> []byte {
+    let px = buffer(w * h * c)
+    for y in 0 .. h {
+      for x in 0 .. w {
+        let o = (y * w + x) * c
+        let lit = ((x * 7 + y * 13) % 29 < 6) or ((x / 9 + y / 11) % 5 == 0)
+        for k in 0 .. c { px[o + k] = 0 }
+        if lit {
+          px[o] = (x * 3 + y) % 256
+          px[o + 1] = (x + y * 5) % 256
+          px[o + 2] = (x * y) % 256
+        }
+        if c == 4 { px[o + 3] = 255 }
+      }
+    }
+    return px
+  }
+
+  handler Boot(render3d_st: mut Render3dState) phase Start {
+    var ok = true
+    for c in 3 .. 5 {
+      let w = 173
+      let h = 101
+      let a = atlas(w, h, c)
+      let b = atlas(w, h, c)
+      render3d_st.tex_w = w
+      render3d_st.tex_h = h
+      render3d_st.tex_channels = c
+      render3d_st.tex_depth = 8
+      tex_dilate_bytes(render3d_st, a, 60, 24)
+      oracle(b, w, h, c, 60, 24)
+      let orig = atlas(w, h, c)
+      var same = 0
+      var moved = 0
+      for i in 0 .. w * h * c {
+        if a[i] == b[i] { same += 1 }
+        if a[i] != orig[i] { moved += 1 }
+      }
+      if same != w * h * c or moved == 0 { ok = false }   # the same bytes, and the padding did pad
+    }
+    if ok { print("DILATE OK") } else { print("DILATE FAILED") }
+    quit()
+  }
+}