feat: port DDGame__LoadFonts and DDGameWrapper__LoadFontExtension to Rust

Replaces the usercall bridge to 0x570F30 with pure Rust that loads 28
bitmap fonts, 23 font extensions, and sets the font palette via typed
DDDisplay vtable calls. Adds three new DDDisplay vtable slots (load_font,
load_font_extension, set_font_palette) and expands gfx_color_table from
9 to 11 entries, absorbing former _unknown_7330 as font palette data.

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

crates/openwa-core/src/address.rs

@@ -104,7 +104,9 @@ pub mod va {
             /// DDGame__InitVersionFlags — stdcall(ddgame_wrapper)
             fn/Stdcall DDGAME_INIT_VERSION_FLAGS = 0x0052_5BE0;
             /// DDGame__LoadFonts — loads .fnt font resources into the display.
-            fn DDGAME_LOAD_FONTS = 0x0057_0F30;
+            fn/Usercall DDGAME_LOAD_FONTS = 0x0057_0F30;
+            /// DDGameWrapper__LoadFontExtension — loads .fex font extension for a font slot.
+            fn/Stdcall DDGAME_WRAPPER_LOAD_FONT_EXTENSION = 0x0057_0E80;
             /// DDGame__LoadHudAndWeaponSprites
             fn/Thiscall DDGAME_LOAD_HUD_AND_WEAPON_SPRITES = 0x0053_D0E0;
             /// DDGame__InitPaletteGradientSprites

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

@@ -29,6 +29,41 @@ pub struct DDDisplayVtable {
     /// set layer visibility
     #[slot(23)]
     pub set_layer_visibility: fn(this: *mut DDDisplay, layer: i32, value: i32),
+    /// load .fnt bitmap font into a font slot (RET 0x10)
+    ///
+    /// DDDisplay__LoadFont (0x523560).
+    /// mode: font source (1-3, usually 1). font_id: slot index (1-based, max 0x1F).
+    /// gfx: GfxDir archive to load from. filename: .fnt resource name.
+    #[slot(34)]
+    pub load_font: fn(
+        this: *mut DDDisplay,
+        mode: i32,
+        font_id: i32,
+        gfx: *mut u8,
+        filename: *const core::ffi::c_char,
+    ) -> u32,
+    /// load .fex font extension (extra glyphs) for a font slot (RET 0x14)
+    ///
+    /// DDDisplay__LoadFontExtension (0x523620).
+    /// font_id: slot index. path: filesystem path to .fex file.
+    /// char_map: 61-byte character code table. palette_value: color from GfxColorTable.
+    /// flag: unknown (always 0 from DDGameWrapper__LoadFontExtension).
+    #[slot(35)]
+    pub load_font_extension: fn(
+        this: *mut DDDisplay,
+        font_id: i32,
+        path: *const core::ffi::c_char,
+        char_map: *const u8,
+        palette_value: u32,
+        flag: i32,
+    ) -> u32,
+    /// set font palette for all loaded fonts (RET 0x8)
+    ///
+    /// DDDisplay__SetFontPalette (0x523690).
+    /// font_count: total number of font slots loaded.
+    /// palette_value: palette/color entry from DDGame GfxColorTable.
+    #[slot(36)]
+    pub set_font_palette: fn(this: *mut DDDisplay, font_count: u32, palette_value: u32),
     /// load sprite with flag (RET 0x14)
     #[slot(31)]
     pub load_sprite: fn(

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

@@ -230,14 +230,13 @@ pub struct DDGame {
     pub _field_7304: u32,
     /// 0x7308: Sprite/gfx dimension data (passed to GFX_DIR_LOAD_SPRITES).
     pub gfx_sprite_data: [u8; 0x730C - 0x7308],
-    /// 0x730C-0x732F: GfxDir color table (9 entries).
+    /// 0x730C-0x7337: GfxDir color table (11 entries).
     /// Populated from colours.img pixel row: `color_table[i] = get_pixel(sprite, i, 0)`.
     /// Known entries:
     /// - [6] (0x7324): Crosshair line color (DrawPolygon param_2)
     /// - [8] (0x732C): Crosshair line style (DrawPolygon param_1)
-    pub gfx_color_table: [u32; 9],
-    /// 0x7330-0x7337: Unknown
-    pub _unknown_7330: [u8; 8],
+    /// - [9]-[10] (0x7330-0x7334): Font palette entries (used by LoadFontExtension)
+    pub gfx_color_table: [u32; 11],
     /// 0x7338: Fill pixel value
     pub fill_pixel: u32,
     /// 0x733C-0x733F: Unknown

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

@@ -153,7 +153,7 @@ pub fn init_constructor_addrs() {
     unsafe {
         SPRITE_REGION_CTOR_ADDR = rb(va::SPRITE_REGION_CONSTRUCTOR);
         FUN_570A90_ADDR = rb(va::FUN_570A90);
-        FUN_570F30_ADDR = rb(va::DDGAME_LOAD_FONTS);
+
         LOAD_SPEECH_BANKS_ADDR = rb(va::DSSOUND_LOAD_ALL_SPEECH_BANKS);
         LOADING_PROGRESS_TICK_ADDR = rb(va::DDGAME_WRAPPER_LOADING_PROGRESS_TICK);
         GFX_LOAD_SPRITES_ADDR = rb(va::GFX_DIR_LOAD_SPRITES);
@@ -627,8 +627,7 @@ unsafe fn init_graphics_and_resources(
 
     // ── Audio init (non-headless + sound available) ──
     if !is_headless {
-        // FUN_570F30: font loading (usercall ESI=wrapper) — NOT audio related
-        call_usercall_esi(wrapper, FUN_570F30_ADDR);
+        crate::engine::ddgame_load_fonts::load_fonts(wrapper);
         if !(*ddgame).sound.is_null() {
             load_effect_wavs(wrapper);
             // DSSound_LoadAllSpeechBanks: the original is hooked to our Rust
@@ -1067,11 +1066,11 @@ unsafe fn init_graphics_and_resources(
 
 // Statics for usercall bridge addresses
 static mut FUN_570A90_ADDR: u32 = 0;
-static mut FUN_570F30_ADDR: u32 = 0;
+
 static mut LOAD_SPEECH_BANKS_ADDR: u32 = 0;
 static mut LOADING_PROGRESS_TICK_ADDR: u32 = 0;
 
-/// Bridge: usercall(ESI=wrapper), plain RET. Used by FUN_570E20, FUN_570F30, LoadSpeechBanks.
+/// Bridge: usercall(ESI=wrapper), plain RET. Used by FUN_570E20, LoadSpeechBanks.
 #[cfg(target_arch = "x86")]
 #[unsafe(naked)]
 unsafe extern "C" fn call_usercall_esi(_wrapper: *mut DDGameWrapper, _addr: u32) {

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

@@ -0,0 +1,156 @@
+//! DDGame__LoadFonts (0x570F30) and DDGameWrapper__LoadFontExtension (0x570E80).
+//!
+//! Loads 28 bitmap fonts (.fnt) and 23 font extensions (.fex) into the display,
+//! then sets the font palette. Called from DDGame__Constructor during loading.
+
+use core::ffi::c_char;
+use heapless::CString;
+
+use crate::display::dd_display::DDDisplay;
+use crate::engine::ddgame_wrapper::DDGameWrapper;
+
+/// Total number of font slots loaded (1-based, so slots 1..=28).
+const FONT_COUNT: u32 = 0x1C;
+
+/// Number of font slots that get font extensions loaded (1..=23).
+const FONT_EXT_COUNT: u32 = 0x17;
+
+/// Font filenames (.fnt), indexed 1..=28 (slot 0 unused).
+const FONT_FILENAMES: [&[u8]; 29] = [
+    b"\0",             // [0] unused
+    b"smlred1.fnt\0",  // [1]
+    b"smlblu1.fnt\0",  // [2]
+    b"smlgrn1.fnt\0",  // [3]
+    b"smlyel1.fnt\0",  // [4]
+    b"smlppl1.fnt\0",  // [5]
+    b"smlcyn1.fnt\0",  // [6]
+    b"smlwht1.fnt\0",  // [7]
+    b"smlwht2.fnt\0",  // [8]
+    b"stdred1.fnt\0",  // [9]
+    b"stdblu1.fnt\0",  // [10]
+    b"stdgrn1.fnt\0",  // [11]
+    b"stdyel1.fnt\0",  // [12]
+    b"stdppl1.fnt\0",  // [13]
+    b"stdcyn1.fnt\0",  // [14]
+    b"stdwht1.fnt\0",  // [15]
+    b"stdwht2.fnt\0",  // [16]
+    b"medred1.fnt\0",  // [17]
+    b"medblu1.fnt\0",  // [18]
+    b"medgrn1.fnt\0",  // [19]
+    b"medyel1.fnt\0",  // [20]
+    b"medppl1.fnt\0",  // [21]
+    b"medcyn1.fnt\0",  // [22]
+    b"medwht1.fnt\0",  // [23]
+    b"lnumred1.fnt\0", // [24]
+    b"lnumwht1.fnt\0", // [25]
+    b"lnumred2.fnt\0", // [26]
+    b"lnumwht2.fnt\0", // [27]
+    b"digiwht.fnt\0",  // [28]
+];
+
+/// Font ID → size category index.
+/// 0 = sml, 1 = std, 2 = med, 3 = bignum, 4 = digi.
+/// Original data at 0x6A90E8.
+const FONT_SIZE_CATEGORY: [u32; 29] = [
+    5, // [0] unused
+    0, 0, 0, 0, 0, 0, 0, 0, // [1-8]   sml
+    1, 1, 1, 1, 1, 1, 1, 1, // [9-16]  std
+    2, 2, 2, 2, 2, 2, 2, // [17-23] med
+    3, 3, 3, 3, // [24-27] bignum
+    4, // [28]    digi
+];
+
+/// Font ID → color index. Original data at 0x6A9160.
+const FONT_COLOR_INDEX: [u32; 29] = [
+    10, // [0]
+    0, 1, 2, 3, 4, 5, 6, 7, // [1-8]   red, blu, grn, yel, ppl, cyn, wht1, wht2
+    0, 1, 2, 3, 4, 5, 6, 7, // [9-16]
+    0, 1, 2, 3, 4, 5, 6, // [17-23]
+    9, 6, 8, 7, // [24-27]
+    6, // [28]
+];
+
+/// Color index → gfx_color_table index (0-based).
+/// Original data at 0x6A91D4 (1-based offsets from DDGame+0x7308, converted to 0-based).
+const COLOR_TABLE_INDEX: [usize; 10] = [0, 1, 2, 3, 4, 5, 8, 6, 9, 10];
+
+/// Size category → .fex path prefix.
+const SIZE_PREFIXES: [&str; 5] = ["sml", "std", "med", "bignum", ""];
+
+/// Extended character map (61 bytes). Original data at 0x66ACD8.
+/// Defines which character codes are present in .fex font extension files.
+const FONT_EXT_CHAR_MAP: [u8; 61] = [
+    0xBF, 0xA1, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D,
+    0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E,
+    0xA2, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0xB3,
+    0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0x0A, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0x00,
+];
+
+/// Load a font extension (.fex) for the given font slot.
+///
+/// Port of DDGameWrapper__LoadFontExtension (0x570E80, stdcall, RET 0x8).
+/// Formats the .fex path from the font's size category, copies the character map,
+/// resolves the palette value, and calls DDDisplay::load_font_extension.
+unsafe fn load_font_extension(wrapper: *mut DDGameWrapper, font_id: u32) {
+    let size_category = FONT_SIZE_CATEGORY[font_id as usize];
+    let prefix = SIZE_PREFIXES[size_category as usize];
+
+    // Format path: "Data\Gfx\FontExt\{prefix}2.fex"
+    let mut path: CString<64> = CString::new();
+    let _ = path.extend_from_bytes(b"Data\\Gfx\\FontExt\\");
+    let _ = path.extend_from_bytes(prefix.as_bytes());
+    let _ = path.extend_from_bytes(b"2.fex");
+
+    // Copy character map to stack (original does REP MOVSD + MOVSB)
+    let char_map = FONT_EXT_CHAR_MAP;
+
+    // Resolve palette value: font_id → color_index → gfx_color_table entry
+    let color_index = FONT_COLOR_INDEX[font_id as usize];
+    let table_index = COLOR_TABLE_INDEX[color_index as usize];
+    let ddgame = (*wrapper).ddgame;
+    let palette_value = (*ddgame).gfx_color_table[table_index];
+
+    let display = (*wrapper).display;
+    DDDisplay::load_font_extension_raw(
+        display,
+        font_id as i32,
+        path.as_ptr() as *const c_char,
+        char_map.as_ptr(),
+        palette_value,
+        0,
+    );
+}
+
+/// Load all bitmap fonts and font extensions.
+///
+/// Port of DDGame__LoadFonts (0x570F30, usercall ESI=DDGameWrapper).
+///
+/// Phase 1: Loads 28 .fnt bitmap fonts via DDDisplay::load_font.
+/// Phase 2: Loads .fex font extensions for font slots 1-23.
+/// Phase 3: Sets the font palette via DDDisplay::set_font_palette.
+pub unsafe fn load_fonts(wrapper: *mut DDGameWrapper) {
+    let display = (*wrapper).display;
+    let gfx_dir = (*wrapper).primary_gfx_dir;
+
+    // Phase 1: Load all 28 .fnt font files
+    for font_id in 1..=FONT_COUNT {
+        let filename = FONT_FILENAMES[font_id as usize];
+        DDDisplay::load_font_raw(
+            display,
+            1,
+            font_id as i32,
+            gfx_dir,
+            filename.as_ptr() as *const c_char,
+        );
+    }
+
+    // Phase 2: Load font extensions for slots 1-23
+    for font_id in 1..=FONT_EXT_COUNT {
+        load_font_extension(wrapper, font_id);
+    }
+
+    // Phase 3: Set font palette — passes font count and gfx_color_table[7].
+    let ddgame = (*wrapper).ddgame;
+    let palette_value = (*ddgame).gfx_color_table[7];
+    DDDisplay::set_font_palette_raw(display, FONT_COUNT, palette_value);
+}

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

@@ -1,5 +1,6 @@
 pub mod ddgame;
 pub mod ddgame_constructor;
+pub mod ddgame_load_fonts;
 pub mod ddgame_wrapper;
 pub mod game_info;
 pub mod game_session;