feat: port non-8bpp blit and introduce PixelGridMut for sound FFI

Port all remaining paths in BitGrid__BlitSpriteRect (0x4F6910) to Rust,
eliminating the fallthrough to the original WA function:

- 1-bit byte-aligned fast path: memcpy/OR/nop for modes 0-3 (collision masks)
- Generic per-pixel fallback (port of FUN_004f80c0): modes 0-5 for any
cells_per_unit, handling unaligned 1-bit, erase, and collision test
- Orientation adjustment logic ported from the original function

Also introduce PixelGridMut<'a> (data: &mut [u8]) to replace the unsound
Vec::from_raw_parts hack used to wrap WA-allocated memory in PixelGrid.
All blit functions now accept PixelGridMut, and the three DLL bridge sites
use slice::from_raw_parts_mut instead.

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

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

@@ -46,6 +46,41 @@ pub struct PixelGrid {
     pub clip_bottom: u32,
 }
 
+/// Borrowed mutable view into an 8bpp pixel buffer.
+///
+/// Same layout as `PixelGrid`, but `data` is a `&mut [u8]` instead of `Vec<u8>`.
+/// Used when the buffer is owned externally (e.g., WA's BitGrid data) and wrapping
+/// it in a `Vec` would be unsound. All blit functions accept this type.
+pub struct PixelGridMut<'a> {
+    pub data: &'a mut [u8],
+    pub width: u32,
+    pub height: u32,
+    pub row_stride: u32,
+    pub clip_left: u32,
+    pub clip_top: u32,
+    pub clip_right: u32,
+    pub clip_bottom: u32,
+}
+
+impl<'a> PixelGridMut<'a> {
+    /// Create a new `PixelGridMut` with a shorter lifetime, allowing the
+    /// original to be reused afterward. Equivalent to `&mut *self` for
+    /// a by-value type — needed when passing to functions that consume
+    /// `PixelGridMut` inside a loop.
+    pub fn reborrow(&mut self) -> PixelGridMut<'_> {
+        PixelGridMut {
+            data: self.data,
+            width: self.width,
+            height: self.height,
+            row_stride: self.row_stride,
+            clip_left: self.clip_left,
+            clip_top: self.clip_top,
+            clip_right: self.clip_right,
+            clip_bottom: self.clip_bottom,
+        }
+    }
+}
+
 impl PixelGrid {
     /// Create a new zeroed pixel grid with default clip rect covering the full surface.
     pub fn new(width: u32, height: u32) -> Self {
@@ -63,6 +98,20 @@ impl PixelGrid {
         }
     }
 
+    /// Borrow this grid as a `PixelGridMut` — the type accepted by blit functions.
+    pub fn as_grid_mut(&mut self) -> PixelGridMut<'_> {
+        PixelGridMut {
+            data: &mut self.data,
+            width: self.width,
+            height: self.height,
+            row_stride: self.row_stride,
+            clip_left: self.clip_left,
+            clip_top: self.clip_top,
+            clip_right: self.clip_right,
+            clip_bottom: self.clip_bottom,
+        }
+    }
+
     /// Clear all pixels to zero.
     pub fn clear(&mut self) {
         self.data.fill(0);

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

@@ -22,7 +22,7 @@
 //!       └── Mode 3: subtractive color mix
 //! ```
 
-use super::line_draw::PixelGrid;
+use super::line_draw::{PixelGrid, PixelGridMut};
 
 /// Source surface for blit operations.
 ///
@@ -135,7 +135,7 @@ impl BlitBlend {
 ///
 /// Returns `true` if any pixels were drawn.
 pub fn blit_sprite_rect(
-    dst: &mut PixelGrid,
+    mut dst: PixelGridMut<'_>,
     src: &BlitSource,
     dst_x: i32,
     dst_y: i32,
@@ -205,7 +205,7 @@ pub fn blit_sprite_rect(
                 vis_bottom,
             );
             blit_copy(
-                dst, src, vis_left, vis_top, vis_w, vis_h, sx_start, sy_start, 1, 1,
+                &mut dst, src, vis_left, vis_top, vis_w, vis_h, sx_start, sy_start, 1, 1,
             );
         }
         BlitBlend::ColorTable => {
@@ -228,12 +228,12 @@ pub fn blit_sprite_rect(
             let table = color_table.unwrap_or(&IDENTITY_TABLE);
             if swap_axes {
                 blit_color_table_swapped(
-                    dst, src, vis_left, vis_top, vis_w, vis_h, sx_start, sy_start, sx_step,
+                    &mut dst, src, vis_left, vis_top, vis_w, vis_h, sx_start, sy_start, sx_step,
                     sy_step, table,
                 );
             } else {
                 blit_color_table(
-                    dst, src, vis_left, vis_top, vis_w, vis_h, sx_start, sy_start, sx_step,
+                    &mut dst, src, vis_left, vis_top, vis_w, vis_h, sx_start, sy_start, sx_step,
                     sy_step, table,
                 );
             }
@@ -254,7 +254,7 @@ pub fn blit_sprite_rect(
                 vis_bottom,
             );
             blit_masked(
-                dst,
+                &mut dst,
                 src,
                 vis_left,
                 vis_top,
@@ -284,7 +284,7 @@ pub fn blit_sprite_rect(
                 vis_bottom,
             );
             blit_masked(
-                dst,
+                &mut dst,
                 src,
                 vis_left,
                 vis_top,
@@ -381,7 +381,7 @@ fn orientation_steps(orientation: BlitOrientation) -> (i32, i32, bool) {
 ///
 /// Source is scanned with sx advancing per dst X, sy advancing per dst Y.
 fn blit_copy(
-    dst: &mut PixelGrid,
+    dst: &mut PixelGridMut<'_>,
     src: &BlitSource,
     vis_left: i32,
     vis_top: i32,
@@ -423,7 +423,7 @@ fn blit_copy(
 /// Each non-zero source pixel is looked up in the color table before writing.
 /// Zero (transparent) pixels are skipped.
 fn blit_color_table(
-    dst: &mut PixelGrid,
+    dst: &mut PixelGridMut<'_>,
     src: &BlitSource,
     vis_left: i32,
     vis_top: i32,
@@ -458,7 +458,7 @@ fn blit_color_table(
 
 /// Color-table blend blit — 90° rotated orientations (axes swapped).
 fn blit_color_table_swapped(
-    dst: &mut PixelGrid,
+    dst: &mut PixelGridMut<'_>,
     src: &BlitSource,
     vis_left: i32,
     vis_top: i32,
@@ -495,7 +495,7 @@ fn blit_color_table_swapped(
 /// Copies source pixels to destination where the predicate `should_write(src, dst)` is true.
 /// Used by modes 2 (additive) and 3 (subtractive).
 fn blit_masked(
-    dst: &mut PixelGrid,
+    dst: &mut PixelGridMut<'_>,
     src: &BlitSource,
     vis_left: i32,
     vis_top: i32,
@@ -551,6 +551,262 @@ pub fn pixel_grid_from_indexed(width: u32, height: u32, pixels: &[u8]) -> PixelG
     grid
 }
 
+// ---------------------------------------------------------------------------
+// 1-bit blit (collision masks)
+// ---------------------------------------------------------------------------
+
+/// Get a single bit from a 1-bit BitGrid data buffer.
+///
+/// Bit layout matches WA's CollisionBitGrid (0x4F5D70):
+/// byte = data[y * stride + (x >> 3)], bit = (byte >> (x & 7)) & 1
+#[inline]
+fn bit_get(data: &[u8], stride: u32, x: i32, y: i32) -> u8 {
+    let byte = data[(y as u32 * stride + (x as u32 >> 3)) as usize];
+    (byte >> (x & 7)) & 1
+}
+
+/// Set a single bit in a 1-bit BitGrid data buffer.
+///
+/// Matches WA's CollisionBitGrid__Put (0x4F5DA0):
+/// clear the bit, then OR in the new value.
+#[inline]
+fn bit_put(data: &mut [u8], stride: u32, x: i32, y: i32, value: u8) {
+    let idx = (y as u32 * stride + (x as u32 >> 3)) as usize;
+    let bit = (x & 7) as u8;
+    data[idx] = (data[idx] & !(1 << bit)) | (((value != 0) as u8) << bit);
+}
+
+/// Byte-aligned 1-bit blit fast path.
+///
+/// Port of the optimized 1-bit path in BitGrid__BlitSpriteRect (0x4F6910).
+/// Requires: both surfaces cpp==1, clip_left/clip_right/src_x all byte-aligned
+/// (divisible by 8), no color table, Normal orientation.
+///
+/// Blend modes:
+/// - 0 (Copy): memcpy bytes
+/// - 1 (ColorTable) / 3 (Subtractive): bitwise OR (both simplify to OR for 1-bit)
+/// - 2 (Additive): no-op (AND of single bits is identity when both are 1)
+pub fn blit_1bit_aligned(
+    dst: &mut [u8],
+    dst_stride: u32,
+    src: &[u8],
+    src_stride: u32,
+    clip_left: i32,
+    clip_top: i32,
+    clip_right: i32,
+    clip_bottom: i32,
+    src_x: i32,
+    src_y: i32,
+    blend_mode: u32,
+) {
+    let byte_width = ((clip_right - clip_left) >> 3) as usize;
+    let dst_byte_x = (clip_left >> 3) as usize;
+    let src_byte_x = (src_x >> 3) as usize;
+
+    match blend_mode {
+        0 => {
+            // Mode 0 (Copy): memcpy per row
+            for row in clip_top..clip_bottom {
+                let dst_off = row as usize * dst_stride as usize + dst_byte_x;
+                let src_row = src_y + (row - clip_top);
+                let src_off = src_row as usize * src_stride as usize + src_byte_x;
+                dst[dst_off..dst_off + byte_width]
+                    .copy_from_slice(&src[src_off..src_off + byte_width]);
+            }
+        }
+        2 => {
+            // Mode 2 (Additive): no-op for 1-bit
+        }
+        _ => {
+            // Mode 1 (ColorTable) and 3 (Subtractive): bitwise OR
+            // Both simplify to OR for single-bit values.
+            for row in clip_top..clip_bottom {
+                let dst_off = row as usize * dst_stride as usize + dst_byte_x;
+                let src_row = src_y + (row - clip_top);
+                let src_off = src_row as usize * src_stride as usize + src_byte_x;
+                for i in 0..byte_width {
+                    dst[dst_off + i] |= src[src_off + i];
+                }
+            }
+        }
+    }
+}
+
+/// Generic per-pixel blit fallback.
+///
+/// Port of FUN_004f80c0 — handles all blend modes (0-5) for any cells_per_unit
+/// by operating one pixel at a time. Slower than the specialized fast paths but
+/// handles unaligned 1-bit blits, oriented blits that fell through, and blend
+/// modes 4 (erase) and 5 (collision test).
+///
+/// Parameters match the original's calling convention:
+/// - clip_left..clip_right, clip_top..clip_bottom: destination region (already clipped)
+/// - src_x: source X corresponding to clip_left
+/// - src_y: source Y corresponding to clip_top
+/// - blend_mode: 0=copy, 1=color_table, 2=additive, 3=subtractive, 4=erase, 5=collision_test
+///
+/// Returns 1 normally, or for mode 5: 1 if collision detected, 0 if not.
+pub fn blit_generic_perpixel(
+    dst: &mut [u8],
+    dst_stride: u32,
+    dst_cpp: u32,
+    src: &[u8],
+    src_stride: u32,
+    src_cpp: u32,
+    clip_left: i32,
+    clip_top: i32,
+    clip_right: i32,
+    clip_bottom: i32,
+    src_x: i32,
+    src_y: i32,
+    color_table: Option<&[u8; 256]>,
+    blend_mode: u32,
+) -> u32 {
+    // Pixel accessors based on cells_per_unit
+    #[inline]
+    fn get_pixel(data: &[u8], stride: u32, cpp: u32, x: i32, y: i32) -> u8 {
+        if cpp == 1 {
+            bit_get(data, stride, x, y)
+        } else {
+            data[y as usize * stride as usize + x as usize]
+        }
+    }
+
+    #[inline]
+    fn put_pixel(data: &mut [u8], stride: u32, cpp: u32, x: i32, y: i32, value: u8) {
+        if cpp == 1 {
+            bit_put(data, stride, x, y, value);
+        } else {
+            data[y as usize * stride as usize + x as usize] = value;
+        }
+    }
+
+    let src_x_offset = src_x - clip_left;
+
+    match blend_mode {
+        0 => {
+            // Copy: get from src, put to dst
+            for y in clip_top..clip_bottom {
+                for x in clip_left..clip_right {
+                    let pixel = get_pixel(
+                        src,
+                        src_stride,
+                        src_cpp,
+                        src_x_offset + x,
+                        src_y + (y - clip_top),
+                    );
+                    put_pixel(dst, dst_stride, dst_cpp, x, y, pixel);
+                }
+            }
+            1
+        }
+        1 => {
+            // Color table blend — per-pixel with optional LUT
+            for y in clip_top..clip_bottom {
+                for x in clip_left..clip_right {
+                    let pixel = get_pixel(
+                        src,
+                        src_stride,
+                        src_cpp,
+                        src_x_offset + x,
+                        src_y + (y - clip_top),
+                    );
+                    if pixel != 0 {
+                        let value = match color_table {
+                            Some(table) => table[pixel as usize],
+                            None => pixel,
+                        };
+                        put_pixel(dst, dst_stride, dst_cpp, x, y, value);
+                    }
+                }
+            }
+            1
+        }
+        2 => {
+            // Additive: copy src where both src and dst non-zero
+            for y in clip_top..clip_bottom {
+                for x in clip_left..clip_right {
+                    let src_pixel = get_pixel(
+                        src,
+                        src_stride,
+                        src_cpp,
+                        src_x_offset + x,
+                        src_y + (y - clip_top),
+                    );
+                    if src_pixel != 0 {
+                        let dst_pixel = get_pixel(dst, dst_stride, dst_cpp, x, y);
+                        if dst_pixel != 0 {
+                            put_pixel(dst, dst_stride, dst_cpp, x, y, src_pixel);
+                        }
+                    }
+                }
+            }
+            1
+        }
+        3 => {
+            // Subtractive: copy src where src non-zero and dst zero
+            for y in clip_top..clip_bottom {
+                for x in clip_left..clip_right {
+                    let src_pixel = get_pixel(
+                        src,
+                        src_stride,
+                        src_cpp,
+                        src_x_offset + x,
+                        src_y + (y - clip_top),
+                    );
+                    if src_pixel != 0 {
+                        let dst_pixel = get_pixel(dst, dst_stride, dst_cpp, x, y);
+                        if dst_pixel == 0 {
+                            put_pixel(dst, dst_stride, dst_cpp, x, y, src_pixel);
+                        }
+                    }
+                }
+            }
+            1
+        }
+        4 => {
+            // Erase: clear dst where src non-zero
+            for y in clip_top..clip_bottom {
+                for x in clip_left..clip_right {
+                    let src_pixel = get_pixel(
+                        src,
+                        src_stride,
+                        src_cpp,
+                        src_x_offset + x,
+                        src_y + (y - clip_top),
+                    );
+                    if src_pixel != 0 {
+                        put_pixel(dst, dst_stride, dst_cpp, x, y, 0);
+                    }
+                }
+            }
+            1
+        }
+        5 => {
+            // Collision test: return 1 if any pixel overlaps (both non-zero)
+            for y in clip_top..clip_bottom {
+                for x in clip_left..clip_right {
+                    let dst_pixel = get_pixel(dst, dst_stride, dst_cpp, x, y);
+                    if dst_pixel != 0 {
+                        let src_pixel = get_pixel(
+                            src,
+                            src_stride,
+                            src_cpp,
+                            src_x_offset + x,
+                            src_y + (y - clip_top),
+                        );
+                        if src_pixel != 0 {
+                            return 1;
+                        }
+                    }
+                }
+            }
+            0
+        }
+        _ => 1,
+    }
+}
+
 // ---------------------------------------------------------------------------
 // Stippled blit (checkerboard pattern)
 // ---------------------------------------------------------------------------
@@ -567,7 +823,7 @@ pub fn pixel_grid_from_indexed(width: u32, height: u32, pixels: &[u8]) -> PixelG
 /// Only non-zero source pixels are drawn (transparent = 0).
 /// Pixels outside the destination clip rect are skipped.
 pub fn blit_stippled(
-    dst: &mut PixelGrid,
+    dst: &mut PixelGridMut<'_>,
     src: &BlitSource<'_>,
     dst_x: i32,
     dst_y: i32,
@@ -636,7 +892,7 @@ pub fn blit_stippled(
 /// `flags` is the blit flags word (orientation + blend mode) passed through
 /// to each individual `blit_sprite_rect` call.
 pub fn blit_tiled(
-    dst: &mut PixelGrid,
+    dst: &mut PixelGridMut<'_>,
     src: &BlitSource<'_>,
     initial_x: i32,
     dst_y: i32,
@@ -666,7 +922,7 @@ pub fn blit_tiled(
     // Tile rightward until past clip_right
     while x < clip_right {
         blit_sprite_rect(
-            dst,
+            dst.reborrow(),
             src,
             x,
             dst_y,
@@ -711,7 +967,7 @@ mod tests {
         let mut dst = PixelGrid::new(16, 16);
 
         blit_sprite_rect(
-            &mut dst,
+            dst.as_grid_mut(),
             &src,
             4,
             4, // dst position
@@ -744,7 +1000,7 @@ mod tests {
         let mut dst_mirror = PixelGrid::new(16, 16);
 
         blit_sprite_rect(
-            &mut dst_normal,
+            dst_normal.as_grid_mut(),
             &src,
             4,
             4,
@@ -757,7 +1013,7 @@ mod tests {
             BlitBlend::Copy,
         );
         blit_sprite_rect(
-            &mut dst_mirror,
+            dst_mirror.as_grid_mut(),
             &src,
             4,
             4,
@@ -784,7 +1040,7 @@ mod tests {
         let mut dst = PixelGrid::new(16, 16);
 
         blit_sprite_rect(
-            &mut dst,
+            dst.as_grid_mut(),
             &src,
             4,
             4,
@@ -811,7 +1067,7 @@ mod tests {
         let mut dst = PixelGrid::new(16, 16);
 
         blit_sprite_rect(
-            &mut dst,
+            dst.as_grid_mut(),
             &src,
             4,
             4,
@@ -841,7 +1097,7 @@ mod tests {
         dst.clip_top = 8;
 
         blit_sprite_rect(
-            &mut dst,
+            dst.as_grid_mut(),
             &src,
             4,
             4,
@@ -877,7 +1133,7 @@ mod tests {
         table[0] = 0; // transparent stays 0
 
         blit_sprite_rect(
-            &mut dst,
+            dst.as_grid_mut(),
             &src,
             4,
             4,
@@ -912,7 +1168,7 @@ mod tests {
         dst.data.fill(99); // background
 
         blit_sprite_rect(
-            &mut dst,
+            dst.as_grid_mut(),
             &src,
             0,
             0,
@@ -948,7 +1204,7 @@ mod tests {
         lut[4] = 40;
 
         blit_sprite_rect(
-            &mut dst,
+            dst.as_grid_mut(),
             &src,
             4,
             4,
@@ -983,7 +1239,7 @@ mod tests {
         lut[4] = 40;
 
         blit_sprite_rect(
-            &mut dst,
+            dst.as_grid_mut(),
             &src,
             4,
             4,
@@ -1017,7 +1273,7 @@ mod tests {
         }
 
         blit_sprite_rect(
-            &mut dst,
+            dst.as_grid_mut(),
             &src,
             4,
             4,
@@ -1055,7 +1311,7 @@ mod tests {
         }
 
         blit_sprite_rect(
-            &mut dst,
+            dst.as_grid_mut(),
             &src,
             4,
             4,
@@ -1102,7 +1358,7 @@ mod tests {
         dst.data.fill(99); // all non-zero
 
         blit_sprite_rect(
-            &mut dst,
+            dst.as_grid_mut(),
             &src,
             0,
             0,
@@ -1241,7 +1497,7 @@ mod tests {
         let mut dst = PixelGrid::new(canvas_w, canvas_h);
 
         blit_sprite_rect(
-            &mut dst,
+            dst.as_grid_mut(),
             &src,
             16,
             16,
@@ -1279,7 +1535,7 @@ mod tests {
 
         let mut dst = PixelGrid::new(sprite.width, sprite.height);
         blit_sprite_rect(
-            &mut dst,
+            dst.as_grid_mut(),
             &src,
             0,
             0,
@@ -1311,7 +1567,7 @@ mod tests {
         // Blit at (-16, -16) so only bottom-right portion is visible
         let mut dst = PixelGrid::new(sprite.width, sprite.height);
         blit_sprite_rect(
-            &mut dst,
+            dst.as_grid_mut(),
             &src,
             -16,
             -16,
@@ -1344,7 +1600,7 @@ mod tests {
         dst.data.fill(42); // background color
 
         blit_sprite_rect(
-            &mut dst,
+            dst.as_grid_mut(),
             &src,
             0,
             0,
@@ -1397,7 +1653,7 @@ mod tests {
         dst.data.fill(42);
 
         blit_sprite_rect(
-            &mut dst,
+            dst.as_grid_mut(),
             &src,
             0,
             0,
@@ -1504,7 +1760,7 @@ mod tests {
         dst.data.fill(bg_fill);
 
         blit_sprite_rect(
-            &mut dst,
+            dst.as_grid_mut(),
             &src,
             dst_x,
             dst_y,
@@ -1759,7 +2015,18 @@ mod tests {
         let mut dst = PixelGrid::new(canvas_w, canvas_h);
         dst.data.fill(77); // background matching DLL capture
 
-        blit_stippled(&mut dst, &src, 16, 16, sw, sh, 0, 0, stipple_mode, parity);
+        blit_stippled(
+            &mut dst.as_grid_mut(),
+            &src,
+            16,
+            16,
+            sw,
+            sh,
+            0,
+            0,
+            stipple_mode,
+            parity,
+        );
 
         assert_matches_snapshot(&dst, snap_name);
     }
@@ -1803,8 +2070,16 @@ mod tests {
         let clip_right = canvas_w as i32;
 
         blit_tiled(
-            &mut dst, &src, 8, // initial_x matching DLL capture
-            16, sw, sh, clip_left, clip_right, None, flags,
+            &mut dst.as_grid_mut(),
+            &src,
+            8, // initial_x matching DLL capture
+            16,
+            sw,
+            sh,
+            clip_left,
+            clip_right,
+            None,
+            flags,
         );
 
         assert_matches_snapshot(&dst, snap_name);

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

@@ -854,10 +854,13 @@ unsafe extern "C" fn blit_hook_trampoline() {
     );
 }
 
-/// Rust implementation of the core sprite blit.
+/// Rust implementation of the core sprite blit (BitGrid__BlitSpriteRect, 0x4F6910).
 ///
-/// Handles all 8bpp blend modes: 0 (copy), 1 (color table), 2 (additive mask), 3 (subtractive mask).
-/// Falls through to the original WA function for non-8bpp surfaces.
+/// Handles all blend modes for both 8bpp and 1-bit surfaces:
+/// - 8bpp modes 0-3: via `blit_sprite_rect` (orientation-aware, PixelGrid wrapper)
+/// - 1-bit byte-aligned fast path: memcpy/OR/nop for modes 0-3 with Normal orientation
+/// - Generic per-pixel fallback: handles all remaining cases (unaligned 1-bit, modes 4-5,
+///   mixed cpp, etc.) via `blit_generic_perpixel`
 pub(crate) unsafe extern "cdecl" fn blit_impl(
     dst: *mut openwa_core::bitgrid::DisplayBitGrid,
     dst_x: i32,
@@ -870,10 +873,6 @@ pub(crate) unsafe extern "cdecl" fn blit_impl(
     color_table: *const u8,
     flags: u32,
 ) -> u32 {
-    use openwa_core::display::sprite_blit::{
-        blit_sprite_rect, BlitBlend, BlitOrientation, BlitSource,
-    };
-
     if width == 0 || height == 0 {
         return 0;
     }
@@ -882,9 +881,9 @@ pub(crate) unsafe extern "cdecl" fn blit_impl(
     let src_cpp = (*src).cells_per_unit;
     let dst_cpp = (*dst).cells_per_unit;
 
-    // Only handle 8bpp surfaces with blend modes 0-3
-    if dst_cpp != 8 || src_cpp != 8 || blend_mode > 3 {
-        return call_original_blit(
+    // Fast path: 8bpp surfaces with blend modes 0-3
+    if dst_cpp == 8 && src_cpp == 8 && blend_mode <= 3 {
+        return blit_8bpp(
             dst,
             dst_x,
             dst_y,
@@ -898,7 +897,196 @@ pub(crate) unsafe extern "cdecl" fn blit_impl(
         );
     }
 
-    // Convert color_table from raw pointer to typed reference
+    // --- Clipping (shared by 1-bit fast path and generic fallback) ---
+    // This mirrors the clipping logic at the top of BitGrid__BlitSpriteRect.
+    let dst_right = dst_x + width;
+    let dst_bottom = dst_y + height;
+
+    let clip_left = (*dst).clip_left as i32;
+    let clip_top = (*dst).clip_top as i32;
+    let clip_right = (*dst).clip_right as i32;
+    let clip_bottom = (*dst).clip_bottom as i32;
+
+    // Early-out: completely outside clip rect
+    if dst_x >= clip_right
+        || dst_right <= clip_left
+        || dst_y >= clip_bottom
+        || dst_bottom <= clip_top
+    {
+        return 0;
+    }
+
+    // Clamp visible region to clip rect
+    let vis_left = dst_x.max(clip_left);
+    let vis_right = dst_right.min(clip_right);
+    let vis_top = dst_y.max(clip_top);
+    let vis_bottom = dst_bottom.min(clip_bottom);
+
+    if vis_left >= vis_right || vis_top >= vis_bottom {
+        return 0;
+    }
+
+    // Adjust source coordinates for clipping and orientation.
+    // The orientation switch in the original adjusts src_x/src_y before the cpp check.
+    let orientation_code = (flags >> 16) & 0xFFFF;
+    let (adj_src_x, adj_src_y) = adjust_src_for_orientation(
+        src_x,
+        src_y,
+        dst_x,
+        dst_y,
+        width,
+        height,
+        vis_left,
+        vis_top,
+        vis_right,
+        vis_bottom,
+        orientation_code,
+    );
+
+    // Build slices from raw BitGrid data pointers
+    let dst_data =
+        core::slice::from_raw_parts_mut((*dst).data, ((*dst).row_stride * (*dst).height) as usize);
+    let src_data =
+        core::slice::from_raw_parts((*src).data, ((*src).row_stride * (*src).height) as usize);
+
+    // 1-bit byte-aligned fast path
+    if dst_cpp == 1 && src_cpp == 1 {
+        let left_aligned = (vis_left & 7) == 0;
+        let right_aligned = (vis_right & 7) == 0;
+        let src_aligned = (adj_src_x & 7) == 0;
+
+        if left_aligned && right_aligned && src_aligned && color_table.is_null() && flags < 4 {
+            openwa_core::display::sprite_blit::blit_1bit_aligned(
+                dst_data,
+                (*dst).row_stride,
+                src_data,
+                (*src).row_stride,
+                vis_left,
+                vis_top,
+                vis_right,
+                vis_bottom,
+                adj_src_x,
+                adj_src_y,
+                blend_mode,
+            );
+            return 1;
+        }
+    }
+
+    // Convert color_table pointer to typed reference for the generic path
+    let color_table_ref: Option<&[u8; 256]> = if !color_table.is_null() {
+        Some(&*(color_table as *const [u8; 256]))
+    } else {
+        None
+    };
+
+    // Generic per-pixel fallback — handles all remaining cases
+    openwa_core::display::sprite_blit::blit_generic_perpixel(
+        dst_data,
+        (*dst).row_stride,
+        dst_cpp,
+        src_data,
+        (*src).row_stride,
+        src_cpp,
+        vis_left,
+        vis_top,
+        vis_right,
+        vis_bottom,
+        adj_src_x,
+        adj_src_y,
+        color_table_ref,
+        blend_mode,
+    )
+}
+
+/// Adjust source coordinates for clipping and orientation.
+///
+/// Port of the orientation switch in BitGrid__BlitSpriteRect (0x4F69D3..0x4F6A9D).
+/// Maps the 16 orientation codes (0-15) to 8 unique source adjustments.
+fn adjust_src_for_orientation(
+    src_x: i32,
+    src_y: i32,
+    dst_x: i32,
+    dst_y: i32,
+    width: i32,
+    height: i32,
+    vis_left: i32,
+    vis_top: i32,
+    vis_right: i32,
+    vis_bottom: i32,
+    orientation: u32,
+) -> (i32, i32) {
+    match orientation {
+        1 | 10 => {
+            // MirrorX: src_x from right side, src_y from top
+            let sx = src_x + (dst_x - vis_right) + width;
+            let sy = src_y + (vis_top - dst_y);
+            (sx, sy)
+        }
+        2 | 9 => {
+            // MirrorY: src_x from left, src_y from bottom
+            let sx = src_x + (vis_left - dst_x);
+            let sy = src_y + (dst_y - vis_bottom) + height;
+            (sx, sy)
+        }
+        3 | 8 => {
+            // MirrorXY: src_x from right, src_y from bottom
+            let sx = src_x + (dst_x - vis_right) + width;
+            let sy = src_y + (dst_y - vis_bottom) + height;
+            (sx, sy)
+        }
+        4 | 15 => {
+            // Rotate90: src_x tracks dst_y from bottom, src_y tracks dst_x from left
+            let sx = src_x + (dst_y - vis_bottom) + height;
+            let sy = src_y + (vis_left - dst_x);
+            (sx, sy)
+        }
+        5 | 14 => {
+            // Rotate90+MirrorX
+            let sx = src_x + (dst_y - vis_bottom) + height;
+            let sy = src_y + (dst_x - vis_right) + width;
+            (sx, sy)
+        }
+        6 | 13 => {
+            // Rotate90+MirrorY
+            let sx = src_x + (vis_top - dst_y);
+            let sy = src_y + (vis_left - dst_x);
+            (sx, sy)
+        }
+        7 | 12 => {
+            // Rotate90+MirrorXY
+            let sx = src_x + (vis_top - dst_y);
+            let sy = src_y + (dst_x - vis_right) + width;
+            (sx, sy)
+        }
+        _ => {
+            // Normal (0, 11, or any default)
+            let sx = src_x + (vis_left - dst_x);
+            let sy = src_y + (vis_top - dst_y);
+            (sx, sy)
+        }
+    }
+}
+
+/// 8bpp blit path — extracted from the original blit_impl for clarity.
+///
+/// Handles blend modes 0-3 on 8bpp surfaces via PixelGrid wrapper.
+unsafe fn blit_8bpp(
+    dst: *mut openwa_core::bitgrid::DisplayBitGrid,
+    dst_x: i32,
+    dst_y: i32,
+    width: i32,
+    height: i32,
+    src: *mut openwa_core::bitgrid::DisplayBitGrid,
+    src_x: i32,
+    src_y: i32,
+    color_table: *const u8,
+    flags: u32,
+) -> u32 {
+    use openwa_core::display::sprite_blit::{
+        blit_sprite_rect, BlitBlend, BlitOrientation, BlitSource,
+    };
+
     let color_table_ref: Option<&[u8; 256]> = if !color_table.is_null() {
         Some(&*(color_table as *const [u8; 256]))
     } else {
@@ -908,7 +1096,6 @@ pub(crate) unsafe extern "cdecl" fn blit_impl(
     let orientation = BlitOrientation::from_flags(flags);
     let blend = BlitBlend::from_flags(flags);
 
-    // Build source view
     let src_data =
         core::slice::from_raw_parts((*src).data, ((*src).row_stride * (*src).height) as usize);
     let blit_src = BlitSource {
@@ -918,29 +1105,20 @@ pub(crate) unsafe extern "cdecl" fn blit_impl(
         row_stride: (*src).row_stride,
     };
 
-    // Build mutable destination view
-    let dst_stride = (*dst).row_stride;
-    let dst_h = (*dst).height;
-    let dst_w = (*dst).width;
-    let dst_data_len = (dst_stride * dst_h) as usize;
-
-    // Create a temporary PixelGrid wrapping the destination BitGrid's memory
-    let mut dst_grid = openwa_core::display::line_draw::PixelGrid {
-        data: Vec::new(), // placeholder — we'll swap in the real data
-        width: dst_w,
-        height: dst_h,
-        row_stride: dst_stride,
+    let dst_data_len = ((*dst).row_stride * (*dst).height) as usize;
+    let dst_grid = openwa_core::display::line_draw::PixelGridMut {
+        data: core::slice::from_raw_parts_mut((*dst).data, dst_data_len),
+        width: (*dst).width,
+        height: (*dst).height,
+        row_stride: (*dst).row_stride,
         clip_left: (*dst).clip_left,
         clip_top: (*dst).clip_top,
         clip_right: (*dst).clip_right,
         clip_bottom: (*dst).clip_bottom,
     };
-    // Swap the real data in (avoids allocation)
-    let mut real_data = Vec::from_raw_parts((*dst).data, dst_data_len, dst_data_len);
-    core::mem::swap(&mut dst_grid.data, &mut real_data);
 
-    let result = blit_sprite_rect(
-        &mut dst_grid,
+    blit_sprite_rect(
+        dst_grid,
         &blit_src,
         dst_x,
         dst_y,
@@ -951,13 +1129,7 @@ pub(crate) unsafe extern "cdecl" fn blit_impl(
         color_table_ref,
         orientation,
         blend,
-    );
-
-    // Swap data back — we must NOT let Vec drop the BitGrid's data
-    core::mem::swap(&mut dst_grid.data, &mut real_data);
-    core::mem::forget(real_data); // BitGrid owns this memory
-
-    result as u32
+    ) as u32
 }
 
 /// Stippled blit on raw BitGrid pointers.
@@ -987,23 +1159,17 @@ pub(crate) unsafe fn blit_stippled_raw(
         row_stride: (*src).row_stride,
     };
 
-    let dst_stride = (*dst).row_stride;
-    let dst_h = (*dst).height;
-    let dst_w = (*dst).width;
-    let dst_data_len = (dst_stride * dst_h) as usize;
-
-    let mut dst_grid = openwa_core::display::line_draw::PixelGrid {
-        data: Vec::new(),
-        width: dst_w,
-        height: dst_h,
-        row_stride: dst_stride,
+    let dst_data_len = ((*dst).row_stride * (*dst).height) as usize;
+    let mut dst_grid = openwa_core::display::line_draw::PixelGridMut {
+        data: core::slice::from_raw_parts_mut((*dst).data, dst_data_len),
+        width: (*dst).width,
+        height: (*dst).height,
+        row_stride: (*dst).row_stride,
         clip_left: (*dst).clip_left,
         clip_top: (*dst).clip_top,
         clip_right: (*dst).clip_right,
         clip_bottom: (*dst).clip_bottom,
     };
-    let mut real_data = Vec::from_raw_parts((*dst).data, dst_data_len, dst_data_len);
-    core::mem::swap(&mut dst_grid.data, &mut real_data);
 
     blit_stippled(
         &mut dst_grid,
@@ -1017,9 +1183,6 @@ pub(crate) unsafe fn blit_stippled_raw(
         stipple_mode,
         parity,
     );
-
-    core::mem::swap(&mut dst_grid.data, &mut real_data);
-    core::mem::forget(real_data);
 }
 
 /// Tiled blit on raw BitGrid pointers.
@@ -1048,23 +1211,17 @@ pub(crate) unsafe fn blit_tiled_raw(
         row_stride: (*src).row_stride,
     };
 
-    let dst_stride = (*dst).row_stride;
-    let dst_h = (*dst).height;
-    let dst_w = (*dst).width;
-    let dst_data_len = (dst_stride * dst_h) as usize;
-
-    let mut dst_grid = openwa_core::display::line_draw::PixelGrid {
-        data: Vec::new(),
-        width: dst_w,
-        height: dst_h,
-        row_stride: dst_stride,
+    let dst_data_len = ((*dst).row_stride * (*dst).height) as usize;
+    let mut dst_grid = openwa_core::display::line_draw::PixelGridMut {
+        data: core::slice::from_raw_parts_mut((*dst).data, dst_data_len),
+        width: (*dst).width,
+        height: (*dst).height,
+        row_stride: (*dst).row_stride,
         clip_left: (*dst).clip_left,
         clip_top: (*dst).clip_top,
         clip_right: (*dst).clip_right,
         clip_bottom: (*dst).clip_bottom,
     };
-    let mut real_data = Vec::from_raw_parts((*dst).data, dst_data_len, dst_data_len);
-    core::mem::swap(&mut dst_grid.data, &mut real_data);
 
     blit_tiled(
         &mut dst_grid,
@@ -1078,12 +1235,11 @@ pub(crate) unsafe fn blit_tiled_raw(
         None, // color_table — tiled mode doesn't use one
         flags,
     );
-
-    core::mem::swap(&mut dst_grid.data, &mut real_data);
-    core::mem::forget(real_data);
 }
 
 /// Call the original WA blit function via trampoline.
+/// No longer used — kept for debugging if fallthrough is temporarily needed.
+#[allow(dead_code)]
 unsafe fn call_original_blit(
     dst: *mut openwa_core::bitgrid::DisplayBitGrid,
     dst_x: i32,
@@ -1113,6 +1269,7 @@ unsafe fn call_original_blit(
 }
 
 /// Naked asm to call the original blit with ESI set correctly.
+#[allow(dead_code)]
 #[unsafe(naked)]
 unsafe extern "cdecl" fn call_original_blit_asm(
     _dst: *mut openwa_core::bitgrid::DisplayBitGrid,