feat: port DDDisplay draw_polyline with zero-alloc polygon fill

Wire draw_polyline (slot 12) to the pure Rust polygon fill pipeline.
All buffers are stack-allocated: 256-vertex input cap, 512-vertex clip
buffers, 1024-entry span tables. Make Vertex public, remove Vec
allocations from draw_polygon_filled. Add polygon snapshot capture.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

crates/openwa-core/src/display/dd_display.rs

@@ -741,6 +741,44 @@ pub unsafe extern "thiscall" fn draw_line_clipped(
     );
 }
 
+/// Port of DDDisplay::DrawPolyline (vtable slot 12, 0x56BCC0).
+///
+/// Transforms point array by camera offset, clips, and fills the polygon.
+/// Points are Fixed-point (x, y) pairs. Pixel-integer camera is applied as
+/// `camera * 0x10000 + coord`.
+///
+/// # Safety
+/// `this` must be a valid `*mut DDDisplay` (actually a `*mut DisplayGfx`).
+pub unsafe extern "thiscall" fn draw_polyline(
+    this: *mut DDDisplay,
+    points: *mut i32,
+    count: i32,
+    color: u32,
+) {
+    let gfx = this as *mut DisplayGfx;
+    let cam_x = Fixed::from_int((*gfx).camera_x);
+    let cam_y = Fixed::from_int((*gfx).camera_y);
+
+    // Build vertex array with camera offset on the stack
+    let n = count as usize;
+    if n == 0 || n > 256 {
+        return;
+    }
+
+    let mut verts = [line_draw::Vertex::new(Fixed::ZERO, Fixed::ZERO); 256];
+    for i in 0..n {
+        verts[i] = line_draw::Vertex::new(
+            Fixed::from_raw(*points.add(i * 2)) + cam_x,
+            Fixed::from_raw(*points.add(i * 2 + 1)) + cam_y,
+        );
+    }
+
+    acquire_render_lock(gfx);
+
+    let mut writer = BitGridWriter((*gfx).layer_0);
+    line_draw::draw_polygon_filled(&mut writer, &verts[..n], color as u8);
+}
+
 /// Port of DDDisplay::DrawPixelStrip (vtable slot 15, 0x56BE10).
 ///
 /// Draws `count + 1` pixels starting at (x, y), stepping by (dx, dy) each

crates/openwa-core/src/display/line_draw.rs

@@ -550,9 +550,16 @@ const MAX_CLIP_VERTS: usize = 512;
 
 /// A Fixed-point vertex (x, y).
 #[derive(Clone, Copy)]
-struct Vertex {
-    x: Fixed,
-    y: Fixed,
+pub struct Vertex {
+    pub x: Fixed,
+    pub y: Fixed,
+}
+
+impl Vertex {
+    #[inline]
+    pub const fn new(x: Fixed, y: Fixed) -> Self {
+        Self { x, y }
+    }
 }
 
 /// Clip polygon edges against a single axis boundary.
@@ -803,15 +810,13 @@ pub fn fill_polygon(writer: &mut impl PixelWriter, verts: &[Vertex], color: u8)
 
 /// Draw a filled polygon. Clips against the writer's bounds, then scanline-fills.
 ///
-/// Input vertices are Fixed-point (x, y) pairs.
-pub fn draw_polygon_filled(writer: &mut impl PixelWriter, vertices: &[(Fixed, Fixed)], color: u8) {
-    let input: Vec<Vertex> = vertices.iter().map(|&(x, y)| Vertex { x, y }).collect();
-
+/// No heap allocation — uses stack buffers for clipping.
+pub fn draw_polygon_filled(writer: &mut impl PixelWriter, vertices: &[Vertex], color: u8) {
     let mut clipped = [Vertex {
         x: Fixed::ZERO,
         y: Fixed::ZERO,
     }; MAX_CLIP_VERTS];
-    let count = clip_polygon(&input, &mut clipped, writer);
+    let count = clip_polygon(vertices, &mut clipped, writer);
 
     if count > 2 {
         fill_polygon(writer, &clipped[..count], color);
@@ -1109,6 +1114,10 @@ mod tests {
     }
 
     // Polygon fill snapshot tests
+    fn v(x: Fixed, y: Fixed) -> Vertex {
+        Vertex::new(x, y)
+    }
+
     macro_rules! snapshot_test_poly {
         ($name:ident, $snap:expr, $verts:expr, $color:expr) => {
             #[test]
@@ -1123,17 +1132,17 @@ mod tests {
     snapshot_test_poly!(
         snap_poly_triangle,
         "poly_triangle",
-        &[(f(64), f(10)), (f(118), f(100)), (f(10), f(100))],
+        &[v(f(64), f(10)), v(f(118), f(100)), v(f(10), f(100))],
         1
     );
     snapshot_test_poly!(
         snap_poly_square,
         "poly_square",
         &[
-            (f(20), f(20)),
-            (f(100), f(20)),
-            (f(100), f(100)),
-            (f(20), f(100))
+            v(f(20), f(20)),
+            v(f(100), f(20)),
+            v(f(100), f(100)),
+            v(f(20), f(100))
         ],
         2
     );
@@ -1141,17 +1150,17 @@ mod tests {
         snap_poly_diamond,
         "poly_diamond",
         &[
-            (f(64), f(10)),
-            (f(118), f(64)),
-            (f(64), f(118)),
-            (f(10), f(64))
+            v(f(64), f(10)),
+            v(f(118), f(64)),
+            v(f(64), f(118)),
+            v(f(10), f(64))
         ],
         3
     );
     snapshot_test_poly!(
         snap_poly_partially_outside,
         "poly_partially_outside",
-        &[(f(64), f(-30)), (f(160), f(100)), (f(-30), f(100))],
+        &[v(f(64), f(-30)), v(f(160), f(100)), v(f(-30), f(100))],
         4
     );
 
@@ -1164,7 +1173,7 @@ mod tests {
         grid.clip_bottom = 98;
         draw_polygon_filled(
             &mut grid,
-            &[(f(64), f(10)), (f(118), f(100)), (f(10), f(100))],
+            &[v(f(64), f(10)), v(f(118), f(100)), v(f(10), f(100))],
             5,
         );
         assert_matches_snapshot(&grid, "poly_restricted_clip");

crates/openwa-dll/src/replacements/display.rs

@@ -300,6 +300,7 @@ pub fn install() -> Result<(), String> {
         // Patch DDDisplay vtable (0x66A218): replace ported methods with Rust.
         vtable_replace!(DDDisplayVtable, va::DD_DISPLAY_VTABLE, {
             get_dimensions      => dd_display::get_dimensions,
+            draw_polyline       => dd_display::draw_polyline,
             draw_line           => dd_display::draw_line,
             draw_line_clipped   => dd_display::draw_line_clipped,
             draw_pixel_strip    => dd_display::draw_pixel_strip,