refactor: rename mislabeled tile-bitmap queue command and slot 11

Trying to trap DisplayGfx vtable slot 11 as dead code revealed it is in
fact reachable: RenderDrawingQueue case 0xD dispatches into it, and the
queue entries come from our own Rust trampoline for what was labelled
RQ_DrawPixel. Both names were wrong end-to-end — the function enqueues a
tile-cached bitmap draw (only known producer: CTaskLand::RenderLandscape),
not a single pixel.

Renames, byte-format unchanged:
WA 0x541D60: RQ_DrawPixel → RQ_EnqueueTiledBitmap
WA 0x56B8C0: DisplayGfx__CreateBitmap → DisplayGfx__DrawTiledBitmap
Rust DrawPixelCmd → DrawTiledBitmapCmd, with corrected field names
(x_pos/y_pos/color → y_fixed16/source_descriptor/x_fixed16)
command_type::DRAW_PIXEL → DRAW_TILED_BITMAP
trampoline_draw_pixel → trampoline_enqueue_tiled_bitmap
vtable slot 11 create_bitmap → draw_tiled_bitmap

The slot 11 docstring now captures the three-phase semantics (lazy
allocate tile surfaces, populate from source, clipped blit) so a future
port has a blueprint.

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

crates/openwa-core/src/address.rs

@@ -240,6 +240,13 @@ pub mod va {
             fn/Stdcall DISPLAY_GFX_INIT_TEAM_PALETTE_DISPLAY = 0x0057_03E0;
             /// DisplayGfx__LoadSpriteEx (vtable slot 30) — thiscall
             fn/Thiscall DISPLAY_GFX_LOAD_SPRITE_EX = 0x0052_3310;
+            /// `DisplayGfx__DrawTiledBitmap` (vtable slot 11) — thiscall.
+            /// Tile-cached bitmap draw: lazily allocates 0x400-row tile
+            /// surfaces from a sprite source descriptor, populates them, and
+            /// blits the visible tiles to the display. Reachable today via
+            /// `RenderDrawingQueue` case 0xD; needs porting if/when slot is
+            /// replaced.
+            fn/Thiscall DISPLAY_GFX_DRAW_TILED_BITMAP = 0x0056_B8C0;
         }
 
         class "Font" {
@@ -463,7 +470,10 @@ pub mod va {
         fn BLIT_SCREEN = 0x005A_2020;
         fn RQ_RENDER_DRAWING_QUEUE = 0x0054_2350;
         fn DRAW_LANDSCAPE = 0x005A_2790;
-        fn RQ_DRAW_PIXEL = 0x0054_1D60;
+        /// `RQ_EnqueueTiledBitmap` — formerly mis-labelled `RQ_DrawPixel`.
+        /// Enqueues a tile-cached bitmap draw command (type 0xD), dispatched
+        /// by `RenderDrawingQueue` into `DisplayGfx::draw_tiled_bitmap`.
+        fn RQ_ENQUEUE_TILED_BITMAP = 0x0054_1D60;
         fn RQ_DRAW_LINE_STRIP = 0x0054_1DD0;
         fn RQ_DRAW_POLYGON = 0x0054_1E50;
         fn RQ_DRAW_CROSSHAIR = 0x0054_1ED0;

crates/openwa-core/src/render/display/vtable.rs

@@ -100,11 +100,37 @@ pub struct DisplayVtable {
     /// set font rendering parameter (0x523710, RET 0x10)
     #[slot(10)]
     pub set_font_param: fn(this: *mut DisplayGfx, font_id: i32, p3: u32, p4: u32, p5: u32) -> u32,
-    /// create bitmap object (0x56B8C0, RET 0xC)
+    /// draw tile-cached bitmap (0x56B8C0, RET 0xC) — `DisplayGfx__DrawTiledBitmap`.
     ///
-    /// Allocates CBitmap, initializes from sprite data.
+    /// Three-phase tile-bitmap operation, run as a single composite call.
+    /// Each invocation does some or all of:
+    ///
+    /// 1. **Allocate** (only if `this->bitmap_vec` is empty): walk the source
+    ///    height in 0x400-row strips. For each strip, `wa_malloc(0xC)` a
+    ///    `CBitmap` (vtable `0x643F64`, surface ptr at +4), lazily ask the
+    ///    render context for a surface, init the surface as `0x40 × strip × 8bpp`
+    ///    (retrying with 4bpp on failure), and `vector::push_back` the bitmap
+    ///    into `DisplayGfx + 0x3580`. Sets `DisplayGfx[+0x358C] = 0`.
+    /// 2. **Populate** (only if `DisplayGfx[+0x358C] == 0`): for each tile,
+    ///    lock its surface, blit the corresponding source strip via
+    ///    `FUN_005B2A5E` (8bpp) or `BlitColorTable_Forward` (CLUT, `bpp == 0x40`),
+    ///    unlock. Sets `DisplayGfx[+0x358C] = 1`.
+    /// 3. **Display**: `dest_x` is masked to a 0x40-aligned X coord; the
+    ///    visible Y range is computed from `camera_y + dest_y` against
+    ///    `display_height`, clamped to the available tile range. For each
+    ///    visible tile × each `0x40`-wide destination column, calls
+    ///    `DisplayGfx__BlitBitmapClipped`.
+    ///
+    /// `source` is a sprite-source descriptor with at least these fields:
+    /// `+0x08` = bpp (8 or 0x40), `+0x10` = source row stride,
+    /// `+0x14` = (saved early, purpose unconfirmed), `+0x18` = total height.
+    ///
+    /// **Reachable at runtime** via `RenderDrawingQueue` case 0xD, fed by
+    /// `RQ_EnqueueTiledBitmap` (0x541D60). The only known producer is
+    /// `CTaskLand::RenderLandscape`. Currently bridged to the original WA
+    /// function — needs porting if/when slot 11 is replaced.
     #[slot(11)]
-    pub create_bitmap: fn(this: *mut DisplayGfx, count: u32, p3: i32, p4: i32),
+    pub draw_tiled_bitmap: fn(this: *mut DisplayGfx, dest_x: u32, dest_y: i32, source: *mut u8),
     /// draw polyline with camera offset (0x56BCC0, RET 0xC)
     ///
     /// Transforms point array by camera offset, then draws connected line segments.

crates/openwa-core/src/render/mod.rs

@@ -15,8 +15,8 @@ pub use display::{
 pub use landscape::{DirtyRect, PCLandscape};
 pub use opengl::OpenGLState;
 pub use queue::{
-    DrawBitmapGlobalCmd, DrawCrosshairCmd, DrawLineStripHeader, DrawPixelCmd, DrawPolygonHeader,
-    DrawRectCmd, DrawSpriteCmd, DrawSpriteOffsetCmd, DrawTextboxLocalCmd, RenderQueue,
+    DrawBitmapGlobalCmd, DrawCrosshairCmd, DrawLineStripHeader, DrawPolygonHeader, DrawRectCmd,
+    DrawSpriteCmd, DrawSpriteOffsetCmd, DrawTextboxLocalCmd, DrawTiledBitmapCmd, RenderQueue,
 };
 pub use sprite::{ParsedSprite, Sprite, SpriteBank, SpriteFrame, SpriteId};
 pub use turn_order::{

crates/openwa-core/src/render/queue.rs

@@ -78,19 +78,54 @@ impl RenderQueue {
     }
 }
 
-/// Type 0xD — single pixel (0x18 bytes).
+/// Type 0xD — tile-bitmap draw command (0x18 bytes).
+///
+/// Enqueued by `RQ_EnqueueTiledBitmap` (0x541D60, formerly mis-labelled
+/// `RQ_DrawPixel`). The only known producer is `CTaskLand::RenderLandscape`,
+/// which uses it to draw cached landscape texture tiles.
+///
+/// Inside `RenderDrawingQueue`, case 0xD dispatches to
+/// `DisplayGfx::draw_tiled_bitmap` (vtable slot 11, 0x56B8C0):
+/// ```text
+/// RQ_ClipCoordinates(0, x_fixed16, y_fixed16, &out_x, &out_y, ...);
+/// vtable[slot 11](
+///     out_x >> 16 (or 0 if `flags & 1`),  // X in pixels
+///     out_y >> 16,                          // Y in pixels
+///     source_descriptor                     // sprite source struct *
+/// );
+/// ```
+///
+/// The slot 11 method itself runs three phases on each call: lazily allocate
+/// 0x400-row tile surfaces from `source_descriptor->total_height` (cached in
+/// `DisplayGfx + 0x3580`), populate them from the source, then clipped-blit
+/// the tiles to the display.
+///
+/// Field names below are corrected. Wire format is byte-identical to what
+/// the original `RQ_EnqueueTiledBitmap` writes.
 #[repr(C)]
-pub struct DrawPixelCmd {
-    pub command_type: u32, // 0xD
-    pub layer: u32,        // hardcoded 0x1B_0000
-    pub color: u32,        // hardcoded 0xFF00_0000
-    pub x_pos: u32,
-    pub y_pos: u32,
+pub struct DrawTiledBitmapCmd {
+    /// 0x00: Command type — always 0xD.
+    pub command_type: u32,
+    /// 0x04: Render layer — hardcoded 0x1B_0000 by the enqueue function.
+    pub layer: u32,
+    /// 0x08: Source X coordinate (Fixed16). Hardcoded 0xFF00_0000 (= -256.0)
+    /// — the tile sheet always renders from off-screen-left, with the
+    /// dispatcher's clipping pass producing the on-screen X.
+    pub x_fixed16: u32,
+    /// 0x0C: Source Y coordinate (Fixed16). Caller-supplied; goes through
+    /// `RQ_ClipCoordinates` and the high 16 bits become the destination Y.
+    pub y_fixed16: u32,
+    /// 0x10: Pointer to a sprite source descriptor — read by the slot 11
+    /// method as `p4` with fields at `+0x08` (bpp, 8 or 0x40), `+0x10`
+    /// (source row stride), `+0x14`, and `+0x18` (total source height).
+    pub source_descriptor: u32,
+    /// 0x14: Flag byte. Bit 0 forces the destination X to 0 (ignoring the
+    /// clipped result), used for "always start at left edge" rendering.
     pub flags: u8,
     pub _pad: [u8; 3],
 }
 
-const _: () = assert!(core::mem::size_of::<DrawPixelCmd>() == 0x18);
+const _: () = assert!(core::mem::size_of::<DrawTiledBitmapCmd>() == 0x18);
 
 /// Type 0xB — draw crosshair (0x1C = 28 bytes).
 ///
@@ -217,5 +252,7 @@ pub mod command_type {
     pub const DRAW_POLYGON: u32 = 9;
     pub const DRAW_CROSSHAIR: u32 = 0xB;
     pub const DRAW_OUTLINED_PIXEL: u32 = 0xC;
-    pub const DRAW_PIXEL: u32 = 0xD;
+    /// Tile-cached bitmap draw — dispatches to `DisplayGfx::draw_tiled_bitmap`
+    /// (vtable slot 11). Formerly mis-labelled `DRAW_PIXEL`.
+    pub const DRAW_TILED_BITMAP: u32 = 0xD;
 }

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

@@ -21,22 +21,31 @@ use crate::log_line;
 // Calling conventions are __usercall variants with register + stack params.
 
 // ---------------------------------------------------------------------------
-// DrawPixel (0x541D60) — type 0xD, EAX=this, 3 stack, RET 0xC
+// EnqueueTiledBitmap (0x541D60) — type 0xD, EAX=this, 3 stack, RET 0xC
+//
+// Mis-labelled `RQ_DrawPixel` in earlier reverse-engineering passes. It does
+// NOT enqueue a single-pixel draw — it enqueues a tile-cached bitmap draw
+// dispatched by `RenderDrawingQueue` case 0xD into vtable slot 11.
 // ---------------------------------------------------------------------------
 
-usercall_trampoline!(fn trampoline_draw_pixel; impl_fn = draw_pixel_impl;
+usercall_trampoline!(fn trampoline_enqueue_tiled_bitmap; impl_fn = enqueue_tiled_bitmap_impl;
     reg = eax; stack_params = 3; ret_bytes = "0xC");
 
-unsafe extern "cdecl" fn draw_pixel_impl(this: u32, x_pos: u32, y_pos: u32, flags: u32) {
+unsafe extern "cdecl" fn enqueue_tiled_bitmap_impl(
+    this: u32,
+    y_fixed16: u32,
+    source_descriptor: u32,
+    flags: u32,
+) {
     let q = &mut *(this as *mut RenderQueue);
 
-    if let Some(entry) = q.alloc::<DrawPixelCmd>() {
-        *entry = DrawPixelCmd {
-            command_type: command_type::DRAW_PIXEL,
+    if let Some(entry) = q.alloc::<DrawTiledBitmapCmd>() {
+        *entry = DrawTiledBitmapCmd {
+            command_type: command_type::DRAW_TILED_BITMAP,
             layer: 0x1B_0000,
-            color: 0xFF00_0000,
-            x_pos,
-            y_pos,
+            x_fixed16: 0xFF00_0000,
+            y_fixed16,
+            source_descriptor,
             flags: flags as u8,
             _pad: [0; 3],
         };
@@ -594,9 +603,9 @@ unsafe extern "cdecl" fn draw_crosshair_line_impl(task_ptr: u32) {
 fn install_render_queue() -> Result<(), String> {
     unsafe {
         let _ = hook::install(
-            "DrawPixel",
-            va::RQ_DRAW_PIXEL,
-            trampoline_draw_pixel as *const (),
+            "EnqueueTiledBitmap",
+            va::RQ_ENQUEUE_TILED_BITMAP,
+            trampoline_enqueue_tiled_bitmap as *const (),
         )?;
 
         let _ = hook::install(