refactor: port IMG_Decode and rename GfxResource to IMG

Port IMG_Decode (0x4F5F80) and DisplayGfx__Constructor (0x4F5E80) to
pure Rust, eliminating the last transmute bridges in the asset loading
pipeline. img_decode returns Option<DecodedBitGrid> with Display/Collision
discrimination; img_decode_cached always returns *mut DisplayBitGrid.

- Add asset/img.rs with img_decode and img_decode_cached
- Replace transmute bridges in gfx_dir.rs, ddgame_constructor.rs
- Hook IMG_DECODE and IMG_DECODE_CACHED for remaining WA callers
- Type DDGame fields: gradient_image, gradient_image_2, arrow_sprites
as *mut BitGrid instead of *mut u8
- Rename GfxResource__Create_Maybe → IMG__LoadFromDir (Ghidra + Rust)
- Rename DisplayGfx__Constructor_Maybe → IMG__DecodeCached (Ghidra + VA)
- Propagate Option<DecodedBitGrid> through call_gfx_find_and_load
and call_gfx_load_and_wrap

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

crates/openwa-core/src/address.rs

@@ -249,8 +249,8 @@ pub mod va {
         class "DisplayGfx" {
             /// DisplayGfx constructor
             ctor/Stdcall DISPLAYGFX_CTOR = 0x0056_9C10;
-            /// DisplayGfx constructor (from raw image)
-            ctor/Stdcall DISPLAYGFX_CONSTRUCTOR = 0x004F_5E80;
+            /// IMG__DecodeCached: decode cached raw image buffer into DisplayBitGrid
+            fn/Stdcall IMG_DECODE_CACHED = 0x004F_5E80;
             /// DisplayGfx construct full (5 params)
             fn/Stdcall DISPLAYGFX_CONSTRUCT_FULL = 0x0056_3FC0;
             /// DisplayGfx init team palette display objects
@@ -524,8 +524,8 @@ pub mod va {
         fn PALETTE_ANIMATE_MAYBE = 0x0053_3A80;
         fn LOAD_SPRITE = 0x0052_3400;
         fn OPENGL_INIT = 0x0059_F000;
-        /// GfxResource__Create_Maybe
-        fn GFX_RESOURCE_CREATE = 0x004F_6300;
+        /// IMG__LoadFromDir: look up + decode IMG resource from a .dir archive
+        fn IMG_LOAD_FROM_DIR = 0x004F_6300;
         /// SpriteGfxTable__Init
         fn/Fastcall SPRITE_GFX_TABLE_INIT = 0x0054_1620;
         /// RingBuffer__Init

crates/openwa-core/src/asset/gfx_dir.rs

@@ -4,11 +4,19 @@
 //! `Gfx0.dir`). It provides name→resource lookup via a 1024-bucket hash table
 //! and delegates file I/O and caching to vtable methods.
 
+#[cfg(target_arch = "x86")]
+use core::ffi::{c_char, CStr};
+
 use openwa_core::vtable;
 
 use crate::address::va;
+#[cfg(target_arch = "x86")]
+use crate::asset::img::DecodedBitGrid;
+use crate::bitgrid::BitGrid;
 use crate::rebase::rb;
 use crate::wa_alloc::{wa_malloc, wa_malloc_struct_zeroed};
+#[cfg(target_arch = "x86")]
+use crate::{asset, render::palette::PaletteContext};
 
 /// Cache slot within a GfxDir (0x10 bytes).
 ///
@@ -143,10 +151,7 @@ unsafe fn gfx_dir_hash(name: *const u8) -> u32 {
 /// `gfx_dir` must be a valid GfxHandler with initialized hash table at +0x04.
 /// `name` must be a valid null-terminated C string.
 #[cfg(target_arch = "x86")]
-pub unsafe fn gfx_dir_find_entry(
-    name: *const core::ffi::c_char,
-    gfx_dir: *const GfxDir,
-) -> *mut u8 {
+pub unsafe fn gfx_dir_find_entry(name: *const c_char, gfx_dir: *const GfxDir) -> *mut GfxDirEntry {
     let mut current_name = name as *const u8;
 
     loop {
@@ -215,7 +220,7 @@ pub unsafe fn gfx_dir_find_entry(
             }
 
             if match_found {
-                return entry as *mut u8;
+                return entry;
             }
 
             entry = (*entry).next;
@@ -448,94 +453,86 @@ pub unsafe extern "thiscall" fn gfx_dir_release(this: *mut GfxDir, flags: u32) {
     }
 }
 
-/// Pure Rust implementation of GfxResource__Create_Maybe (0x4F6300).
+/// Pure Rust implementation of IMG__LoadFromDir (0x4F6300).
 ///
-/// Convention: usercall(ECX=gfx_dir, EAX=name) + 1 stack(output), RET 0x4.
+/// Convention: usercall(ECX=gfx_dir, EAX=name) + 1 stack(palette_ctx), RET 0x4.
 ///
-/// Looks up `name` in the GfxHandler's directory, tries cached load, wraps
-/// as DisplayGfx. Falls back to loading the raw image and decoding it.
+/// Looks up `name` in the GfxDir archive's hash table. If found in cache,
+/// decodes via `img_decode_cached`. Otherwise loads from the archive stream
+/// and decodes via `img_decode`.
 ///
 /// # Safety
 /// All pointers must be valid WA objects.
 #[cfg(target_arch = "x86")]
-pub unsafe fn gfx_resource_create(
+pub unsafe fn img_load_from_dir(
     gfx_dir: *mut GfxDir,
-    name: *const core::ffi::c_char,
-    output: *mut crate::render::palette::PaletteContext,
-) -> *mut u8 {
-    // 1. Try FindEntry → cached load → DisplayGfx wrap
+    name: *const c_char,
+    palette_ctx: *mut PaletteContext,
+) -> *mut BitGrid {
+    use crate::asset::img::{img_decode, img_decode_cached};
+
+    // 1. Try FindEntry → cached load → decode from raw buffer
     let entry = gfx_dir_find_entry(name, gfx_dir);
     if !entry.is_null() {
-        // gfx_dir->vtable[2](entry->field_4) — cached load
-        let entry_val = (*(entry as *const GfxDirEntry)).value;
+        let entry_val = (*entry).value;
         let cached = GfxDir::load_cached_raw(gfx_dir, entry_val);
         if !cached.is_null() {
-            // DisplayGfx__Constructor_Maybe: stdcall(raw_image), RET 0x4
-            let ctor: unsafe extern "stdcall" fn(*mut u8) -> *mut u8 =
-                core::mem::transmute(rb(va::DISPLAYGFX_CONSTRUCTOR) as usize);
-            return ctor(cached);
+            return img_decode_cached(palette_ctx, cached) as *mut BitGrid;
         }
     }
 
-    // 2. Fallback: LoadImage → IMG_Decode
+    // 2. Fallback: LoadImage → IMG_Decode from stream
     let raw_image = gfx_dir_load_image(gfx_dir, name);
     if raw_image.is_null() {
         return core::ptr::null_mut();
     }
 
-    // IMG_Decode: stdcall(output, raw_image, 1), RET 0xC
-    let decode: unsafe extern "stdcall" fn(*mut u8, *mut u8, i32) -> *mut u8 =
-        core::mem::transmute(rb(va::IMG_DECODE) as usize);
-    let result = decode(output as *mut u8, raw_image as *mut u8, 1);
-
+    let result = match img_decode(palette_ctx, raw_image, 1) {
+        Some(decoded) => decoded.as_bitgrid_ptr(),
+        None => core::ptr::null_mut(),
+    };
     GfxDirStream::destroy_raw(raw_image);
 
     result
 }
 
 /// Helper: find entry in GfxDir and load image, or load directly.
-/// Returns a DisplayGfx/sprite pointer or null.
 #[cfg(target_arch = "x86")]
 pub(crate) unsafe fn call_gfx_find_and_load(
     gfx_dir: *mut GfxDir,
-    name: &core::ffi::CStr,
-    display_ctx: *mut crate::render::palette::PaletteContext,
-) -> *mut u8 {
-    let name_ptr = name.as_ptr() as *const u8;
-    let entry = gfx_dir_find_entry(name_ptr.cast(), gfx_dir);
+    name: &CStr,
+    palette_ctx: *mut PaletteContext,
+) -> Option<DecodedBitGrid> {
+    let name_ptr = name.as_ptr();
+    let entry = gfx_dir_find_entry(name_ptr, gfx_dir);
 
     if !entry.is_null() {
-        // Try cached load: gfx_dir->vtable[2](entry->field_4)
-        let cached = GfxDir::load_cached_raw(gfx_dir, (*(entry as *const GfxDirEntry)).value);
+        let cached = GfxDir::load_cached_raw(gfx_dir, (*entry).value);
         if !cached.is_null() {
-            // Wrap with DisplayGfx__Constructor_Maybe (0x4F5E80)
-            // This is stdcall(1 param), RET 0x4
-            let ctor: unsafe extern "stdcall" fn(*mut u8) -> *mut u8 =
-                core::mem::transmute(rb(va::DISPLAYGFX_CONSTRUCTOR) as usize);
-            return ctor(cached);
+            let grid = asset::img::img_decode_cached(palette_ctx, cached);
+            if !grid.is_null() {
+                return Some(DecodedBitGrid::Display(grid));
+            }
+            return None;
         }
     }
 
     // Fallback: load image directly
-    call_gfx_load_and_wrap(gfx_dir, name_ptr.cast(), display_ctx)
+    call_gfx_load_and_wrap(gfx_dir, name_ptr.cast(), palette_ctx)
 }
 
-/// Helper: load image via GfxDir__LoadImage + wrap as DisplayGfx.
-/// Used by arrow sprite loop when GfxDir__FindEntry returns null.
+/// Helper: load image via GfxDir__LoadImage + IMG_Decode.
 #[cfg(target_arch = "x86")]
 pub(crate) unsafe fn call_gfx_load_and_wrap(
     gfx_dir: *mut GfxDir,
-    name: *const core::ffi::c_char,
-    display_ctx: *mut crate::render::palette::PaletteContext,
-) -> *mut u8 {
+    name: *const c_char,
+    palette_ctx: *mut PaletteContext,
+) -> Option<DecodedBitGrid> {
     let image = gfx_dir_load_image(gfx_dir, name);
     if image.is_null() {
-        return core::ptr::null_mut();
+        return None;
     }
-    // FUN_004F5F80(display_ctx, image, 1) — stdcall, RET 0xC (3 params)
-    let f: unsafe extern "stdcall" fn(*mut u8, *mut u8, u32) -> *mut u8 =
-        core::mem::transmute(rb(va::IMG_DECODE) as usize);
-    let result = f(display_ctx as *mut u8, image as *mut u8, 1);
+    let result = asset::img::img_decode(palette_ctx, image, 1);
     GfxDirStream::destroy_raw(image);
     result
 }
@@ -806,10 +803,7 @@ pub unsafe extern "thiscall" fn gfx_dir_stream_read(
 /// creates a GfxDirStream for sequential reading, and returns it.
 /// Returns null if no free slots or name not found.
 #[cfg(target_arch = "x86")]
-pub unsafe fn gfx_dir_load_image(
-    gfx_dir: *mut GfxDir,
-    name: *const core::ffi::c_char,
-) -> *mut GfxDirStream {
+pub unsafe fn gfx_dir_load_image(gfx_dir: *mut GfxDir, name: *const c_char) -> *mut GfxDirStream {
     // Check if there are free cache slots
     if (*gfx_dir).slot_count == 0 {
         return core::ptr::null_mut();

crates/openwa-core/src/asset/img.rs

@@ -0,0 +1,293 @@
+//! IMG format decoder — `.img` image files in `.dir` archives.
+//!
+//! WA uses a custom "IMG" format for static graphics (gradients, masks,
+//! HUD elements). Format: magic "IMG\x1A", header with flags, optional
+//! palette, width/height, then raw or LZSS-compressed pixel data.
+//!
+//! Two entry points:
+//! - `img_decode` — reads from a `GfxDirStream` (stream-based path)
+//! - `img_decode_cached` — reads from a raw memory buffer (cached path)
+
+use crate::asset::gfx_dir::GfxDirStream;
+use crate::bitgrid::{
+    BitGrid, CollisionBitGrid, DisplayBitGrid, BIT_GRID_COLLISION_VTABLE, BIT_GRID_DISPLAY_VTABLE,
+};
+use crate::rebase::rb;
+use crate::render::palette::{palette_map_color, remap_pixels_through_lut, PaletteContext};
+use crate::render::sprite::lzss::sprite_lzss_decode;
+use crate::wa_alloc::wa_malloc_zeroed;
+
+/// IMG file magic: "IMG\x1A" as little-endian u32.
+const IMG_MAGIC: u32 = 0x1A47_4D49;
+
+/// IMG header flags.
+const FLAG_HAS_PALETTE: u16 = 0x8000;
+const FLAG_LZSS_COMPRESSED: u16 = 0x4000;
+const FLAG_EXTENDED_HEADER: u16 = 0x3FF6;
+
+// ─── Global sprite palette byte counter (0x7A0870) ──────────────────────────
+// IMG_Decode and DisplayGfx__Constructor both add palette_count * 3 to this.
+crate::define_addresses! {
+    global G_SPRITE_PALETTE_BYTES = 0x007A_0870;
+    /// Global temp buffer for LZSS decompression (large static array in WA.exe)
+    global G_LZSS_TEMP_BUFFER = 0x006B_39C8;
+}
+
+pub enum DecodedBitGrid {
+    Display(*mut DisplayBitGrid),
+    Collision(*mut CollisionBitGrid),
+}
+
+impl DecodedBitGrid {
+    /// Get the underlying pointer as `*mut BitGrid` (common base type).
+    /// Valid because all BitGrid variants share the same `#[repr(C)]` layout.
+    pub fn as_bitgrid_ptr(self) -> *mut BitGrid {
+        match self {
+            DecodedBitGrid::Display(p) => p as *mut BitGrid,
+            DecodedBitGrid::Collision(p) => p as *mut BitGrid,
+        }
+    }
+}
+
+/// Pure Rust implementation of IMG_Decode (0x4F5F80).
+///
+/// Reads an IMG image from a `GfxDirStream`, decodes it into a BitGrid
+/// (DisplayBitGrid for 8bpp or CollisionBitGrid for 1bpp).
+///
+/// Convention: stdcall(palette_ctx, stream, align_flag), RET 0xC.
+///
+/// # Safety
+/// All pointers must be valid WA objects. Must be called from within WA.exe.
+#[cfg(target_arch = "x86")]
+pub unsafe fn img_decode(
+    palette_ctx: *mut PaletteContext,
+    stream: *mut GfxDirStream,
+    align_flag: i32,
+) -> Option<DecodedBitGrid> {
+    // ── 1. Read and validate magic ──
+    let mut magic: u32 = 0;
+    GfxDirStream::read_raw(stream, &raw mut magic as *mut u8, 4);
+    if magic != IMG_MAGIC {
+        return None;
+    }
+
+    // ── 2. Read data_size (used for LZSS remaining calculation) ──
+    let mut data_size: u32 = 0;
+    GfxDirStream::read_raw(stream, &raw mut data_size as *mut u8, 4);
+
+    // ── 3. Read flags ──
+    let mut flags: u16 = 0;
+    GfxDirStream::read_raw(stream, &raw mut flags as *mut u8, 2);
+
+    // ── 4. Handle extended header (rare) ──
+    if (flags & FLAG_EXTENDED_HEADER) != 0 {
+        // Seek back before flags, skip bytes until null terminator, re-read flags
+        let pos = GfxDirStream::bytes_consumed_raw(stream);
+        GfxDirStream::seek_raw(stream, pos.wrapping_sub(2));
+        loop {
+            let mut b: u8 = 0;
+            GfxDirStream::read_raw(stream, &raw mut b, 1);
+            if b == 0 {
+                break;
+            }
+        }
+        GfxDirStream::read_raw(stream, &raw mut flags as *mut u8, 2);
+    }
+
+    // ── 5. Build palette LUT ──
+    let mut palette_lut = [0u8; 256];
+    if (flags & FLAG_HAS_PALETTE) != 0 {
+        let mut palette_count: u16 = 0;
+        GfxDirStream::read_raw(stream, &raw mut palette_count as *mut u8, 2);
+
+        // Read RGB triplets into temp buffer
+        let rgb_byte_count = palette_count as u32 * 3;
+        let mut rgb_buf = [0u8; 256 * 3]; // max 256 entries * 3 bytes
+        GfxDirStream::read_raw(stream, rgb_buf.as_mut_ptr(), rgb_byte_count);
+
+        // Map each RGB triplet through PaletteContext to build LUT
+        // lut[0] = 0 (transparent), lut[1+i] = MapColor(RGB[i])
+        for i in 0..palette_count as usize {
+            // Read as u32 from the RGB bytes (only low 3 bytes matter)
+            let r = rgb_buf[i * 3] as u32;
+            let g = rgb_buf[i * 3 + 1] as u32;
+            let b = rgb_buf[i * 3 + 2] as u32;
+            let rgb = r | (g << 8) | (b << 16);
+            palette_lut[i + 1] = palette_map_color(palette_ctx, rgb) as u8;
+        }
+
+        // Update global palette byte counter
+        let counter = rb(G_SPRITE_PALETTE_BYTES) as *mut u32;
+        *counter = (*counter).wrapping_add(rgb_byte_count);
+    }
+
+    // ── 6. Read width and height ──
+    let mut width: u16 = 0;
+    let mut height: u16 = 0;
+    GfxDirStream::read_raw(stream, &raw mut width as *mut u8, 2);
+    GfxDirStream::read_raw(stream, &raw mut height as *mut u8, 2);
+
+    // ── 7. Determine bpp from flags low byte ──
+    let bpp = (flags & 0xFF) as u8;
+    if bpp != 1 && bpp != 8 {
+        return None;
+    }
+
+    // ── 8. Allocate BitGrid (0x4C bytes, matching original allocation size) ──
+    let grid = wa_malloc_zeroed(0x4C) as *mut BitGrid;
+    if grid.is_null() {
+        return None;
+    }
+    BitGrid::init(grid, bpp as u32, width as u32, height as u32);
+
+    // Override vtable based on bpp
+    if bpp == 8 {
+        (*(grid as *mut DisplayBitGrid)).vtable =
+            rb(BIT_GRID_DISPLAY_VTABLE) as *const crate::bitgrid::BitGridDisplayVtable;
+    } else {
+        (*(grid as *mut CollisionBitGrid)).vtable =
+            rb(BIT_GRID_COLLISION_VTABLE) as *const crate::bitgrid::BitGridCollisionVtable;
+    }
+
+    let pixel_data = (*grid).data;
+    let row_stride = (*grid).row_stride;
+
+    // ── 9. Alignment padding ──
+    if align_flag != 0 {
+        loop {
+            let pos = GfxDirStream::bytes_consumed_raw(stream);
+            if (pos & 3) == 0 {
+                break;
+            }
+            let mut dummy: u8 = 0;
+            GfxDirStream::read_raw(stream, &raw mut dummy, 1);
+        }
+    }
+
+    // ── 10. Read pixel data ──
+    if (flags & FLAG_LZSS_COMPRESSED) != 0 {
+        // LZSS path: read remaining stream data into temp buffer, then decompress.
+        // sprite_lzss_decode applies the palette LUT during decompression,
+        // so no separate remap step is needed afterward.
+        let pos = GfxDirStream::bytes_consumed_raw(stream);
+        let remaining = data_size.wrapping_sub(pos);
+
+        // Use WA's global LZSS temp buffer
+        let lzss_buffer = rb(G_LZSS_TEMP_BUFFER) as *mut u8;
+        GfxDirStream::read_raw(stream, lzss_buffer, remaining);
+
+        sprite_lzss_decode(pixel_data, lzss_buffer, palette_lut.as_ptr());
+    } else {
+        // Row-by-row path: read raw pixel data
+        let bits_per_row = width as u32 * bpp as u32;
+        let bytes_per_row = (bits_per_row + 7) / 8;
+
+        for row in 0..height as u32 {
+            let row_ptr = pixel_data.add((row * row_stride) as usize);
+            GfxDirStream::read_raw(stream, row_ptr, bytes_per_row);
+        }
+
+        // Remap through palette LUT (only for non-LZSS, since LZSS applies the LUT inline)
+        if (flags & FLAG_HAS_PALETTE) != 0 && bpp == 8 {
+            let dwords_per_row = row_stride / 4;
+            remap_pixels_through_lut(
+                pixel_data,
+                row_stride,
+                palette_lut.as_ptr(),
+                dwords_per_row,
+                height as u32,
+            );
+        }
+    }
+
+    if bpp == 8 {
+        Some(DecodedBitGrid::Display(grid as *mut DisplayBitGrid))
+    } else {
+        Some(DecodedBitGrid::Collision(grid as *mut CollisionBitGrid))
+    }
+}
+
+/// Pure Rust implementation of DisplayGfx__Constructor (0x4F5E80).
+///
+/// Reads from a raw memory buffer (cached `.dir` entry). Always creates an
+/// 8bpp DisplayBitGrid. Format: raw_image+0x0A has palette_count, RGB data,
+/// width, height, then pixel data.
+///
+/// In the original WA code, the PaletteContext is passed implicitly via EBX
+/// (callee-saved register from the caller). Our Rust API takes it explicitly.
+///
+/// # Safety
+/// `raw_image` must be a valid pointer to cached image data.
+/// `palette_ctx` must be a valid PaletteContext pointer (from the caller).
+#[cfg(target_arch = "x86")]
+pub unsafe fn img_decode_cached(
+    palette_ctx: *mut PaletteContext,
+    raw_image: *mut u8,
+) -> *mut DisplayBitGrid {
+    use crate::wa_alloc::wa_malloc_struct_zeroed;
+
+    let mut ptr = raw_image.add(0x0A);
+
+    // ── 1. Read palette count and build LUT ──
+    let palette_count = *(ptr as *const u16) as usize;
+    ptr = ptr.add(2);
+
+    let mut palette_lut = [0u8; 256];
+    // palette_lut[0] = 0 (transparent, already zero)
+
+    for i in 0..palette_count {
+        // Read 3 RGB bytes as a u32 (4th byte is junk but MapColor only uses low 24 bits)
+        let rgb = *(ptr as *const u32);
+        palette_lut[i + 1] = palette_map_color(palette_ctx, rgb) as u8;
+        ptr = ptr.add(3);
+    }
+
+    // Update global palette byte counter
+    let counter = rb(G_SPRITE_PALETTE_BYTES) as *mut u32;
+    *counter = (*counter).wrapping_add(palette_count as u32 * 3);
+
+    // ── 2. Read width and height ──
+    let width = *(ptr as *const u16) as u32;
+    let height = *(ptr.add(2) as *const u16) as u32;
+    ptr = ptr.add(2); // advance past width (height pointer computed differently)
+
+    // ── 3. Allocate DisplayBitGrid (0x4C bytes, 8bpp only) ──
+    let grid = wa_malloc_struct_zeroed::<DisplayBitGrid>();
+    if grid.is_null() {
+        return core::ptr::null_mut();
+    }
+
+    // ── 4. Compute pixel data pointer (4-byte aligned after width+height) ──
+    // Original: (ptr - raw_image + 5) & ~3 + raw_image
+    // ptr is at raw_image + 0x0C + palette_count * 3 + 2
+    let offset = ptr.offset_from(raw_image) as usize + 5; // +5 accounts for remaining header
+    let aligned_offset = (offset & !3) as usize;
+    let pixel_data = raw_image.add(aligned_offset);
+
+    // ── 5. Set up fields manually (matching original, not via BitGrid::init) ──
+    (*grid).vtable = rb(BIT_GRID_DISPLAY_VTABLE) as *const crate::bitgrid::BitGridDisplayVtable;
+    (*grid).cells_per_unit = 8;
+    (*grid).width = width;
+    (*grid).height = height;
+    (*grid).row_stride = width; // row_stride = width for 8bpp uncompressed
+    (*grid).data = pixel_data;
+    (*grid).clip_left = 0;
+    (*grid).clip_top = 0;
+    (*grid).clip_right = width;
+    (*grid).clip_bottom = height;
+    (*grid).external_buffer = 1; // pixel data is owned by the cached buffer, not the grid
+
+    // ── 6. Remap pixels through palette LUT ──
+    if (*grid).cells_per_unit == 8 {
+        let dwords_per_row = width / 4;
+        remap_pixels_through_lut(
+            pixel_data,
+            width,
+            palette_lut.as_ptr(),
+            dwords_per_row,
+            height,
+        );
+    }
+
+    grid
+}

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

@@ -1 +1,2 @@
 pub mod gfx_dir;
+pub mod img;

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

@@ -3,7 +3,7 @@ use crate::audio::dssound::DSSound;
 use crate::audio::music::Music;
 use crate::audio::speech::SpeechSlotTable;
 use crate::audio::SoundQueueEntry;
-use crate::bitgrid::{CollisionBitGrid, DisplayBitGrid};
+use crate::bitgrid::{BitGrid, CollisionBitGrid, DisplayBitGrid};
 use crate::engine::game_info::GameInfo;
 use crate::engine::{CoordEntry, CoordList, TeamArena, TeamIndexMap};
 use crate::fixed::Fixed;
@@ -61,12 +61,12 @@ pub struct DDGame {
     pub net_game: *mut u8,
     /// 0x02C: Secondary PaletteContext (0x70C bytes, conditional on secondary GfxDir)
     pub secondary_palette_ctx: *mut crate::render::palette::PaletteContext,
-    /// 0x030: Gradient image pointer
-    pub gradient_image: *mut u8,
-    /// 0x034: Gradient image 2 pointer
-    pub gradient_image_2: *mut u8,
-    /// 0x038-0x0B4: Arrow sprite object pointers (32 entries)
-    pub arrow_sprites: [*mut u8; 32],
+    /// 0x030: Gradient image (decoded from gradient.img via IMG_Decode).
+    pub gradient_image: *mut BitGrid,
+    /// 0x034: Gradient image 2 pointer.
+    pub gradient_image_2: *mut BitGrid,
+    /// 0x038-0x0B4: Arrow sprite BitGrid pointers (32 entries, decoded from arrow*.img).
+    pub arrow_sprites: [*mut BitGrid; 32],
     /// 0x0B8-0x134: Arrow GfxDir pointers (32 entries, conditional)
     pub arrow_gfxdirs: [*mut u8; 32],
     /// 0x138: Primary display BitGrid (vtable 0x664144, 8bpp pixel buffer).

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

@@ -12,7 +12,8 @@ use crate::address::va;
 use crate::asset::gfx_dir::{
     call_gfx_find_and_load, call_gfx_load_and_wrap, gfx_dir_load_dir, GfxDir, GfxDirVtable,
 };
-pub use crate::asset::gfx_dir::{gfx_dir_find_entry, gfx_resource_create};
+pub use crate::asset::gfx_dir::{gfx_dir_find_entry, img_load_from_dir};
+use crate::asset::img::DecodedBitGrid;
 use crate::audio::active_sound::ActiveSoundTable;
 use crate::audio::dssound::DSSound;
 use crate::audio::music::Music;
@@ -173,7 +174,7 @@ unsafe fn wa_init_version_flags(wrapper: *mut DDGameWrapper) {
 /// GfxHandler__LoadSprites (0x570B50): usercall(ESI=layer_ctx) + stdcall(4 params).
 ///
 /// ESI must hold the display layer context (from DisplayGfx::set_active_layer).
-/// The function uses ESI for LoadSpriteFromVfs and GfxResource__Create_Maybe
+/// The function uses ESI for LoadSpriteFromVfs and IMG__LoadFromDir
 /// when param4 (gfx_dir) is non-null.
 #[cfg(target_arch = "x86")]
 #[unsafe(naked)]
@@ -253,7 +254,7 @@ unsafe fn load_effect_wavs(wrapper: *mut DDGameWrapper) {
 unsafe fn wa_pc_landscape_ctor(
     this: *mut u8,
     ddgame: *mut DDGame,
-    gfx_resource: *mut u8,
+    gfx_resource: *mut crate::bitgrid::BitGrid,
     display: *mut DisplayGfx,
     landscape_data: *const u8,
     byte_output: *mut u8,
@@ -266,7 +267,7 @@ unsafe fn wa_pc_landscape_ctor(
     let f: unsafe extern "stdcall" fn(
         *mut u8,
         *mut DDGame,
-        *mut u8,
+        *mut crate::bitgrid::BitGrid,
         *mut DisplayGfx,
         *const u8,
         *mut u8,
@@ -291,12 +292,13 @@ unsafe fn wa_pc_landscape_ctor(
     )
 }
 
-/// DisplayGfx__Constructor (0x4F5E80): wrap raw image data in DisplayGfx object.
+/// Decode a cached raw image buffer into a BitGrid (0x4F5E80).
 #[cfg(target_arch = "x86")]
-unsafe fn wa_displaygfx_ctor(raw_image: *mut u8) -> *mut u8 {
-    let f: unsafe extern "stdcall" fn(*mut u8) -> *mut u8 =
-        core::mem::transmute(rb(va::DISPLAYGFX_CONSTRUCTOR) as usize);
-    f(raw_image)
+unsafe fn wa_displaygfx_ctor(
+    palette_ctx: *mut crate::render::palette::PaletteContext,
+    raw_image: *mut u8,
+) -> *mut BitGrid {
+    crate::asset::img::img_decode_cached(palette_ctx, raw_image) as *mut BitGrid
 }
 
 /// DDGame__InitDisplayFinal (0x56A830): finalize display for non-headless mode.
@@ -545,27 +547,27 @@ 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.
+    // the `output` parameter in the color-entries IMG__LoadFromDir call below.
     let layer_ctx = (*(*ddgame).display).set_active_layer(1);
 
     // ── GfxDir color entries DDGame+0x730C..0x732C ──
-    // Original logic: if gfx_mode!=0, try GfxResource__Create for colours.img.
+    // Original logic: if gfx_mode!=0, try IMG__LoadFromDir for colours.img.
     // If gfx_mode==0 OR resource creation fails, fall back to LoadSprites.
     // The fallback's 4th param is primary_gfx_dir when gfx_mode==0, or 0 on resource fail.
     if (*wrapper).gfx_mode != 0 {
-        let res = gfx_resource_create(
+        let res = img_load_from_dir(
             (*wrapper).primary_gfx_dir,
             rb(va::STR_COLOURS_IMG) as *const core::ffi::c_char,
             layer_ctx,
         );
         if !res.is_null() {
             let rvt = *(res as *const *const u32);
-            let get_color: unsafe extern "thiscall" fn(*mut u8, u32, u32) -> u32 =
+            let get_color: unsafe extern "thiscall" fn(*mut BitGrid, u32, u32) -> u32 =
                 core::mem::transmute(*rvt.add(4));
             for i in 0..9u32 {
                 (*ddgame).gfx_color_table[i as usize] = get_color(res, i, 0);
             }
-            let release: unsafe extern "thiscall" fn(*mut u8, u8) =
+            let release: unsafe extern "thiscall" fn(*mut BitGrid, u8) =
                 core::mem::transmute(*rvt.add(3));
             release(res, 1);
         } else {
@@ -638,16 +640,16 @@ unsafe fn init_graphics_and_resources(
     // ── GfxResource for masks.img ──
     // The original constructor uses a stack-local PaletteContext buffer (ESP+0x1A4)
     // initialized at the start with (word=1, word=0xFE, PaletteContext__Init).
-    // This same buffer is reused as the output param for GfxResource__Create(masks.img).
+    // This same buffer is reused as the output param for IMG__LoadFromDir(masks.img).
     // We replicate this initialization here. Size 0x900 matches the stack allocation.
-    let gfx_resource: *mut u8;
+    let gfx_resource: *mut crate::bitgrid::BitGrid;
     {
         let gfx_dir = (*wrapper).primary_gfx_dir;
         let palette_ctx = wa_malloc_zeroed(0x900) as *mut crate::render::palette::PaletteContext;
         (*palette_ctx).dirty_range_min = 1;
         (*palette_ctx).dirty_range_max = 0xFE;
         crate::render::palette::palette_context_init(palette_ctx);
-        gfx_resource = gfx_resource_create(
+        gfx_resource = img_load_from_dir(
             gfx_dir,
             rb(va::STR_MASKS_IMG) as *const core::ffi::c_char,
             palette_ctx as *mut crate::render::palette::PaletteContext,
@@ -659,7 +661,7 @@ unsafe fn init_graphics_and_resources(
         let use_orig = std::env::var("OPENWA_USE_ORIG_CTOR").is_ok();
         let tag = if use_orig { "orig" } else { "rust" };
         // Dump GfxResource object + first sub-object
-        let gr_data = core::slice::from_raw_parts(gfx_resource, 0x100);
+        let gr_data = core::slice::from_raw_parts(gfx_resource as *const u8, 0x100);
         let _ = std::fs::write(format!("gfx_resource_{}.bin", tag), gr_data);
     }
 
@@ -707,7 +709,7 @@ unsafe fn init_graphics_and_resources(
     // SpriteRegion__Constructor: fastcall(ECX, EDX) + 6 stack(this, p2, p3, p4, p5, p6), RET 0x18
     {
         // (array_index, ECX, EDX, p2, p3, p4, p5, p6=gfx_resource)
-        // p6 is the GfxResource pointer returned by GfxResource__Create_Maybe.
+        // p6 is the GfxResource pointer returned by IMG__LoadFromDir.
         let gr = gfx_resource as u32;
         let regions: [(usize, u32, u32, u32, u32, u32, u32, u32); 8] = [
             (2, 0x37, 0x36, 0x2E, 0x24, 0x41, 0x2D, gr),
@@ -756,22 +758,27 @@ unsafe fn init_graphics_and_resources(
 
             let entry = gfx_dir_find_entry(name_buf.as_ptr().cast(), gfx_dir);
 
-            let sprite: *mut u8;
-            if !entry.is_null() {
+            let decoded = if !entry.is_null() {
                 let entry_val = *(entry.add(4) as *const u32);
                 let cached = GfxDir::load_cached_raw(gfx_dir, entry_val);
                 if !cached.is_null() {
-                    sprite = wa_displaygfx_ctor(cached);
+                    let grid = wa_displaygfx_ctor(layer_ctx, cached);
+                    if !grid.is_null() {
+                        Some(DecodedBitGrid::Display(grid as *mut DisplayBitGrid))
+                    } else {
+                        None
+                    }
                 } else {
-                    // Fallback: load from file via GfxDir__LoadImage + IMG_Decode
-                    sprite = call_gfx_load_and_wrap(gfx_dir, name_buf.as_ptr().cast(), layer_ctx);
+                    call_gfx_load_and_wrap(gfx_dir, name_buf.as_ptr().cast(), layer_ctx)
                 }
             } else {
-                // Entry not found — try direct file load
-                sprite = call_gfx_load_and_wrap(gfx_dir, name_buf.as_ptr().cast(), layer_ctx);
-            }
+                call_gfx_load_and_wrap(gfx_dir, name_buf.as_ptr().cast(), layer_ctx)
+            };
 
             // Store arrow sprite at DDGame+0x38+i*4
+            let sprite = decoded
+                .map(|d| d.as_bitgrid_ptr())
+                .unwrap_or(core::ptr::null_mut());
             (*ddgame).arrow_sprites[i as usize] = sprite;
 
             // Calculate collision region dimensions from sprite.
@@ -780,9 +787,8 @@ unsafe fn init_graphics_and_resources(
             //   right/bottom = dim - margin
             // Result: this[5]=this[6]=10 for sprites >20px (the 10px inset).
             if !sprite.is_null() {
-                let grid = &*(sprite as *const BitGrid);
-                let sprite_w = grid.width as i32;
-                let sprite_h = grid.height as i32;
+                let sprite_w = (*sprite).width as i32;
+                let sprite_h = (*sprite).height as i32;
                 let margin_w = (sprite_w / 2 - 10).max(0);
                 let margin_h = (sprite_h / 2 - 10).max(0);
 
@@ -807,12 +813,12 @@ unsafe fn init_graphics_and_resources(
 
             // Arrow GfxDir (conditional on secondary gfxdir)
             if !(*ddgame).secondary_palette_ctx.is_null() {
-                let gfx_resource_create: unsafe extern "thiscall" fn(
+                let wa_img_load_from_dir: unsafe extern "thiscall" fn(
                     *mut GfxDir,
                     *mut u8,
-                ) -> *mut u8 = core::mem::transmute(rb(va::GFX_RESOURCE_CREATE) as usize);
+                ) -> *mut u8 = core::mem::transmute(rb(va::IMG_LOAD_FROM_DIR) as usize);
                 (*ddgame).arrow_gfxdirs[i as usize] =
-                    gfx_resource_create(gfx_dir, core::ptr::null_mut());
+                    wa_img_load_from_dir(gfx_dir, core::ptr::null_mut());
             }
         }
     }
@@ -821,7 +827,8 @@ unsafe fn init_graphics_and_resources(
     // vtable[3] = DisplayGfx__vmethod_3: thiscall(this, byte param_2), RET 4.
     if !gfx_resource.is_null() {
         let rvt = *(gfx_resource as *const *const u32);
-        let release: unsafe extern "thiscall" fn(*mut u8, u8) = core::mem::transmute(*rvt.add(3));
+        let release: unsafe extern "thiscall" fn(*mut crate::bitgrid::BitGrid, u8) =
+            core::mem::transmute(*rvt.add(3));
         release(gfx_resource, 1);
     }
 
@@ -956,8 +963,10 @@ unsafe fn init_graphics_and_resources(
 
         if s_var1 < 0x61 && level_height == 0x2B8 {
             // Simple gradient: load gradient.img directly
-            let gradient = call_gfx_find_and_load(land_dir, c"gradient.img", layer3_ctx);
-            (*ddgame).gradient_image = gradient;
+            (*ddgame).gradient_image =
+                call_gfx_find_and_load(land_dir, c"gradient.img", layer3_ctx)
+                    .map(|d| d.as_bitgrid_ptr())
+                    .unwrap_or(core::ptr::null_mut());
         } else {
             compute_complex_gradient(ddgame, land_dir, layer3_ctx, s_var1);
         }
@@ -965,19 +974,18 @@ unsafe fn init_graphics_and_resources(
         // ── Fill image → fill_pixel (0x7338) ──
         {
             let layer2_ctx = (*(*ddgame).display).set_active_layer(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 = call_gfx_find_and_load(water_dir, c"fill.img", layer2_ctx);
-            if !fill_sprite.is_null() {
-                // Get pixel value: fill_sprite->vtable[4](0, 0)
-                let fill_vt = *(fill_sprite as *const *const u32);
-                let get_pixel: unsafe extern "thiscall" fn(*mut u8, i32, i32) -> u32 =
+            if let Some(decoded) = fill_sprite {
+                let ptr = decoded.as_bitgrid_ptr();
+                // Get pixel value: vtable[4](0, 0)
+                let fill_vt = *(ptr as *const *const u32);
+                let get_pixel: unsafe extern "thiscall" fn(*mut BitGrid, i32, i32) -> u32 =
                     core::mem::transmute(*fill_vt.add(4));
-                (*ddgame).fill_pixel = get_pixel(fill_sprite, 0, 0);
-                // Release fill sprite: vtable[3] = DisplayGfx__vmethod_3(this, param_2=1)
-                let release: unsafe extern "thiscall" fn(*mut u8, u8) =
+                (*ddgame).fill_pixel = get_pixel(ptr, 0, 0);
+                // Release: vtable[3](this, flags=1)
+                let release: unsafe extern "thiscall" fn(*mut BitGrid, u8) =
                     core::mem::transmute(*fill_vt.add(3));
-                release(fill_sprite, 1);
+                release(ptr, 1);
             }
         }
 
@@ -1006,7 +1014,7 @@ unsafe fn init_graphics_and_resources(
         if !obj.is_null() {
             (*obj).vtable = rb(va::BIT_GRID_BASE_VTABLE) as *const BitGridBaseVtable;
             // height = 0 → CTaskLand skips the gradient column loop
-            (*ddgame).gradient_image = obj as *mut u8;
+            (*ddgame).gradient_image = obj;
         }
     }
 

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

@@ -117,18 +117,19 @@ pub(crate) unsafe fn compute_complex_gradient(
     let mut palette = PaletteContext::new();
 
     // Step 1: Load gradient.img
-    let gradient_sprite = call_gfx_find_and_load(land_dir, c"gradient.img", layer3_ctx);
-    if gradient_sprite.is_null() {
-        return;
-    }
+    let gradient_decoded = call_gfx_find_and_load(land_dir, c"gradient.img", layer3_ctx);
+    let gradient_sprite = match gradient_decoded {
+        Some(d) => d.as_bitgrid_ptr(),
+        None => return,
+    };
 
     // Sprite height from BitGrid layout (shared vtable 0x6640EC)
-    let gradient_height = (*(gradient_sprite as *const BitGrid)).height as i32;
+    let gradient_height = (*gradient_sprite).height as i32;
     if gradient_height <= 0 {
         return;
     }
 
-    let get_pixel: unsafe extern "thiscall" fn(*mut u8, i32, i32) -> u32 =
+    let get_pixel: unsafe extern "thiscall" fn(*mut BitGrid, i32, i32) -> u32 =
         core::mem::transmute(*(*(gradient_sprite as *const *const u32)).add(4));
 
     // Step 2: Compute target rows and stretch gradient through palette
@@ -146,8 +147,9 @@ pub(crate) unsafe fn compute_complex_gradient(
 
     // Step 3: If heights match, also set gradient_image_2
     if target_rows == gradient_height {
-        let gradient2 = call_gfx_find_and_load(land_dir, c"gradient.img", layer3_ctx);
-        (*ddgame).gradient_image_2 = gradient2;
+        (*ddgame).gradient_image_2 = call_gfx_find_and_load(land_dir, c"gradient.img", layer3_ctx)
+            .map(|d| d.as_bitgrid_ptr())
+            .unwrap_or(core::ptr::null_mut());
     }
 
     // Step 4: Sample 7 anchor colors by averaging 8×2 pixel blocks.
@@ -184,7 +186,7 @@ pub(crate) unsafe fn compute_complex_gradient(
 
     // Release the gradient sprite
     let gvt = *(gradient_sprite as *const *const u32);
-    let release: unsafe extern "thiscall" fn(*mut u8, u8) = core::mem::transmute(*gvt.add(3));
+    let release: unsafe extern "thiscall" fn(*mut BitGrid, u8) = core::mem::transmute(*gvt.add(3));
     release(gradient_sprite, 1);
 
     // Step 5: Establish initial/fallback color via palette closest-match.
@@ -256,5 +258,5 @@ pub(crate) unsafe fn compute_complex_gradient(
     (*gfx_obj).row_stride = stride;
     (*gfx_obj).width = 0;
     (*gfx_obj).height = total_height as u32;
-    (*ddgame).gradient_image = gfx_obj as *mut u8;
+    (*ddgame).gradient_image = gfx_obj;
 }

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

@@ -8,14 +8,14 @@
 //! - `DDGame__InitFields` (0x526120): usercall(EDI=ddgame), plain RET → EAX=ddgame
 //! - `DDGame__InitRenderIndices` (0x526080): usercall(ESI=base), plain RET → EAX=base
 //! - `BitGrid__Init` (0x4F6370): usercall(ESI,ECX,EDI) + 1 stack, RET 0x4
-//! - `GfxResource__Create_Maybe` (0x4F6300): usercall(ECX,EAX) + 1 stack, RET 0x4
+//! - `IMG__LoadFromDir` (0x4F6300): usercall(ECX,EAX) + 1 stack, RET 0x4
 //! - `FUN_570E20` (display layer init): usercall(ESI=wrapper), plain RET
 
 use crate::hook;
 use core::ffi::c_char;
 use openwa_core::address::va;
 use openwa_core::asset::gfx_dir::{
-    gfx_dir_find_entry, gfx_dir_load_dir, gfx_resource_create, GfxDir,
+    gfx_dir_find_entry, gfx_dir_load_dir, img_load_from_dir, GfxDir,
 };
 use openwa_core::bitgrid::BitGrid;
 use openwa_core::engine::game_state_init::{
@@ -95,9 +95,9 @@ extern "cdecl" fn impl_display_layer_init(wrapper: *mut DDGameWrapper) -> *mut D
     wrapper
 }
 
-// ─── GfxResource__Create_Maybe (0x4F6300) ───────────────────────────────────
+// ─── IMG__LoadFromDir (0x4F6300) ───────────────────────────────────
 
-extern "cdecl" fn impl_gfx_resource_create(
+extern "cdecl" fn impl_img_load_from_dir(
     gfx_dir: *mut GfxDir,
     name: *const c_char,
     output: *mut u8,
@@ -106,12 +106,12 @@ extern "cdecl" fn impl_gfx_resource_create(
     // WA caller always passes a `PaletteContext*` (verified at all known
     // call sites — `set_active_layer`'s return value).
     let output = output as *mut openwa_core::render::palette::PaletteContext;
-    let result = unsafe { gfx_resource_create(gfx_dir, name, output) };
+    let result = unsafe { img_load_from_dir(gfx_dir, name, output) };
     result as u32
 }
 
 #[unsafe(naked)]
-unsafe extern "C" fn gfx_resource_create_trampoline() {
+unsafe extern "C" fn img_load_from_dir_trampoline() {
     core::arch::naked_asm!(
         "push edx",
         "push [esp+8]",       // output (stack param)
@@ -121,7 +121,7 @@ unsafe extern "C" fn gfx_resource_create_trampoline() {
         "add esp, 12",
         "pop edx",
         "ret 0x4",
-        impl_fn = sym impl_gfx_resource_create,
+        impl_fn = sym impl_img_load_from_dir,
     );
 }
 
@@ -197,9 +197,9 @@ pub fn install() -> Result<(), String> {
         )?;
 
         hook::install(
-            "GfxResource__Create",
-            va::GFX_RESOURCE_CREATE,
-            gfx_resource_create_trampoline as *const (),
+            "IMG__LoadFromDir",
+            va::IMG_LOAD_FROM_DIR,
+            img_load_from_dir_trampoline as *const (),
         )?;
 
         hook::install(

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

@@ -1,7 +1,6 @@
-//! GfxDir and GfxDirStream vtable replacements + LoadImage hook.
+//! GfxDir, GfxDirStream, and IMG decoder replacements.
 //!
-//! Replaces the file I/O and stream vtable methods with Rust implementations,
-//! and hooks GfxDir__LoadImage for any remaining WA callers.
+//! Replaces vtable methods, LoadImage, IMG_Decode, and DisplayGfx__Constructor.
 
 use core::ffi::c_char;
 use openwa_core::address::va;
@@ -10,7 +9,10 @@ use openwa_core::asset::gfx_dir::{
     gfx_dir_stream_bytes_consumed, gfx_dir_stream_destructor, gfx_dir_stream_get_total_size,
     gfx_dir_stream_has_data, gfx_dir_stream_read, gfx_dir_stream_seek, GfxDir, GfxDirStream,
 };
+use openwa_core::asset::img::{img_decode, img_decode_cached};
+use openwa_core::bitgrid::BitGrid;
 use openwa_core::log::log_line;
+use openwa_core::render::palette::PaletteContext;
 
 // ─── GfxDir__LoadImage (0x5666D0) ───────────────────────────────────────────
 // Convention: usercall(ESI=gfx_dir) + 1 stack(name), RET 0x4.
@@ -33,6 +35,47 @@ unsafe extern "C" fn load_image_trampoline() {
     );
 }
 
+// ─── IMG_Decode (0x4F5F80) ──────────────────────────────────────────────────
+// Convention: stdcall(palette_ctx, stream, align_flag), RET 0xC.
+
+unsafe extern "stdcall" fn img_decode_hook(
+    palette_ctx: *mut PaletteContext,
+    stream: *mut GfxDirStream,
+    align_flag: i32,
+) -> *mut BitGrid {
+    match img_decode(palette_ctx, stream, align_flag) {
+        Some(decoded) => decoded.as_bitgrid_ptr(),
+        None => core::ptr::null_mut(),
+    }
+}
+
+// ─── DisplayGfx__Constructor (0x4F5E80) ─────────────────────────────────────
+// Convention: stdcall(raw_image), RET 0x4.
+// PaletteContext passed implicitly via EBX (callee-saved from caller).
+
+extern "cdecl" fn impl_displaygfx_ctor(
+    palette_ctx: *mut PaletteContext,
+    raw_image: *mut u8,
+) -> *mut u8 {
+    unsafe { img_decode_cached(palette_ctx, raw_image) as *mut u8 }
+}
+
+#[unsafe(naked)]
+unsafe extern "C" fn displaygfx_ctor_trampoline() {
+    core::arch::naked_asm!(
+        "push edx",
+        "push ecx",
+        "push [esp+12]",    // raw_image (stack param, shifted by 2 pushes)
+        "push ebx",          // palette_ctx (EBX, callee-saved from caller)
+        "call {impl_fn}",
+        "add esp, 8",
+        "pop ecx",
+        "pop edx",
+        "ret 0x4",           // callee cleans 1 stack param
+        impl_fn = sym impl_displaygfx_ctor,
+    );
+}
+
 pub fn install() -> Result<(), String> {
     use openwa_core::vtable_replace;
 
@@ -58,8 +101,16 @@ pub fn install() -> Result<(), String> {
             va::GFX_DIR_LOAD_IMAGE,
             load_image_trampoline as *const (),
         )?;
+
+        crate::hook::install("IMG_Decode", va::IMG_DECODE, img_decode_hook as *const ())?;
+
+        crate::hook::install(
+            "DisplayGfx__Constructor",
+            va::IMG_DECODE_CACHED,
+            displaygfx_ctor_trampoline as *const (),
+        )?;
     }
 
-    let _ = log_line("[GfxDir] All vtable methods + LoadImage replaced");
+    let _ = log_line("[GfxDir] All vtable methods + LoadImage + IMG_Decode replaced");
     Ok(())
 }