refactor: migrate all render queue commands to typed RenderMessage enum

Replace legacy DrawXxxCmd structs with RenderMessage variants for all
10 Rust-produced command types. Variable-length commands (LineStrip,
Polygon) use alloc_aux() for vertex data with explicit pointers in the
enum, avoiding layout coupling. Remove legacy structs and command_type
constants module.

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

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

@@ -10,7 +10,7 @@
 use crate::address::va;
 use crate::fixed::Fixed;
 use crate::rebase::rb;
-use crate::render::queue::*;
+use crate::render::message::RenderMessage;
 use crate::render::SpriteOp;
 use crate::task::BungeeTrailTask;
 use crate::trig::trig_lookup;
@@ -46,17 +46,17 @@ pub unsafe fn draw_bungee_trail(task: *const BungeeTrailTask, style: u32, fill:
 
     let first_angle = *(seg_data.add(4) as *const i32);
 
-    // Enqueue start sprite (command type 5 = local)
-    if let Some(entry) = rq.alloc::<DrawSpriteCmd>() {
-        *entry = DrawSpriteCmd {
-            command_type: command_type::DRAW_SPRITE_LOCAL,
-            layer: 0xDFFFF,
+    // Enqueue start sprite (screen-space)
+    let _ = rq.push_typed(
+        0xDFFFF,
+        RenderMessage::Sprite {
+            local: true,
             x: Fixed(x).floor(),
             y: Fixed(y).floor(),
             sprite: SpriteOp(0x45),
             palette: (first_angle + 0x8100) as u32,
-        };
-    }
+        },
+    );
 
     // Build vertex array from trail segments
     const MAX_VERTICES: usize = 256;
@@ -91,38 +91,30 @@ pub unsafe fn draw_bungee_trail(task: *const BungeeTrailTask, style: u32, fill:
         vert_count += 1;
     }
 
-    // Enqueue as polygon or line strip
-    if fill != 0 {
-        let total_size = vert_count * 0xC + 0x20;
-        if let Some(ptr) = rq.alloc_raw(total_size) {
-            let header = &mut *(ptr as *mut DrawPolygonHeader);
-            *header = DrawPolygonHeader {
-                command_type: command_type::DRAW_POLYGON,
-                layer: 0xE_0000,
-                count: vert_count as u32,
-                color1: style,
-                color2: fill,
-            };
-            core::ptr::copy_nonoverlapping(
-                verts.as_ptr() as *const u8,
-                ptr.add(core::mem::size_of::<DrawPolygonHeader>()),
-                vert_count * 0xC,
+    // Allocate vertex data in the arena and enqueue as polygon or line strip
+    let byte_len = vert_count * core::mem::size_of::<[i32; 3]>();
+    if let Some(vert_ptr) = rq.alloc_aux(byte_len) {
+        core::ptr::copy_nonoverlapping(verts.as_ptr() as *const u8, vert_ptr, byte_len);
+        let vert_slice = vert_ptr as *const [i32; 3];
+
+        if fill != 0 {
+            let _ = rq.push_typed(
+                0xE_0000,
+                RenderMessage::Polygon {
+                    count: vert_count as u32,
+                    color1: style,
+                    color2: fill,
+                    vertices: vert_slice,
+                },
             );
-        }
-    } else {
-        let total_size = vert_count * 0xC + 0x1C;
-        if let Some(ptr) = rq.alloc_raw(total_size) {
-            let header = &mut *(ptr as *mut DrawLineStripHeader);
-            *header = DrawLineStripHeader {
-                command_type: command_type::DRAW_LINE_STRIP,
-                layer: 0xE_0000,
-                count: vert_count as u32,
-                color: style,
-            };
-            core::ptr::copy_nonoverlapping(
-                verts.as_ptr() as *const u8,
-                ptr.add(core::mem::size_of::<DrawLineStripHeader>()),
-                vert_count * 0xC,
+        } else {
+            let _ = rq.push_typed(
+                0xE_0000,
+                RenderMessage::LineStrip {
+                    count: vert_count as u32,
+                    color: style,
+                    vertices: vert_slice,
+                },
             );
         }
     }

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

@@ -11,7 +11,7 @@
 use crate::address::va;
 use crate::fixed::Fixed;
 use crate::rebase::rb;
-use crate::render::queue::*;
+use crate::render::message::RenderMessage;
 use crate::render::SpriteOp;
 use crate::task::WeaponAimTask;
 use crate::trig::trig_lookup;
@@ -86,34 +86,31 @@ pub unsafe fn draw_crosshair_line(task: *const WeaponAimTask) {
     let poly_param_1 = ddgame.gfx_color_table[8]; // crosshair line style
     let poly_param_2 = ddgame.gfx_color_table[6]; // crosshair line color
     let verts: [[i32; 3]; 2] = [[start_x, start_y, 0], [endpoint_x, endpoint_y, 0]];
-    let total_size = 2 * 0xC + 0x20;
-    if let Some(ptr) = rq.alloc_raw(total_size) {
-        let header = &mut *(ptr as *mut DrawPolygonHeader);
-        *header = DrawPolygonHeader {
-            command_type: command_type::DRAW_POLYGON,
-            layer: 0xE_0000,
-            count: 2,
-            color1: poly_param_1,
-            color2: poly_param_2,
-        };
-        core::ptr::copy_nonoverlapping(
-            verts.as_ptr() as *const u8,
-            ptr.add(core::mem::size_of::<DrawPolygonHeader>()),
-            2 * 0xC,
+    let byte_len = 2 * core::mem::size_of::<[i32; 3]>();
+    if let Some(vert_ptr) = rq.alloc_aux(byte_len) {
+        core::ptr::copy_nonoverlapping(verts.as_ptr() as *const u8, vert_ptr, byte_len);
+        let _ = rq.push_typed(
+            0xE_0000,
+            RenderMessage::Polygon {
+                count: 2,
+                color1: poly_param_1,
+                color2: poly_param_2,
+                vertices: vert_ptr as *const [i32; 3],
+            },
         );
     }
 
     // Draw crosshair sprite at endpoint (only if no overflow clamping)
     if !overflowed {
-        if let Some(entry) = rq.alloc::<DrawSpriteCmd>() {
-            *entry = DrawSpriteCmd {
-                command_type: command_type::DRAW_SPRITE_LOCAL,
-                layer: 0x4_0000,
+        let _ = rq.push_typed(
+            0x4_0000,
+            RenderMessage::Sprite {
+                local: true,
                 x: Fixed(endpoint_x).floor(),
                 y: Fixed(endpoint_y).floor(),
                 sprite: SpriteOp(0x44),
                 palette: (0x8000u32).wrapping_sub(angle),
-            };
-        }
+            },
+        );
     }
 }

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

@@ -12,8 +12,18 @@
 //! `rq.push_typed(layer, RenderMessage::Xxx { ... })` one at a time.
 //! The dispatcher (`queue_dispatch.rs`) handles both legacy and typed
 //! commands simultaneously until all producers are migrated.
+//!
+//! ## Variable-length commands
+//!
+//! Commands with variable-length data (LineStrip, Polygon) allocate
+//! their vertex arrays separately in the arena via
+//! `RenderQueue::alloc_aux()` and store an explicit pointer in the
+//! enum variant. This avoids layout coupling between the command and
+//! its auxiliary data.
 
+use crate::bitgrid::DisplayBitGrid;
 use crate::fixed::Fixed;
+use crate::render::display::vtable::TiledBitmapSource;
 use crate::render::sprite::sprite_op::SpriteOp;
 
 /// Sentinel `command_type` value for [`TypedRenderCmd`]. Sits outside
@@ -47,11 +57,104 @@ pub enum RenderMessage {
         /// Semantics vary by producer (palette pointer, animation index, etc.).
         palette: u32,
     },
-    // Future variants added here as producers migrate:
-    // FillRect { ... }
-    // Crosshair { ... }
-    // TiledBitmap { ... }
-    // etc.
+
+    /// Replaces legacy type 0 (`DRAW_RECT`).
+    FillRect {
+        color: u32,
+        x1: Fixed,
+        y1: Fixed,
+        x2: Fixed,
+        y2: Fixed,
+        /// Perspective clip reference Z (`cmd[7]` in legacy format).
+        ref_z: i32,
+    },
+
+    /// Replaces legacy type 0xB (`DRAW_CROSSHAIR`).
+    ///
+    /// `ref_z` is always 0 in all known producers — omitted here,
+    /// the dispatcher passes 0 directly.
+    Crosshair {
+        color_fg: u32,
+        color_bg: u32,
+        x: Fixed,
+        y: Fixed,
+    },
+
+    /// Replaces legacy type 0xD (`DRAW_TILED_BITMAP`).
+    TiledBitmap {
+        x: Fixed,
+        y: Fixed,
+        source: *const TiledBitmapSource,
+        /// Bit 0 forces destination X to 0.
+        flags: u8,
+    },
+
+    /// Replaces legacy type 6 (`DRAW_SPRITE_OFFSET`).
+    ///
+    /// `ref_z` (first Z reference) is always 0 in all known producers —
+    /// omitted here, the dispatcher passes 0 directly.
+    SpriteOffset {
+        flags: u32,
+        x: Fixed,
+        y: Fixed,
+        /// Second Z reference for perspective clip (`cmd[6]` in legacy format).
+        ref_z_2: i32,
+        sprite: SpriteOp,
+        palette: u32,
+    },
+
+    /// Replaces legacy type 1 (`DRAW_BITMAP_GLOBAL`).
+    ///
+    /// `src_x` is always 0 in all known producers — omitted here.
+    BitmapGlobal {
+        x: Fixed,
+        y: Fixed,
+        bitmap: *mut DisplayBitGrid,
+        src_y: i32,
+        src_w: i32,
+        src_h: i32,
+        flags: u32,
+    },
+
+    /// Replaces legacy type 2 (`DRAW_TEXTBOX_LOCAL`).
+    ///
+    /// `mode`, `ref_z`, `ref_z_2`, `src_x`, `src_y` are always 0 in
+    /// all known producers — omitted here.
+    TextboxLocal {
+        x: Fixed,
+        y: Fixed,
+        bitmap: *mut DisplayBitGrid,
+        src_w: i32,
+        src_h: i32,
+        flags: u32,
+    },
+
+    /// Replaces legacy type 8 (`DRAW_LINE_STRIP`).
+    ///
+    /// Vertex data is allocated separately via `RenderQueue::alloc_aux()`
+    /// and referenced by the explicit `vertices` pointer.
+    /// Each vertex is `[x: i32, y: i32, z: i32]` in Fixed16.
+    LineStrip {
+        count: u32,
+        color: u32,
+        /// Pointer to `count` vertices in the arena. Allocated via
+        /// `alloc_aux()`, valid for the current frame only.
+        vertices: *const [i32; 3],
+    },
+
+    /// Replaces legacy type 9 (`DRAW_POLYGON`).
+    ///
+    /// Vertex data is allocated separately via `RenderQueue::alloc_aux()`
+    /// and referenced by the explicit `vertices` pointer.
+    /// Each vertex is `[x: i32, y: i32, z: i32]` in Fixed16.
+    Polygon {
+        count: u32,
+        color1: u32,
+        color2: u32,
+        /// Pointer to `count` vertices in the arena. Allocated via
+        /// `alloc_aux()`, valid for the current frame only.
+        vertices: *const [i32; 3],
+    },
 }
 
 /// Wrapper that carries a [`RenderMessage`] inline in the render queue
@@ -66,3 +169,7 @@ pub struct TypedRenderCmd {
     /// The typed payload.
     pub message: RenderMessage,
 }
+
+// Canary for buffer pressure — if this fires, revisit the size budget
+// note in the plan (consider #[repr(u8)] discriminant or variant splitting).
+const _: () = assert!(core::mem::size_of::<TypedRenderCmd>() <= 48);

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

@@ -20,10 +20,7 @@ pub use display::{
 pub use landscape::{DirtyRect, PCLandscape};
 pub use message::{RenderMessage, TypedRenderCmd, COMMAND_TYPE_TYPED};
 pub use opengl::OpenGLState;
-pub use queue::{
-    DrawBitmapGlobalCmd, DrawCrosshairCmd, DrawLineStripHeader, DrawPolygonHeader, DrawRectCmd,
-    DrawSpriteCmd, DrawSpriteOffsetCmd, DrawTextboxLocalCmd, DrawTiledBitmapCmd, RenderQueue,
-};
+pub use queue::RenderQueue;
 pub use sprite::{
     KnownSpriteId, ParsedSprite, Sprite, SpriteBank, SpriteFlags, SpriteFrame, SpriteOp,
 };

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

@@ -1,43 +1,17 @@
-use crate::bitgrid::DisplayBitGrid;
-use crate::fixed::Fixed;
-use crate::render::display::vtable::TiledBitmapSource;
-
 use super::message::{RenderMessage, TypedRenderCmd, COMMAND_TYPE_TYPED};
-use super::sprite::sprite_op::SpriteOp;
-
-/// Render command entry (0x18 bytes).
-///
-/// Enqueued by DrawSpriteGlobal (type 4), DrawSpriteLocal (type 5),
-/// and other drawing functions.
-#[repr(C)]
-pub struct DrawSpriteCmd {
-    /// Command type: 4 = sprite global (world-space), 5 = sprite local (screen-space)
-    pub command_type: u32,
-    pub layer: u32,
-    /// X position (Fixed16, fractional bits always zero — producers floor before storing).
-    pub x: Fixed,
-    /// Y position (Fixed16, fractional bits always zero — producers floor before storing).
-    pub y: Fixed,
-    pub sprite: SpriteOp,
-    /// Palette context — passed to `blit_sprite` as the last arg.
-    /// Semantics vary by producer (palette pointer, animation index, etc.).
-    pub palette: u32,
-}
-
-const _: () = assert!(core::mem::size_of::<DrawSpriteCmd>() == 0x18);
 
-/// Render queue — manages a downward-growing buffer of DrawSpriteCmd entries.
+/// Render queue — manages a downward-growing arena buffer of draw commands.
 ///
-/// Passed as `this` (ECX) to DrawSpriteGlobal/Local. The buffer area sits
-/// between offset 0x04 and the entry metadata at 0x10000+. Entries are
-/// allocated from the end of the buffer downward (offset decrements by 0x18).
+/// Passed as `this` (ECX) to the original DrawSprite*/DrawRect/etc. enqueue
+/// functions. The buffer area sits between offset 0x04 and the entry metadata
+/// at 0x10000+. Entries are allocated from the end of the buffer downward.
 ///
 /// Max 0x800 (2048) entries per frame.
 #[repr(C)]
 pub struct RenderQueue {
-    /// 0x00000: Buffer write offset (i32, decrements by 0x18 per entry)
+    /// 0x00000: Buffer write offset (i32, decrements per allocation)
     pub buffer_offset: i32,
-    /// 0x00004 - 0x10003: Buffer area for DrawSpriteCmd entries
+    /// 0x00004 - 0x10003: Buffer area for command entries (64KB)
     pub _buffer: [u8; 0x10000],
     /// 0x10004: Number of enqueued entries (max 0x800)
     pub entry_count: u32,
@@ -66,9 +40,28 @@ impl RenderQueue {
         Some(entry)
     }
 
+    /// Allocate `size` bytes from the buffer WITHOUT registering an entry pointer.
+    ///
+    /// Used for auxiliary data (vertex arrays, etc.) that will be referenced
+    /// from a typed command via an explicit pointer. Both the aux data and
+    /// the subsequent `push_typed()` command live in the same arena, freed
+    /// together on frame reset.
+    ///
+    /// Unlike `alloc_raw()`, this does NOT consume an `entry_ptrs` slot or
+    /// increment `entry_count`.
+    pub unsafe fn alloc_aux(&mut self, size: usize) -> Option<*mut u8> {
+        let new_offset = self.buffer_offset - size as i32;
+        if new_offset < 0 {
+            return None;
+        }
+        self.buffer_offset = new_offset;
+        Some(self._buffer.as_mut_ptr().add(new_offset as usize))
+    }
+
     /// Allocate `size` bytes from the downward-growing buffer.
     ///
-    /// Like `alloc<T>()` but for variable-size entries (e.g. DrawLineStrip, DrawPolygon).
+    /// Like `alloc<T>()` but for variable-size entries (e.g. legacy commands
+    /// still enqueued by unported WA.exe code).
     /// Returns `None` if the queue is full or buffer exhausted.
     pub unsafe fn alloc_raw(&mut self, size: usize) -> Option<*mut u8> {
         if self.entry_count >= 0x800 {
@@ -85,171 +78,7 @@ impl RenderQueue {
         self.entry_count += 1;
         Some(ptr)
     }
-}
-
-/// 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 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: Fixed,
-    /// 0x0C: Source Y coordinate (Fixed16). Caller-supplied; goes through
-    /// `RQ_ClipCoordinates` and the high 16 bits become the destination Y.
-    pub y: Fixed,
-    /// 0x10: Pointer to a [`TiledBitmapSource`] descriptor — read by the
-    /// slot 11 method with fields at `+0x08` (bpp, 8 or 0x40), `+0x10`
-    /// (source row stride), `+0x14`, and `+0x18` (total source height).
-    pub source: *const TiledBitmapSource,
-    /// 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::<DrawTiledBitmapCmd>() == 0x18);
-
-/// Type 0xB — draw crosshair (0x1C = 28 bytes).
-///
-/// Dispatched by RenderDrawingQueue case 0xB → DisplayGfx::draw_crosshair (slot 16).
-/// The enqueue function at 0x541ED0 writes fields in non-sequential order:
-/// `[1]=layer, [4]=x, [5]=y, [2]=color_fg, [3]=color_bg, [6]=0`.
-#[repr(C)]
-pub struct DrawCrosshairCmd {
-    pub command_type: u32, // 0xB
-    pub layer: u32,
-    pub color_fg: u32,
-    pub color_bg: u32,
-    pub x: Fixed,
-    pub y: Fixed,
-    pub ref_z: i32, // hardcoded 0 (perspective clip reference Z)
-}
-
-const _: () = assert!(core::mem::size_of::<DrawCrosshairCmd>() == 0x1C);
 
-/// Type 0 — filled rectangle (0x20 = 32 bytes).
-#[repr(C)]
-pub struct DrawRectCmd {
-    pub command_type: u32, // 0
-    pub layer: u32,
-    pub color: u32,
-    pub x1: Fixed,
-    pub y1: Fixed,
-    pub x2: Fixed,
-    pub y2: Fixed,
-    pub ref_z: i32, // perspective clip reference Z (EDX & 0xFFFF0000)
-}
-
-const _: () = assert!(core::mem::size_of::<DrawRectCmd>() == 0x20);
-
-/// Type 6 — sprite with offset/scaling (0x24 = 36 bytes).
-#[repr(C)]
-pub struct DrawSpriteOffsetCmd {
-    pub command_type: u32, // 6
-    pub layer: u32,
-    pub flags: u32,
-    pub x: Fixed,
-    pub y: Fixed,
-    pub ref_z: i32,   // first Z reference for perspective clip (hardcoded 0)
-    pub ref_z_2: i32, // second Z reference (EDX & 0xFFFF0000)
-    pub sprite: SpriteOp,
-    pub palette: u32,
-}
-
-const _: () = assert!(core::mem::size_of::<DrawSpriteOffsetCmd>() == 0x24);
-
-/// Type 1 — bitmap global (0x28 = 40 bytes).
-#[repr(C)]
-pub struct DrawBitmapGlobalCmd {
-    pub command_type: u32, // 1
-    pub layer: u32,
-    pub x: Fixed,
-    pub y: Fixed,
-    pub bitmap: *mut DisplayBitGrid,
-    pub src_x: i32, // hardcoded 0
-    pub src_y: i32,
-    pub src_w: i32,
-    pub src_h: i32,
-    pub flags: u32,
-}
-
-const _: () = assert!(core::mem::size_of::<DrawBitmapGlobalCmd>() == 0x28);
-
-/// Type 2 — textbox local (0x34 = 52 bytes).
-#[repr(C)]
-pub struct DrawTextboxLocalCmd {
-    pub command_type: u32, // 2
-    pub layer: u32,
-    pub mode: u32,
-    pub x: Fixed,
-    pub y: Fixed,
-    pub ref_z: i32,   // perspective clip reference Z (hardcoded 0)
-    pub ref_z_2: i32, // second Z reference (hardcoded 0)
-    pub bitmap: *mut DisplayBitGrid,
-    pub src_x: i32, // hardcoded 0
-    pub src_y: i32, // hardcoded 0
-    pub src_w: i32,
-    pub src_h: i32,
-    pub flags: u32,
-}
-
-const _: () = assert!(core::mem::size_of::<DrawTextboxLocalCmd>() == 0x34);
-
-/// Type 8 — line strip header (0x10 bytes, followed by count × 0xC vertex data).
-///
-/// Total allocation: count × 0xC + 0x1C.
-#[repr(C)]
-pub struct DrawLineStripHeader {
-    pub command_type: u32, // 8
-    pub layer: u32,        // hardcoded 0xE_0000
-    pub count: u32,        // vertex count (from EDI)
-    pub color: u32,        // line color
-}
-
-const _: () = assert!(core::mem::size_of::<DrawLineStripHeader>() == 0x10);
-
-/// Type 9 — polygon header (0x14 bytes, followed by count × 0xC vertex data).
-///
-/// Total allocation: count × 0xC + 0x20.
-#[repr(C)]
-pub struct DrawPolygonHeader {
-    pub command_type: u32, // 9
-    pub layer: u32,        // hardcoded 0xE_0000
-    pub count: u32,        // vertex count (from ESI)
-    pub color1: u32,       // line color 1
-    pub color2: u32,       // line color 2
-}
-
-const _: () = assert!(core::mem::size_of::<DrawPolygonHeader>() == 0x14);
-
-impl RenderQueue {
     /// Enqueue a typed render message. Constant-time, zero allocation —
     /// the message is stored inline in the existing per-frame buffer.
     ///
@@ -272,20 +101,3 @@ impl RenderQueue {
         }
     }
 }
-
-/// Render command type constants.
-pub mod command_type {
-    pub const DRAW_RECT: u32 = 0;
-    pub const DRAW_BITMAP_GLOBAL: u32 = 1;
-    pub const DRAW_TEXTBOX_LOCAL: u32 = 2;
-    pub const DRAW_SPRITE_GLOBAL: u32 = 4;
-    pub const DRAW_SPRITE_LOCAL: u32 = 5;
-    pub const DRAW_SPRITE_OFFSET: u32 = 6;
-    pub const DRAW_LINE_STRIP: u32 = 8;
-    pub const DRAW_POLYGON: u32 = 9;
-    pub const DRAW_CROSSHAIR: u32 = 0xB;
-    pub const DRAW_OUTLINED_PIXEL: u32 = 0xC;
-    /// 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-core/src/render/queue_dispatch.rs

@@ -935,16 +935,258 @@ unsafe fn dispatch_typed(display: *mut DisplayGfx, clip: &ClipContext, msg: &Ren
             palette,
         } => {
             if local {
-                // Screen-space: apply camera translation (same as case 5).
                 let mut out_x = Fixed::ZERO;
                 let mut out_y = Fixed::ZERO;
                 rq_translate_coordinates(clip, x, y, &mut out_x, &mut out_y);
                 DisplayGfx::blit_sprite_raw(display, out_x, out_y, sprite, palette);
             } else {
-                // World-space: pass through directly (same as case 4).
                 DisplayGfx::blit_sprite_raw(display, x, y, sprite, palette);
             }
         }
+
+        RenderMessage::FillRect {
+            color,
+            x1,
+            y1,
+            x2,
+            y2,
+            ref_z,
+        } => {
+            let mut ox1 = Fixed::ZERO;
+            let mut oy1 = Fixed::ZERO;
+            let mut ox2 = Fixed::ZERO;
+            let mut oy2 = Fixed::ZERO;
+            let mut scale = Fixed::ZERO;
+            if !rq_clip_coordinates(clip, x1, y1, ref_z, &mut ox1, &mut oy1, &mut scale) {
+                return;
+            }
+            if !rq_clip_coordinates(clip, x2, y2, ref_z, &mut ox2, &mut oy2, &mut scale) {
+                return;
+            }
+            // Sentinel clamps for "infinite" screen-space rectangles.
+            if x1.0 == i32::MIN {
+                ox1 = Fixed(i32::MIN);
+            }
+            if y1.0 == i32::MIN {
+                oy1 = Fixed(i32::MIN);
+            }
+            if x2.0 == 0x7FFF_0000 {
+                ox2 = Fixed(i32::MAX);
+            }
+            if y2.0 == 0x7FFF_0000 {
+                oy2 = Fixed(i32::MAX);
+            }
+            DisplayGfx::fill_rect_raw(
+                display,
+                ox1.to_int(),
+                oy1.to_int(),
+                ox2.to_int(),
+                oy2.to_int(),
+                color,
+            );
+        }
+
+        RenderMessage::Crosshair {
+            color_fg,
+            color_bg,
+            x,
+            y,
+        } => {
+            let mut ox = Fixed::ZERO;
+            let mut oy = Fixed::ZERO;
+            let mut scale = Fixed::ZERO;
+            if !rq_clip_coordinates(clip, x, y, 0, &mut ox, &mut oy, &mut scale) {
+                return;
+            }
+            DisplayGfx::draw_crosshair_raw(display, ox.to_int(), oy.to_int(), color_fg, color_bg);
+        }
+
+        RenderMessage::TiledBitmap {
+            x,
+            y,
+            source,
+            flags,
+        } => {
+            let mut ox = Fixed::ZERO;
+            let mut oy = Fixed::ZERO;
+            let mut scale = Fixed::ZERO;
+            if !rq_clip_coordinates(clip, Fixed::ZERO, x, y.0, &mut ox, &mut oy, &mut scale) {
+                return;
+            }
+            let dest_x = if flags & 1 != 0 { 0 } else { ox.to_int() };
+            DisplayGfx::draw_tiled_bitmap_raw(display, dest_x, oy.to_int(), source);
+        }
+
+        RenderMessage::SpriteOffset {
+            flags,
+            x,
+            y,
+            ref_z_2,
+            sprite,
+            palette,
+        } => {
+            let mut ox = Fixed::ZERO;
+            let mut oy = Fixed::ZERO;
+            let mut scale = Fixed::ZERO;
+
+            if flags == 0 {
+                rq_translate_coordinates(clip, x, y, &mut ox, &mut oy);
+            } else {
+                let use_pivot = (flags & 4) != 0;
+                let clip_fn: fn(
+                    &ClipContext,
+                    Fixed,
+                    Fixed,
+                    i32,
+                    &mut Fixed,
+                    &mut Fixed,
+                    &mut Fixed,
+                ) -> bool = if use_pivot {
+                    rq_clip_coordinates_with_ref
+                } else {
+                    rq_clip_coordinates
+                };
+                // ref_z (first Z reference) is always 0.
+                if !clip_fn(clip, x, y, 0, &mut ox, &mut oy, &mut scale) {
+                    return;
+                }
+                let mut ox2 = Fixed::ZERO;
+                let mut oy2 = Fixed::ZERO;
+                if !clip_fn(clip, x, y, ref_z_2, &mut ox2, &mut oy2, &mut scale) {
+                    return;
+                }
+                if flags & 1 != 0 {
+                    ox = ox2;
+                }
+                if flags & 2 != 0 {
+                    oy = oy2;
+                }
+            }
+
+            DisplayGfx::blit_sprite_raw(display, ox, oy, sprite, palette);
+        }
+
+        RenderMessage::BitmapGlobal {
+            x,
+            y,
+            bitmap,
+            src_y,
+            src_w,
+            src_h,
+            flags,
+        } => {
+            // src_x is always 0 in all known producers.
+            DisplayGfx::draw_scaled_sprite_raw(
+                display, x, y, bitmap, 0, src_y, src_w, src_h, flags,
+            );
+        }
+
+        RenderMessage::TextboxLocal {
+            x,
+            y,
+            bitmap,
+            src_w,
+            src_h,
+            flags,
+        } => {
+            // mode is always 0, so simple one-clip path.
+            // ref_z is always 0.
+            let mut ox = Fixed::ZERO;
+            let mut oy = Fixed::ZERO;
+            let mut scale = Fixed::ZERO;
+            if !rq_clip_coordinates(clip, x, y, 0, &mut ox, &mut oy, &mut scale) {
+                return;
+            }
+            // src_x and src_y are always 0.
+            DisplayGfx::draw_scaled_sprite_raw(display, ox, oy, bitmap, 0, 0, src_w, src_h, flags);
+        }
+
+        RenderMessage::LineStrip {
+            count,
+            color,
+            vertices,
+        } => {
+            if count <= 1 {
+                return;
+            }
+            let verts = core::slice::from_raw_parts(vertices, count as usize);
+            let mut x1 = Fixed::ZERO;
+            let mut y1 = Fixed::ZERO;
+            let mut scale = Fixed::ZERO;
+            if !rq_clip_coordinates(
+                clip,
+                Fixed::from_raw(verts[0][0]),
+                Fixed::from_raw(verts[0][1]),
+                verts[0][2],
+                &mut x1,
+                &mut y1,
+                &mut scale,
+            ) {
+                return;
+            }
+            for v in &verts[1..] {
+                let mut x2 = Fixed::ZERO;
+                let mut y2 = Fixed::ZERO;
+                if !rq_clip_coordinates(
+                    clip,
+                    Fixed::from_raw(v[0]),
+                    Fixed::from_raw(v[1]),
+                    v[2],
+                    &mut x2,
+                    &mut y2,
+                    &mut scale,
+                ) {
+                    break;
+                }
+                DisplayGfx::draw_line_clipped_raw(display, x1, y1, x2, y2, color);
+                x1 = x2;
+                y1 = y2;
+            }
+        }
+
+        RenderMessage::Polygon {
+            count,
+            color1,
+            color2,
+            vertices,
+        } => {
+            if count <= 1 {
+                return;
+            }
+            let verts = core::slice::from_raw_parts(vertices, count as usize);
+            let mut x1 = Fixed::ZERO;
+            let mut y1 = Fixed::ZERO;
+            let mut scale = Fixed::ZERO;
+            if !rq_clip_coordinates(
+                clip,
+                Fixed::from_raw(verts[0][0]),
+                Fixed::from_raw(verts[0][1]),
+                verts[0][2],
+                &mut x1,
+                &mut y1,
+                &mut scale,
+            ) {
+                return;
+            }
+            for v in &verts[1..] {
+                let mut x2 = Fixed::ZERO;
+                let mut y2 = Fixed::ZERO;
+                if !rq_clip_coordinates(
+                    clip,
+                    Fixed::from_raw(v[0]),
+                    Fixed::from_raw(v[1]),
+                    v[2],
+                    &mut x2,
+                    &mut y2,
+                    &mut scale,
+                ) {
+                    break;
+                }
+                DisplayGfx::draw_line_raw(display, x1, y1, x2, y2, color1, color2);
+                x1 = x2;
+                y1 = y2;
+            }
+        }
     }
 }
 

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

@@ -5,7 +5,8 @@ use openwa_core::bitgrid::DisplayBitGrid;
 use openwa_core::fixed::Fixed;
 use openwa_core::render::display::vtable::TiledBitmapSource;
 use openwa_core::render::display::DisplayGfx;
-use openwa_core::render::queue::*;
+use openwa_core::render::message::RenderMessage;
+use openwa_core::render::queue::RenderQueue;
 use openwa_core::render::queue_dispatch::{render_drawing_queue, ClipContext};
 use openwa_core::render::SpriteOp;
 use openwa_core::task::{BungeeTrailTask, WeaponAimTask};
@@ -23,20 +24,18 @@ unsafe extern "cdecl" fn enqueue_tiled_bitmap_impl(
     source: *const TiledBitmapSource,
     flags: u32,
 ) {
-    if let Some(entry) = (*queue).alloc::<DrawTiledBitmapCmd>() {
-        *entry = DrawTiledBitmapCmd {
-            command_type: command_type::DRAW_TILED_BITMAP,
-            layer: 0x1B_0000,
+    let _ = (*queue).push_typed(
+        0x1B_0000,
+        RenderMessage::TiledBitmap {
             x: Fixed(0xFF00_0000u32 as i32),
             y,
             source,
             flags: flags as u8,
-            _pad: [0; 3],
-        };
-    }
+        },
+    );
 }
 
-// DrawLineStrip (0x541DD0) — variable-size allocation: count * 0xC + 0x1C
+// DrawLineStrip (0x541DD0) — variable-size: vertex data via alloc_aux
 
 usercall_trampoline!(fn trampoline_draw_line_strip; impl_fn = draw_line_strip_impl;
     regs = [eax, edi]; stack_params = 2; ret_bytes = "0x8");
@@ -44,28 +43,25 @@ usercall_trampoline!(fn trampoline_draw_line_strip; impl_fn = draw_line_strip_im
 unsafe extern "cdecl" fn draw_line_strip_impl(
     queue: *mut RenderQueue,
     count: u32,
-    vertices: *const u8,
+    vertices: *const [i32; 3],
     color: u32,
 ) {
-    let total_size = count as usize * 0xC + 0x1C;
-
-    if let Some(ptr) = (*queue).alloc_raw(total_size) {
-        let header = &mut *(ptr as *mut DrawLineStripHeader);
-        *header = DrawLineStripHeader {
-            command_type: command_type::DRAW_LINE_STRIP,
-            layer: 0xE_0000,
-            count,
-            color,
-        };
-        core::ptr::copy_nonoverlapping(
-            vertices,
-            ptr.add(core::mem::size_of::<DrawLineStripHeader>()),
-            count as usize * 0xC,
+    let rq = &mut *queue;
+    let byte_len = count as usize * core::mem::size_of::<[i32; 3]>();
+    if let Some(vert_ptr) = rq.alloc_aux(byte_len) {
+        core::ptr::copy_nonoverlapping(vertices as *const u8, vert_ptr, byte_len);
+        let _ = rq.push_typed(
+            0xE_0000,
+            RenderMessage::LineStrip {
+                count,
+                color,
+                vertices: vert_ptr as *const [i32; 3],
+            },
         );
     }
 }
 
-// DrawPolygon (0x541E50) — variable-size allocation: count * 0xC + 0x20
+// DrawPolygon (0x541E50) — variable-size: vertex data via alloc_aux
 
 usercall_trampoline!(fn trampoline_draw_polygon; impl_fn = draw_polygon_impl;
     regs = [ecx, esi]; stack_params = 3; ret_bytes = "0xC");
@@ -73,25 +69,22 @@ usercall_trampoline!(fn trampoline_draw_polygon; impl_fn = draw_polygon_impl;
 unsafe extern "cdecl" fn draw_polygon_impl(
     queue: *mut RenderQueue,
     count: u32,
-    vertices: *const u8,
+    vertices: *const [i32; 3],
     color1: u32,
     color2: u32,
 ) {
-    let total_size = count as usize * 0xC + 0x20;
-
-    if let Some(ptr) = (*queue).alloc_raw(total_size) {
-        let header = &mut *(ptr as *mut DrawPolygonHeader);
-        *header = DrawPolygonHeader {
-            command_type: command_type::DRAW_POLYGON,
-            layer: 0xE_0000,
-            count,
-            color1,
-            color2,
-        };
-        core::ptr::copy_nonoverlapping(
-            vertices,
-            ptr.add(core::mem::size_of::<DrawPolygonHeader>()),
-            count as usize * 0xC,
+    let rq = &mut *queue;
+    let byte_len = count as usize * core::mem::size_of::<[i32; 3]>();
+    if let Some(vert_ptr) = rq.alloc_aux(byte_len) {
+        core::ptr::copy_nonoverlapping(vertices as *const u8, vert_ptr, byte_len);
+        let _ = rq.push_typed(
+            0xE_0000,
+            RenderMessage::Polygon {
+                count,
+                color1,
+                color2,
+                vertices: vert_ptr as *const [i32; 3],
+            },
         );
     }
 }
@@ -109,17 +102,15 @@ unsafe extern "cdecl" fn draw_crosshair_impl(
     color_fg: u32,
     color_bg: u32,
 ) {
-    if let Some(entry) = (*queue).alloc::<DrawCrosshairCmd>() {
-        *entry = DrawCrosshairCmd {
-            command_type: command_type::DRAW_CROSSHAIR,
-            layer,
+    let _ = (*queue).push_typed(
+        layer,
+        RenderMessage::Crosshair {
             color_fg,
             color_bg,
             x,
             y,
-            ref_z: 0,
-        };
-    }
+        },
+    );
 }
 
 // DrawRect (0x541F40)
@@ -137,18 +128,17 @@ unsafe extern "cdecl" fn draw_rect_impl(
     y2: Fixed,
     color: u32,
 ) {
-    if let Some(entry) = (*queue).alloc::<DrawRectCmd>() {
-        *entry = DrawRectCmd {
-            command_type: command_type::DRAW_RECT,
-            layer,
+    let _ = (*queue).push_typed(
+        layer,
+        RenderMessage::FillRect {
             color,
             x1: x1.floor(),
             y1: y1.floor(),
             x2: x2.floor(),
             y2: y2.floor(),
             ref_z: y_clip.floor().0,
-        };
-    }
+        },
+    );
 }
 
 // DrawSpriteGlobal (0x541FE0)
@@ -164,16 +154,16 @@ unsafe extern "cdecl" fn draw_sprite_global_impl(
     sprite: SpriteOp,
     frame: u32,
 ) {
-    if let Some(entry) = (*queue).alloc::<DrawSpriteCmd>() {
-        *entry = DrawSpriteCmd {
-            command_type: command_type::DRAW_SPRITE_GLOBAL,
-            layer,
+    let _ = (*queue).push_typed(
+        layer,
+        RenderMessage::Sprite {
+            local: false,
             x: x_pos.floor(),
             y: y_pos.floor(),
             sprite,
             palette: frame,
-        };
-    }
+        },
+    );
 }
 
 // DrawSpriteLocal (0x542060)
@@ -189,16 +179,16 @@ unsafe extern "cdecl" fn draw_sprite_local_impl(
     sprite: SpriteOp,
     frame: u32,
 ) {
-    if let Some(entry) = (*queue).alloc::<DrawSpriteCmd>() {
-        *entry = DrawSpriteCmd {
-            command_type: command_type::DRAW_SPRITE_LOCAL,
-            layer,
+    let _ = (*queue).push_typed(
+        layer,
+        RenderMessage::Sprite {
+            local: true,
             x: x_pos.floor(),
             y: y_pos.floor(),
             sprite,
             palette: frame,
-        };
-    }
+        },
+    );
 }
 
 // DrawSpriteOffset (0x5420E0)
@@ -216,19 +206,17 @@ unsafe extern "cdecl" fn draw_sprite_offset_impl(
     sprite: SpriteOp,
     palette: u32,
 ) {
-    if let Some(entry) = (*queue).alloc::<DrawSpriteOffsetCmd>() {
-        *entry = DrawSpriteOffsetCmd {
-            command_type: command_type::DRAW_SPRITE_OFFSET,
-            layer,
+    let _ = (*queue).push_typed(
+        layer,
+        RenderMessage::SpriteOffset {
             flags,
             x: x_pos.floor(),
             y: y_pos.floor(),
-            ref_z: 0,
             ref_z_2: y_clip.floor().0,
             sprite,
             palette,
-        };
-    }
+        },
+    );
 }
 
 // DrawBitmapGlobal (0x542170)
@@ -247,20 +235,18 @@ unsafe extern "cdecl" fn draw_bitmap_global_impl(
     src_h: i32,
     flags: u32,
 ) {
-    if let Some(entry) = (*queue).alloc::<DrawBitmapGlobalCmd>() {
-        *entry = DrawBitmapGlobalCmd {
-            command_type: command_type::DRAW_BITMAP_GLOBAL,
-            layer,
+    let _ = (*queue).push_typed(
+        layer,
+        RenderMessage::BitmapGlobal {
             x: x_pos.floor(),
             y: y_pos.floor(),
             bitmap,
-            src_x: 0,
             src_y,
             src_w,
             src_h,
             flags,
-        };
-    }
+        },
+    );
 }
 
 // DrawTextboxLocal (0x542200)
@@ -278,23 +264,17 @@ unsafe extern "cdecl" fn draw_textbox_local_impl(
     src_h: i32,
     flags: u32,
 ) {
-    if let Some(entry) = (*q).alloc::<DrawTextboxLocalCmd>() {
-        *entry = DrawTextboxLocalCmd {
-            command_type: command_type::DRAW_TEXTBOX_LOCAL,
-            layer,
-            mode: 0,
+    let _ = (*q).push_typed(
+        layer,
+        RenderMessage::TextboxLocal {
             x: x_pos.floor(),
             y: y_pos.floor(),
-            ref_z: 0,
-            ref_z_2: 0,
             bitmap,
-            src_x: 0,
-            src_y: 0,
             src_w,
             src_h,
             flags,
-        };
-    }
+        },
+    );
 }
 
 // DrawBungeeTrail (0x500720)