feat: port DDDisplay slots 5, 23, 24 — layer management and palette update

Port set_active_layer (trivial field read), update_palette (iterates
PaletteContext cache to copy RGBX entries into DisplayGfx palette, calls
PaletteCommit via usercall bridge), and set_layer_visibility (dispatches
to set_active_layer + update_palette).

Improve type safety: use typed PaletteContext struct instead of raw pointer
arithmetic, rename DisplayBase fields (font_table, layer_contexts,
layer_visibility) and DisplayGfx palette dirty range fields.

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

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

@@ -45,18 +45,22 @@ pub struct DisplayBase {
     pub _field_3018: u32,
     // +0x301C..0x309C: gap (0x80 bytes, 32 u32s: indices 0xC07..0xC26)
     pub _gap_301c: [u32; 32],
-    // +0x309C..0x311C: indices 0xC27..0xC46 (32 entries), zeroed by ctor
-    pub _fields_309c: [u32; 32],
-    // +0x311C..0x312C: indices 0xC47..0xC4A (4 entries), zeroed by ctor
-    pub _fields_311c: [u32; 4],
+    // +0x309C..0x311C: font object pointers (32 entries), zeroed by ctor.
+    // Indexed by font_id (valid range 1-31). Used by GetFontInfo, GetFontMetric, SetFontParam.
+    pub font_table: [u32; 32],
+    // +0x311C..0x312C: layer context pointers (4 entries), zeroed by ctor.
+    // Indexed by layer (valid range 1-3). Returned by set_active_layer (vtable slot 5).
+    // Used as palette data input for update_palette (vtable slot 24).
+    pub layer_contexts: [u32; 4],
     // +0x312C: index 0xC4B, zeroed by ctor
     pub _field_312c: u32,
     // +0x3130..0x352C: slot_table — 0xFF entries, all initialized to 1 by ctor
     pub slot_table: [u32; 0xFF],
     // +0x352C: index 0xD4B = 0xFFFFFFFF
     pub _field_352c: u32,
-    // +0x3530..0x3540: indices 0xD4C..0xD4F (4 entries), zeroed by ctor
-    pub _fields_3530: [u32; 4],
+    // +0x3530..0x3540: layer visibility flags (4 entries), zeroed by ctor.
+    // Indexed by layer. Cleared to 0 by set_layer_visibility when visible < 0.
+    pub layer_visibility: [u32; 4],
     // +0x3540: display initialized flag (set to 1 by DDDisplay__Init)
     pub display_initialized: u32,
     // +0x3544: unknown

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

@@ -184,9 +184,13 @@ pub struct DDDisplayVtable {
     /// set layer visibility (0x56A5D0, RET 0x8)
     #[slot(23)]
     pub set_layer_visibility: fn(this: *mut DDDisplay, layer: i32, visible: i32),
-    /// update palette from palette data (0x56A610, RET 0x8)
+    /// update palette from PaletteContext (0x56A610, RET 0x8)
     #[slot(24)]
-    pub update_palette: fn(this: *mut DDDisplay, palette_data: *mut i16, p3: i32),
+    pub update_palette: fn(
+        this: *mut DDDisplay,
+        palette_ctx: *mut crate::render::palette::PaletteContext,
+        commit: i32,
+    ),
     // Slot 25: stub (CGameTask__vt19)
     /// flush pending render state (0x56A580, plain RET)
     ///
@@ -285,6 +289,7 @@ bind_DDDisplayVtable!(DDDisplay, vtable);
 use super::gfx::DisplayGfx;
 use super::line_draw;
 use crate::bitgrid::DisplayBitGrid;
+use crate::render::palette::PaletteContext;
 
 /// Port of DDDisplay::GetDimensions (vtable slot 1, 0x56A460).
 ///
@@ -1020,3 +1025,149 @@ pub unsafe extern "thiscall" fn draw_pixel_strip(
         }
     }
 }
+
+/// Port of DDDisplay::SetActiveLayer (vtable slot 5, 0x523270).
+///
+/// Returns the layer context pointer for `layer` (valid: 1, 2, 3), or null
+/// if the layer index is out of range. The returned pointer is used as
+/// palette data input for `update_palette`.
+///
+/// # Safety
+/// `this` must be a valid `*mut DDDisplay` (actually a `*mut DisplayGfx`).
+pub unsafe extern "thiscall" fn set_active_layer(this: *mut DDDisplay, layer: i32) -> *mut u8 {
+    let gfx = this as *mut DisplayGfx;
+    if (layer as u32).wrapping_sub(1) < 3 {
+        (*gfx).base.layer_contexts[layer as usize] as *mut u8
+    } else {
+        core::ptr::null_mut()
+    }
+}
+
+/// Port of DDDisplay::UpdatePalette (vtable slot 24, 0x56A610).
+///
+/// Updates DisplayGfx palette entries from a `PaletteContext`. The context's
+/// `cache` array lists which palette indices to copy, and `cache_count` says
+/// how many. Each index's RGB is read from `rgb_table` and written to the
+/// DisplayGfx `palette_entries` table.
+///
+/// If `commit != 0`, calls the palette commit function (0x56CD20) to push
+/// the updated entries to the DDraw surface palette.
+///
+/// # Safety
+/// `this` must be a valid `*mut DDDisplay` (actually a `*mut DisplayGfx`).
+/// `palette_ctx` must point to a valid `PaletteContext`.
+pub unsafe extern "thiscall" fn update_palette(
+    this: *mut DDDisplay,
+    palette_ctx: *mut PaletteContext,
+    commit: i32,
+) {
+    let gfx = this as *mut DisplayGfx;
+    let ctx = &mut *palette_ctx;
+
+    // Reset iteration counter
+    ctx.cache_iter = 0;
+
+    if ctx.cache_count <= 0 {
+        return;
+    }
+
+    let dirty_min = ctx.dirty_range_min as i32;
+    let dirty_max = ctx.dirty_range_max as i32;
+
+    // Mark iteration started
+    ctx.cache_iter = 1;
+
+    // First index to update
+    let mut idx = ctx.cache[0] as usize;
+
+    loop {
+        // Read RGB entry from PaletteContext rgb_table (stored as u32: low 3 bytes = R, G, B)
+        let rgb = ctx.rgb_table[idx].to_le_bytes();
+
+        // Write to DisplayGfx palette_entries: [R, G, B, flags=0]
+        (*gfx).palette_entries[idx * 4] = rgb[0];
+        (*gfx).palette_entries[idx * 4 + 1] = rgb[1];
+        (*gfx).palette_entries[idx * 4 + 2] = rgb[2];
+        (*gfx).palette_entries[idx * 4 + 3] = 0;
+
+        // Check if we've processed all entries
+        if ctx.cache_iter >= ctx.cache_count {
+            break;
+        }
+
+        // Advance to next index
+        idx = ctx.cache[ctx.cache_iter as usize] as usize;
+        ctx.cache_iter += 1;
+    }
+
+    // Track dirty palette range (expand to cover this update)
+    if ((*gfx).palette_dirty_min as i32) > dirty_min {
+        (*gfx).palette_dirty_min = dirty_min as u32;
+    }
+    if ((*gfx).palette_dirty_max as i32) < dirty_max {
+        (*gfx).palette_dirty_max = dirty_max as u32;
+    }
+
+    // Commit palette to DDraw surface if requested
+    if commit != 0 {
+        palette_commit(gfx);
+        (*gfx).palette_dirty_min = 0x100;
+        (*gfx).palette_dirty_max = 0xFFFF_FFFF;
+    }
+}
+
+/// Call WA's palette commit function (0x56CD20).
+///
+/// Usercall: EAX = dirty_min, EDX = dirty_max, stack param = this (DisplayGfx*).
+/// Pushes updated palette entries to the DDraw surface palette.
+unsafe fn palette_commit(gfx: *mut DisplayGfx) {
+    let dirty_min = (*gfx).palette_dirty_min;
+    let dirty_max = (*gfx).palette_dirty_max;
+    palette_commit_bridge(
+        gfx as *mut u8,
+        dirty_min,
+        dirty_max,
+        crate::rebase::rb(0x0056_CD20),
+    );
+}
+
+#[unsafe(naked)]
+unsafe extern "cdecl" fn palette_commit_bridge(
+    _gfx: *mut u8,
+    _dirty_min: u32,
+    _dirty_max: u32,
+    _target: u32,
+) {
+    core::arch::naked_asm!(
+        "mov eax, [esp + 8]",        // dirty_min
+        "mov edx, [esp + 12]",       // dirty_max
+        "push dword ptr [esp + 4]",  // gfx (this)
+        "call dword ptr [esp + 20]", // target (+4 from our push, +16 from original)
+        "ret",
+    );
+}
+
+/// Port of DDDisplay::SetLayerVisibility (vtable slot 23, 0x56A5D0).
+///
+/// Gets the layer context via `set_active_layer`, then updates the palette
+/// from that context if it exists. If `visible < 0`, clears the layer's
+/// visibility flag.
+///
+/// # Safety
+/// `this` must be a valid `*mut DDDisplay` (actually a `*mut DisplayGfx`).
+pub unsafe extern "thiscall" fn set_layer_visibility(
+    this: *mut DDDisplay,
+    layer: i32,
+    visible: i32,
+) {
+    let gfx = this as *mut DisplayGfx;
+
+    let layer_ctx = set_active_layer(this, layer) as *mut PaletteContext;
+    if !layer_ctx.is_null() {
+        update_palette(this, layer_ctx, visible);
+    }
+
+    if visible < 0 {
+        (*gfx).base.layer_visibility[layer as usize] = 0;
+    }
+}

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

@@ -87,10 +87,12 @@ pub struct DisplayGfx {
     // =========================================================================
     // Palette metadata and render state (0x3D90 - 0x3D97)
     // =========================================================================
-    /// 0x3D90: Palette entry count (init 0x100 = 256)
-    pub palette_count: u32,
-    /// 0x3D94: Unknown (init 0xFFFFFFFF)
-    pub _unknown_3d94: u32,
+    /// 0x3D90: Lowest dirty palette index (init 0x100 = none dirty).
+    /// Updated by `update_palette`, reset to 0x100 after palette commit.
+    pub palette_dirty_min: u32,
+    /// 0x3D94: Highest dirty palette index (init 0xFFFFFFFF = none dirty).
+    /// Updated by `update_palette`, reset to 0xFFFFFFFF after palette commit.
+    pub palette_dirty_max: u32,
 
     // =========================================================================
     // Render state and layer pointers (0x3D98 - 0x3DD3)

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

@@ -9,8 +9,11 @@
 /// May be embedded in a larger composite object (e.g. GfxDir + palette data).
 #[repr(C)]
 pub struct PaletteContext {
-    /// +0x00: Unknown (possibly vtable or parent object field).
-    pub _unknown_00: u32,
+    /// +0x00: Lowest palette index in the current update batch.
+    /// Set by the caller before `update_palette`; used to expand `palette_dirty_min`.
+    pub dirty_range_min: i16,
+    /// +0x02: Highest palette index in the current update batch.
+    pub dirty_range_max: i16,
     /// +0x04: RGB values stored per palette index (24-bit RGB in low 3 bytes).
     pub rgb_table: [u32; 256],
     /// +0x404: In-use flag per palette index (1 = allocated).
@@ -25,8 +28,13 @@ pub struct PaletteContext {
     pub cache: [u8; 256],
     /// +0x708: Dirty flag (set to 1 when a new slot is allocated).
     pub dirty: u16,
+    /// +0x70A: Iteration position in cache[] during `update_palette`.
+    /// Read/written by `update_palette` to track progress through the cache.
+    pub cache_iter: i16,
 }
 
+const _: () = assert!(core::mem::offset_of!(PaletteContext, dirty_range_min) == 0x00);
+const _: () = assert!(core::mem::offset_of!(PaletteContext, dirty_range_max) == 0x02);
 const _: () = assert!(core::mem::offset_of!(PaletteContext, rgb_table) == 0x04);
 const _: () = assert!(core::mem::offset_of!(PaletteContext, in_use) == 0x404);
 const _: () = assert!(core::mem::offset_of!(PaletteContext, free_count) == 0x504);
@@ -34,6 +42,7 @@ const _: () = assert!(core::mem::offset_of!(PaletteContext, free_stack) == 0x506
 const _: () = assert!(core::mem::offset_of!(PaletteContext, cache_count) == 0x606);
 const _: () = assert!(core::mem::offset_of!(PaletteContext, cache) == 0x608);
 const _: () = assert!(core::mem::offset_of!(PaletteContext, dirty) == 0x708);
+const _: () = assert!(core::mem::offset_of!(PaletteContext, cache_iter) == 0x70A);
 
 /// Map an RGB color to the nearest display palette index.
 ///

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

@@ -557,10 +557,13 @@ pub fn install() -> Result<(), String> {
             set_camera_offset   => dd_display::set_camera_offset,
             set_clip_rect       => dd_display::set_clip_rect,
             is_sprite_loaded    => dd_display::is_sprite_loaded,
-            draw_scaled_sprite => draw_scaled_sprite,
+            draw_scaled_sprite  => draw_scaled_sprite,
+            set_active_layer    => dd_display::set_active_layer,
+            set_layer_visibility => dd_display::set_layer_visibility,
+            update_palette      => dd_display::update_palette,
             slot 19 [originals::BLIT_SPRITE] => blit_sprite,
         })?;
-        let _ = log_line("[Display]   DDDisplay: patched 15 methods → Rust");
+        let _ = log_line("[Display]   DDDisplay: patched 18 methods → Rust");
     }
 
     Ok(())