refactor: add DDDisplayVtable, replace inline vtable dispatch

Create DDDisplayVtable (38 slots) with typed methods for the 5 slots
used in the DDGame constructor:
- set_layer_color (slot 4)
- set_active_layer (slot 5)
- set_layer_visibility (slot 23)
- load_sprite (slot 31)
- load_sprite_by_layer (slot 37)

Methods take *mut DDDisplay (not &self) to avoid UB from creating
mutable pointers from shared references.

Replaces ~15 inline transmute + vtable[N] patterns with typed calls
like DDDisplay::set_layer_color(disp, 1, 0xFE).

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

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

@@ -1,16 +1,151 @@
 /// DDDisplay — display/rendering subsystem.
 ///
 /// Constructor: DDDisplay__Init (0x569D00).
-/// Vtable: 0x66A218.
+/// Vtable: 0x66A218 (38 known slots).
 /// Destructor: FUN_00569CE0.
 ///
 /// Manages display mode, dimensions, palette, and HWND.
 /// Contains DrawTextOnBitmap (thiscall) and ConstructTextbox methods.
 /// The OpenGL context (HDC, HGLRC) is also stored here when GL mode is active.
 ///
-/// OPAQUE: Size not yet determined. Only vtable pointer defined.
+/// OPAQUE: Full struct size not yet determined. Only vtable pointer defined.
 #[repr(C)]
 pub struct DDDisplay {
     /// 0x000: Vtable pointer (0x66A218)
-    pub vtable: *mut u8,
+    pub vtable: *const DDDisplayVtable,
+}
+
+/// DDDisplay vtable (0x66A218, 38 slots).
+///
+/// Only actively-used slots have typed signatures. Unknown slots are `usize`.
+/// Follows the DSSoundVtable pattern: all slots defined, unknowns as stubs.
+#[repr(C)]
+pub struct DDDisplayVtable {
+    /// Slot 0: destructor
+    pub _slot_00: usize,
+    /// Slot 1
+    pub _slot_01: usize,
+    /// Slot 2
+    pub _slot_02: usize,
+    /// Slot 3
+    pub _slot_03: usize,
+    /// Slot 4: set layer color — thiscall(this, layer, color)
+    pub set_layer_color: unsafe extern "thiscall" fn(*mut DDDisplay, i32, i32),
+    /// Slot 5: set active layer — thiscall(this, layer) -> layer context ptr
+    pub set_active_layer: unsafe extern "thiscall" fn(*mut DDDisplay, i32) -> *mut u8,
+    /// Slot 6
+    pub _slot_06: usize,
+    /// Slot 7
+    pub _slot_07: usize,
+    /// Slot 8
+    pub _slot_08: usize,
+    /// Slot 9
+    pub _slot_09: usize,
+    /// Slot 10
+    pub _slot_10: usize,
+    /// Slot 11
+    pub _slot_11: usize,
+    /// Slot 12
+    pub _slot_12: usize,
+    /// Slot 13
+    pub _slot_13: usize,
+    /// Slot 14
+    pub _slot_14: usize,
+    /// Slot 15
+    pub _slot_15: usize,
+    /// Slot 16
+    pub _slot_16: usize,
+    /// Slot 17
+    pub _slot_17: usize,
+    /// Slot 18
+    pub _slot_18: usize,
+    /// Slot 19
+    pub _slot_19: usize,
+    /// Slot 20
+    pub _slot_20: usize,
+    /// Slot 21
+    pub _slot_21: usize,
+    /// Slot 22
+    pub _slot_22: usize,
+    /// Slot 23 (0x5C): set layer visibility — thiscall(this, layer, value)
+    pub set_layer_visibility: unsafe extern "thiscall" fn(*mut DDDisplay, i32, i32),
+    /// Slot 24
+    pub _slot_24: usize,
+    /// Slot 25
+    pub _slot_25: usize,
+    /// Slot 26
+    pub _slot_26: usize,
+    /// Slot 27
+    pub _slot_27: usize,
+    /// Slot 28
+    pub _slot_28: usize,
+    /// Slot 29
+    pub _slot_29: usize,
+    /// Slot 30
+    pub _slot_30: usize,
+    /// Slot 31 (0x7C): load sprite with flag — thiscall(this, layer, id, flag, gfx, name), RET 0x14
+    pub load_sprite:
+        unsafe extern "thiscall" fn(*mut DDDisplay, u32, u32, u32, *mut u8, *const u8) -> i32,
+    /// Slot 32
+    pub _slot_32: usize,
+    /// Slot 33
+    pub _slot_33: usize,
+    /// Slot 34
+    pub _slot_34: usize,
+    /// Slot 35
+    pub _slot_35: usize,
+    /// Slot 36
+    pub _slot_36: usize,
+    /// Slot 37 (0x94): load sprite by layer — thiscall(this, layer, id, gfx, name), RET 0x10
+    pub load_sprite_by_layer:
+        unsafe extern "thiscall" fn(*mut DDDisplay, u32, u32, *mut u8, *const u8) -> i32,
+}
+
+const _: () = assert!(core::mem::size_of::<DDDisplayVtable>() == 38 * 4);
+
+/// Typed wrappers for DDDisplay vtable calls.
+/// All take `*mut DDDisplay` since thiscall passes `this` as mutable.
+impl DDDisplay {
+    /// Vtable slot 5: set active display layer, returns layer context pointer.
+    #[inline]
+    pub unsafe fn set_active_layer(this: *mut Self, layer: i32) -> *mut u8 {
+        ((*(*this).vtable).set_active_layer)(this, layer)
+    }
+
+    /// Vtable slot 4: set color for a display layer.
+    #[inline]
+    pub unsafe fn set_layer_color(this: *mut Self, layer: i32, color: i32) {
+        ((*(*this).vtable).set_layer_color)(this, layer, color)
+    }
+
+    /// Vtable slot 23: set layer visibility.
+    #[inline]
+    pub unsafe fn set_layer_visibility(this: *mut Self, layer: i32, value: i32) {
+        ((*(*this).vtable).set_layer_visibility)(this, layer, value)
+    }
+
+    /// Vtable slot 37: load sprite into a layer by name.
+    #[inline]
+    pub unsafe fn load_sprite_by_layer(
+        this: *mut Self,
+        layer: u32,
+        id: u32,
+        gfx: *mut u8,
+        name: *const u8,
+    ) -> i32 {
+        ((*(*this).vtable).load_sprite_by_layer)(this, layer, id, gfx, name)
+    }
+
+    /// Vtable slot 31: load sprite with flag.
+    #[inline]
+    pub unsafe fn load_sprite(
+        this: *mut Self,
+        layer: u32,
+        id: u32,
+        flag: u32,
+        gfx: *mut u8,
+        name: *const u8,
+    ) -> i32 {
+        ((*(*this).vtable).load_sprite)(this, layer, id, flag, gfx, name)
+    }
 }

crates/openwa-core/src/engine/ddgame.rs

@@ -526,15 +526,10 @@ pub unsafe fn display_layer_color_init(wrapper: *mut DDGameWrapper) {
         5 + 0x69 // = 0x6E
     };
 
-    let display = (*wrapper).display as *mut u8;
-    let vt = *(display as *const *const u32);
-    // vtable[4]: set layer color
-    let set_color: unsafe extern "thiscall" fn(*mut u8, i32, i32) =
-        core::mem::transmute(*vt.add(4));
-
-    set_color(display, 1, layer1_color);
-    set_color(display, 2, 0x20);
-    set_color(display, 3, 0x70);
+    let display = (*wrapper).display;
+    DDDisplay::set_layer_color(display, 1, layer1_color);
+    DDDisplay::set_layer_color(display, 2, 0x20);
+    DDDisplay::set_layer_color(display, 3, 0x70);
 }
 
 /// Initialize runtime addresses for the constructor bridges.
@@ -844,22 +839,18 @@ unsafe fn init_graphics_and_resources(
         if *(rb(va::G_DISPLAY_MODE_FLAG) as *const u8) == 0 {
             call_usercall_eax(wrapper, FUN_570A90_ADDR);
         }
-        // Read display (may be modified by FUN_00570A90).
-        let disp = (*wrapper).display as *mut u8;
+        let disp = (*wrapper).display;
         let gfx_handler = (*wrapper)._field_4c0;
-        let vt = *(disp as *const *const u32);
-        // vtable[4]: set palette range
-        let vt_10: unsafe extern "thiscall" fn(*mut u8, i32, i32) =
-            core::mem::transmute(*vt.add(4));
-        vt_10(disp, 1, 0xFE);
-        // vtable[0x1F]: init palette layer
-        let vt_7c: unsafe extern "thiscall" fn(*mut u8, i32, i32, i32, *mut u8, u32) =
-            core::mem::transmute(*vt.add(0x1F));
-        vt_7c(disp, 1, 1, 0, gfx_handler, rb(va::STR_CDROM_SPR));
-        // vtable[0x17]: set layer visibility
-        let vt_5c: unsafe extern "thiscall" fn(*mut u8, i32, i32) =
-            core::mem::transmute(*vt.add(0x17));
-        vt_5c(disp, 1, -100);
+        DDDisplay::set_layer_color(disp, 1, 0xFE);
+        DDDisplay::load_sprite(
+            disp,
+            1,
+            1,
+            0,
+            gfx_handler,
+            rb(va::STR_CDROM_SPR) as *const u8,
+        );
+        DDDisplay::set_layer_visibility(disp, 1, -100);
 
         // Palette slot range init
         let palette_range_ptr = *(disp.add(0x3120) as *const *mut i16);
@@ -883,12 +874,7 @@ unsafe fn init_graphics_and_resources(
     // ── Display vtable slot 5 (offset 0x14) ──
     // Original: CALL EAX (vtable[5]), saves return value in ESI for use as
     // the `output` parameter in the color-entries GfxResource__Create call below.
-    let layer_ctx = {
-        let vt = *((*ddgame).display as *const *const u32);
-        let f: unsafe extern "thiscall" fn(*mut DDDisplay, i32) -> *mut u8 =
-            core::mem::transmute(*vt.add(5));
-        f((*ddgame).display, 1)
-    };
+    let layer_ctx = DDDisplay::set_active_layer((*ddgame).display, 1);
 
     // ── GfxDir color entries DDGame+0x730C..0x732C ──
     if (*wrapper).gfx_mode != 0 {
@@ -1076,11 +1062,7 @@ unsafe fn init_graphics_and_resources(
             name_buf[5] = b'0' + (i / 10) as u8;
             name_buf[6] = b'0' + (i % 10) as u8;
 
-            // Display vtable[5](1) — set active layer, returns context ptr
-            let disp_vt = *((*ddgame).display as *const *const u32);
-            let set_layer: unsafe extern "thiscall" fn(*mut DDDisplay, i32) -> *mut u8 =
-                core::mem::transmute(*disp_vt.add(5));
-            let layer_ctx = set_layer((*ddgame).display, 1);
+            let layer_ctx = DDDisplay::set_active_layer((*ddgame).display, 1);
 
             let entry = gfx_dir_find_entry(name_buf.as_ptr(), gfx_handler);
 
@@ -1267,37 +1249,16 @@ unsafe fn init_graphics_and_resources(
             0x2F4,
         );
 
-        // Display vtable[5](3) — set active layer 3, returns context ptr
-        let disp_vt = *((*ddgame).display as *const *const u32);
-        let set_layer: unsafe extern "thiscall" fn(*mut DDDisplay, i32) -> *mut u8 =
-            core::mem::transmute(*disp_vt.add(5));
-        let _layer3_ctx = set_layer((*ddgame).display, 3);
+        let disp = (*wrapper).display;
+        DDDisplay::set_active_layer(disp, 3);
 
-        // Load back.spr and debris.spr (conditional)
-        let disp_obj = (*wrapper).display as *mut u8;
-        let disp_obj_vt = *(disp_obj as *const *const u32);
-        // Check if gfx_mode high byte is set (original: uStack_123c._3_1_ != '\0')
         if (*wrapper).gfx_mode != 0 {
-            let load_spr_94: unsafe extern "thiscall" fn(*mut u8, u32, u32, *mut u8, *const u8) =
-                core::mem::transmute(*disp_obj_vt.add(0x94 / 4));
-            load_spr_94(disp_obj, 3, 0x26D, land_layer, b"back.spr\0".as_ptr());
-
-            let load_spr_7c: unsafe extern "thiscall" fn(
-                *mut u8,
-                u32,
-                u32,
-                u32,
-                *mut u8,
-                *const u8,
-            ) = core::mem::transmute(*disp_obj_vt.add(0x7C / 4));
-            load_spr_7c(disp_obj, 3, 0x26E, 0, land_layer, b"debris.spr\0".as_ptr());
+            DDDisplay::load_sprite_by_layer(disp, 3, 0x26D, land_layer, b"back.spr\0".as_ptr());
+            DDDisplay::load_sprite(disp, 3, 0x26E, 0, land_layer, b"debris.spr\0".as_ptr());
         }
 
-        // Load layer.spr into layer 2
-        let load_spr_94: unsafe extern "thiscall" fn(*mut u8, u32, u32, *mut u8, *const u8) =
-            core::mem::transmute(*disp_obj_vt.add(0x94 / 4));
-        load_spr_94(
-            disp_obj,
+        DDDisplay::load_sprite_by_layer(
+            disp,
             2,
             0x26C,
             water_layer,
@@ -1307,11 +1268,8 @@ unsafe fn init_graphics_and_resources(
         (*ddgame).gradient_image_2 = core::ptr::null_mut();
 
         // ── Gradient image (0x030) ──
-        // The gradient is loaded from "gradient.img" via GfxDir.
-        // Simple path: height <= 0x60 AND level_height == 0x2B8
         let level_height = (*ddgame).level_height as i32;
-        // Read sVar1 from display layer 3 context
-        let layer3_ctx = set_layer((*ddgame).display, 3);
+        let layer3_ctx = DDDisplay::set_active_layer(disp, 3);
         let s_var1 = *(layer3_ctx.add(0x606) as *const i16);
 
         if s_var1 < 0x61 && level_height == 0x2B8 {
@@ -1325,7 +1283,7 @@ unsafe fn init_graphics_and_resources(
 
         // ── Fill image → fill_pixel (0x7338) ──
         {
-            let layer2_ctx = set_layer((*ddgame).display, 2);
+            let layer2_ctx = DDDisplay::set_active_layer((*ddgame).display, 2);
             // In the original, fill.img uses piStack_126c which the decompiler
             // shows was set from piVar3 (water_layer from landscape+0xB38).
             let fill_sprite =
@@ -1380,15 +1338,12 @@ unsafe fn init_graphics_and_resources(
         call_usercall_eax(wrapper, FUN_570A90_ADDR);
     }
 
-    // ── Final display layer visibility (vtable[0x17], offset 0x5C) ──
+    // ── Final display layer visibility ──
     {
-        let disp = (*wrapper).display as *mut u8;
-        let vt = *(disp as *const *const u32);
-        let set_vis: unsafe extern "thiscall" fn(*mut u8, i32, i32) =
-            core::mem::transmute(*vt.add(0x17));
-        set_vis(disp, 1, 0);
-        set_vis(disp, 2, 0);
-        set_vis(disp, 3, 1);
+        let disp = (*wrapper).display;
+        DDDisplay::set_layer_visibility(disp, 1, 0);
+        DDDisplay::set_layer_visibility(disp, 2, 0);
+        DDDisplay::set_layer_visibility(disp, 3, 1);
     }
 
     let _ = crate::log::log_line("[DDGame] init_graphics_and_resources DONE");