paavohtl Claude Opus 4.6 (1M context) commited on
Commit
30d0cba
·
1 Parent(s): 43b6a0b

feat: port LoadSpriteByLayer (slot 37) and LoadSpriteByName to pure Rust

Browse files

Port the layer sprite loading pipeline to Rust, eliminating all usercall
bridges. This enables load_sprite_by_layer (vtable slot 37, 0x56A4C0) to
be fully hooked via vtable_replace.

Key functions ported:
- LoadSpriteByName (FUN_005733b0): reads .spr header, palette, frame pixel
data from GfxDir stream; creates software surfaces via RenderContext
- FreeLayerSprite (FUN_0056a2f0): destroys surfaces and frees the sprite
- RemapPixelsThroughLut (FUN_005b2beb): palette index remapping on pixel buffers

New types:
- LayerSprite (0x70 bytes): background/water layer sprite object
- LayerSpriteFrame (0x14 bytes): per-frame surface with bounding box
- GfxDirStream / GfxDirStreamVtable: typed wrapper for .dir archive reader

Notable findings during porting:
- Ghidra's unaff_ESI/unaff_EBP were decompiler artifacts, not caller-frame
reads — both registers are set within the function
- RenderContext::alloc_surface returns the pointer in EAX, not via the
FastcallResult buffer
- .spr palette entry 0 is implicit transparent; file RGB data maps to
palette LUT entries 1+, not 0+

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

crates/openwa-core/src/render/display/vtable.rs CHANGED
@@ -1,5 +1,6 @@
1
  use crate::fixed::Fixed;
2
  use crate::render::display::line_draw::Vertex;
 
3
  use crate::render::SpriteCache;
4
  use crate::wa_alloc::wa_malloc_struct_zeroed;
5
 
@@ -1659,38 +1660,332 @@ pub unsafe fn load_sprite(
1659
  1
1660
  }
1661
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1662
  /// Port of DisplayGfx::LoadSpriteByLayer (vtable slot 37, 0x56A4C0).
1663
  ///
1664
  /// Simplified sprite loading that stores into DisplayGfx::sprite_table
1665
  /// (offset 0x3DD4) instead of DisplayBase::sprite_ptrs. Allocates a raw
1666
- /// 0x70-byte object, partially initializes it (NOT via ConstructSprite),
1667
- /// then loads via FUN_005733b0.
1668
  ///
1669
  /// # Safety
1670
  /// `this` must be a valid `*mut DisplayGfx`.
1671
- /// `load_fn` must be a valid function pointer to FUN_005733b0.
1672
- /// `free_fn` must be a valid function pointer to FUN_0056a2f0.
1673
  pub unsafe fn load_sprite_by_layer(
1674
  this: *mut DisplayGfx,
1675
  layer: u32,
1676
  id: u32,
1677
  gfx: *mut u8,
1678
  name: *const core::ffi::c_char,
1679
- load_fn: unsafe extern "cdecl" fn(
1680
- sprite: *mut u8,
1681
- gfx: *mut u8,
1682
- id: u32,
1683
- name: *const core::ffi::c_char,
1684
- ) -> i32,
1685
- free_fn: unsafe extern "cdecl" fn(sprite: *mut u8),
1686
  ) -> i32 {
 
 
1687
  // Bit 23 set = already loaded sentinel
1688
  if id & 0x80_0000 != 0 {
1689
  return 1;
1690
  }
1691
 
1692
- // Call set_active_layer (vtable slot 5) — already ported Rust
1693
- set_active_layer(this, layer as i32);
1694
 
1695
  if !is_valid_sprite_id(id as i32) {
1696
  return 0;
@@ -1702,27 +1997,27 @@ pub unsafe fn load_sprite_by_layer(
1702
  }
1703
 
1704
  // Allocate 0x70 bytes + 0x20 guard (matching WA_MallocMemset behavior)
1705
- use crate::wa_alloc::wa_malloc_zeroed;
1706
- let sprite = wa_malloc_zeroed(0x90);
1707
  if sprite.is_null() {
1708
  return 0;
1709
  }
1710
 
1711
  // Partial init (NOT ConstructSprite — different from load_sprite)
1712
- *(sprite.add(0x58) as *mut *mut DisplayGfx) = this;
1713
- *(sprite.add(0x66) as *mut u16) = 0;
1714
- *(sprite.add(0x6C) as *mut u32) = 0;
1715
- *(sprite.add(0x54) as *mut u32) = 0;
1716
 
1717
- // Load via FUN_005733b0
1718
- let result = load_fn(sprite, gfx, id, name);
1719
  if result == 0 {
1720
- free_fn(sprite);
1721
  return 0;
1722
  }
1723
 
1724
  // Store in sprite_table (DisplayGfx offset 0x3DD4)
1725
  (*this).sprite_table[id as usize] = sprite as u32;
 
1726
  1
1727
  }
1728
 
 
1
  use crate::fixed::Fixed;
2
  use crate::render::display::line_draw::Vertex;
3
+ use crate::render::sprite::sprite::{LayerSprite, LayerSpriteFrame};
4
  use crate::render::SpriteCache;
5
  use crate::wa_alloc::wa_malloc_struct_zeroed;
6
 
 
1660
  1
1661
  }
1662
 
1663
+ /// Port of FUN_005733b0 — load sprite data from GfxDir stream.
1664
+ ///
1665
+ /// Original convention: `usercall(EDI=sprite, ECX=gfx_dir) + stack(palette_ctx, name), RET 0x8`.
1666
+ /// Ported to a regular Rust function — no usercall bridge needed.
1667
+ ///
1668
+ /// Reads sprite header, palette, and frame pixel data from a `.dir` archive stream.
1669
+ /// In headless mode (g_DisplayModeFlag != 0), skips all surface creation.
1670
+ ///
1671
+ /// # Safety
1672
+ /// All pointers must be valid. `sprite` must be a zeroed 0x70-byte allocation.
1673
+ pub unsafe fn load_sprite_by_name(
1674
+ sprite: *mut LayerSprite,
1675
+ gfx_dir: *mut u8,
1676
+ palette_ctx: *mut PaletteContext,
1677
+ name: *const core::ffi::c_char,
1678
+ ) -> i32 {
1679
+ use crate::address::va;
1680
+ use crate::rebase::rb;
1681
+ use crate::render::display::context::{FastcallResult, RenderContext};
1682
+ use crate::render::palette::{palette_map_color, remap_pixels_through_lut};
1683
+ use crate::render::sprite::gfx_dir::{call_gfx_load_image, GfxDirStream};
1684
+
1685
+ use crate::wa_alloc::wa_malloc;
1686
+
1687
+ let sp = sprite as *mut u8;
1688
+
1689
+ // 1. Copy name into sprite.name (max 0x4F chars + null)
1690
+ let name_dest = (*sprite).name.as_mut_ptr();
1691
+ let mut i = 0usize;
1692
+ while i < 0x4F {
1693
+ let ch = *name.add(i);
1694
+ *name_dest.add(i) = ch as u8;
1695
+ if ch == 0 {
1696
+ break;
1697
+ }
1698
+ i += 1;
1699
+ }
1700
+ *name_dest.add(i.min(0x4F)) = 0;
1701
+
1702
+ // 2. Store gfx_dir and palette_ctx in sprite
1703
+ (*sprite).gfx_dir = gfx_dir;
1704
+ (*sprite).palette_ctx = palette_ctx as u32;
1705
+
1706
+ // 3. Load image stream from GfxDir
1707
+ let stream = call_gfx_load_image(gfx_dir, name) as *mut GfxDirStream;
1708
+ if stream.is_null() {
1709
+ return 0;
1710
+ }
1711
+
1712
+ // 5. Check headless mode — skip all surface creation if g_DisplayModeFlag != 0
1713
+ let display_mode_flag = *(rb(va::G_DISPLAY_MODE_FLAG) as *const u8);
1714
+ if display_mode_flag == 0 {
1715
+ // ── Graphics path: read header, palette, allocate surfaces ──
1716
+
1717
+ // Read and discard: remaining() result (original calls vtable[2])
1718
+ GfxDirStream::remaining_raw(stream);
1719
+
1720
+ // Read .spr header as 4+4+2+2 separate calls, matching the original exactly.
1721
+ // The stream seeks before each read; matching the original's read granularity
1722
+ // may matter for internal stream state.
1723
+ let mut hdr4 = [0u8; 4];
1724
+ GfxDirStream::read_raw(stream, hdr4.as_mut_ptr(), 4); // unused/version
1725
+ GfxDirStream::read_raw(stream, hdr4.as_mut_ptr(), 4); // data_size
1726
+
1727
+ let mut header_flags: u16 = 0;
1728
+ GfxDirStream::read_raw(stream, &mut header_flags as *mut u16 as *mut u8, 2);
1729
+
1730
+ let mut palette_count: u32 = 0;
1731
+ GfxDirStream::read_raw(stream, &mut palette_count as *mut u32 as *mut u8, 2);
1732
+
1733
+ // Build palette LUT: bulk-read all RGB triplets then iterate.
1734
+ let mut palette_lut = [0u8; 256];
1735
+ let lut_count = (palette_count as usize).min(256);
1736
+ let bulk_size = palette_count as usize * 3;
1737
+ let mut palette_data = [0u8; 768]; // max 256 * 3
1738
+ GfxDirStream::read_raw(stream, palette_data.as_mut_ptr(), bulk_size as u32);
1739
+
1740
+ // Palette entry 0 is always transparent (display index 0).
1741
+ // The palette RGB data in the file defines entries 1..palette_count,
1742
+ // NOT entry 0. So palette_data[0..3] maps to lut[1], etc.
1743
+ palette_lut[0] = 0;
1744
+ for idx in 0..lut_count {
1745
+ let r = palette_data[idx * 3];
1746
+ let g = palette_data[idx * 3 + 1];
1747
+ let b = palette_data[idx * 3 + 2];
1748
+
1749
+ if r == 0 && g == 0 && b == 0 {
1750
+ palette_lut[idx + 1] = 0;
1751
+ } else {
1752
+ let rgb = (r as u32) | ((g as u32) << 8) | ((b as u32) << 16);
1753
+ let mapped = palette_map_color(palette_ctx, rgb);
1754
+ palette_lut[idx + 1] = mapped as u8;
1755
+ }
1756
+ }
1757
+
1758
+ // Read sprite metadata fields
1759
+ GfxDirStream::read_raw(stream, sp.add(0x60), 4); // field_60
1760
+ GfxDirStream::read_raw(stream, sp.add(0x64), 2); // field_64
1761
+ GfxDirStream::read_raw(stream, sp.add(0x68), 2); // field_68
1762
+ GfxDirStream::read_raw(stream, sp.add(0x6A), 2); // field_6a
1763
+
1764
+ // frame_count: zero first, then read
1765
+ (*sprite).frame_count = 0;
1766
+ GfxDirStream::read_raw(stream, sp.add(0x66), 2);
1767
+ let frame_count = (*sprite).frame_count as usize;
1768
+
1769
+ // Allocate LayerSpriteFrame array (counted array: count at [-4])
1770
+ // Size per element: 0x14, with 4-byte count prefix
1771
+ let total_elems = frame_count;
1772
+ // Overflow check matching original (saturate on overflow)
1773
+ let checked_count = total_elems as u32;
1774
+ let checked_size = checked_count.checked_mul(0x14).unwrap_or(u32::MAX);
1775
+ let checked_alloc = checked_size.checked_add(4).unwrap_or(u32::MAX);
1776
+
1777
+ let array_base = wa_malloc(checked_alloc);
1778
+ let frame_array = if !array_base.is_null() {
1779
+ *(array_base as *mut u32) = checked_count; // store count at [-4]
1780
+ let arr = array_base.add(4);
1781
+ // Construct each element: set vtable at +0x08, zero surface at +0x0C
1782
+ let bitmap_vtable = rb(0x00643F64) as u32; // CBitmap vtable (set by constructor at 0x573C30)
1783
+ for j in 0..total_elems {
1784
+ let elem = arr.add(j * 0x14);
1785
+ *(elem.add(0x08) as *mut u32) = bitmap_vtable;
1786
+ *(elem.add(0x0C) as *mut u32) = 0;
1787
+ }
1788
+ arr
1789
+ } else {
1790
+ core::ptr::null_mut()
1791
+ };
1792
+ (*sprite).frame_array = frame_array as *mut LayerSpriteFrame;
1793
+
1794
+ // Skip alignment padding: while (remaining() & 3) != 0, read 1 dummy byte
1795
+ loop {
1796
+ let remaining = GfxDirStream::remaining_raw(stream);
1797
+ if remaining & 3 == 0 {
1798
+ break;
1799
+ }
1800
+ let mut dummy = 0u8;
1801
+ GfxDirStream::read_raw(stream, &mut dummy, 1);
1802
+ }
1803
+
1804
+ // Read frame headers
1805
+ if frame_count > 0 && !frame_array.is_null() {
1806
+ for j in 0..frame_count {
1807
+ let elem = frame_array.add(j * 0x14);
1808
+ // Read 4-byte unknown header (discarded)
1809
+ let mut frame_hdr = [0u8; 4];
1810
+ GfxDirStream::read_raw(stream, frame_hdr.as_mut_ptr(), 4);
1811
+ // Read 4x u16: start_x, start_y, end_x, end_y
1812
+ GfxDirStream::read_raw(stream, elem, 2); // start_x
1813
+ GfxDirStream::read_raw(stream, elem.add(2), 2); // start_y
1814
+ GfxDirStream::read_raw(stream, elem.add(4), 2); // end_x
1815
+ GfxDirStream::read_raw(stream, elem.add(6), 2); // end_y
1816
+ }
1817
+ }
1818
+
1819
+ // Surface creation loop: create surfaces and read pixel data for each frame
1820
+ if frame_count > 0 && !frame_array.is_null() {
1821
+ let render_ctx = *(rb(va::G_RENDER_CONTEXT) as *const *mut RenderContext);
1822
+
1823
+ for j in 0..frame_count {
1824
+ let elem = frame_array.add(j * 0x14);
1825
+ let start_x = *(elem as *const i16) as i32;
1826
+ let start_y = *(elem.add(2) as *const i16) as i32;
1827
+ let end_x = *(elem.add(4) as *const i16) as i32;
1828
+ let end_y = *(elem.add(6) as *const i16) as i32;
1829
+
1830
+ let width = end_x - start_x;
1831
+ let height = end_y - start_y;
1832
+
1833
+ if width * height == 0 {
1834
+ continue;
1835
+ }
1836
+
1837
+ // Ensure surface exists at elem+0x0C
1838
+ // alloc_surface returns the surface pointer in EAX (the return value),
1839
+ // NOT via the FastcallResult buffer. The original code at 0x57367f
1840
+ // does: MOV [EBX+0xC], EAX — storing EAX directly.
1841
+ let surface_ptr = elem.add(0x0C) as *mut u32;
1842
+ if *surface_ptr == 0 {
1843
+ let mut buf = FastcallResult::default();
1844
+ let ret = RenderContext::alloc_surface_raw(render_ctx, &mut buf);
1845
+ *surface_ptr = ret as u32;
1846
+ }
1847
+ let surface = *surface_ptr as *mut u8;
1848
+ if surface.is_null() {
1849
+ continue;
1850
+ }
1851
+
1852
+ // Init surface: surface->vtable[5](width, height, 0)
1853
+ {
1854
+ let vt = *(surface as *const *const u32);
1855
+ let init_fn: unsafe extern "fastcall" fn(
1856
+ *mut u8,
1857
+ *mut FastcallResult,
1858
+ u32,
1859
+ u32,
1860
+ u32,
1861
+ ) = core::mem::transmute(*vt.add(5));
1862
+ let mut buf = FastcallResult::default();
1863
+ init_fn(surface, &mut buf, width as u32, height as u32, 0);
1864
+ }
1865
+
1866
+ // SetColorKey: surface->vtable[7](0, 0x10)
1867
+ {
1868
+ let vt = *(surface as *const *const u32);
1869
+ let set_ck_fn: unsafe extern "fastcall" fn(
1870
+ *mut u8,
1871
+ *mut FastcallResult,
1872
+ u32,
1873
+ u32,
1874
+ ) = core::mem::transmute(*vt.add(7));
1875
+ let mut buf = FastcallResult::default();
1876
+ set_ck_fn(surface, &mut buf, 0, 0x10);
1877
+ }
1878
+
1879
+ // Lock: surface->vtable[3](&out_data, &out_pitch)
1880
+ let mut data_ptr: u32 = 0;
1881
+ let mut pitch: u32 = 0;
1882
+ {
1883
+ let vt = *(surface as *const *const u32);
1884
+ let lock_fn: unsafe extern "fastcall" fn(
1885
+ *mut u8,
1886
+ *mut FastcallResult,
1887
+ *mut u32,
1888
+ *mut u32,
1889
+ ) = core::mem::transmute(*vt.add(3));
1890
+ let mut buf = FastcallResult::default();
1891
+ lock_fn(surface, &mut buf, &mut data_ptr, &mut pitch);
1892
+ }
1893
+
1894
+ if data_ptr != 0 && pitch != 0 {
1895
+ // Read pixel data row by row
1896
+ let data = data_ptr as *mut u8;
1897
+ for row in 0..height {
1898
+ let row_dest = data.add((row as u32 * pitch) as usize);
1899
+ GfxDirStream::read_raw(stream, row_dest, width as u32);
1900
+ }
1901
+
1902
+ // Remap pixels through palette LUT
1903
+ let width_dwords = ((width as u32) + 3) / 4;
1904
+ remap_pixels_through_lut(
1905
+ data,
1906
+ pitch,
1907
+ palette_lut.as_ptr(),
1908
+ width_dwords,
1909
+ height as u32,
1910
+ );
1911
+ }
1912
+
1913
+ // Unlock: surface->vtable[4](data_ptr)
1914
+ {
1915
+ let vt = *(surface as *const *const u32);
1916
+ let unlock_fn: unsafe extern "fastcall" fn(*mut u8, *mut FastcallResult, u32) =
1917
+ core::mem::transmute(*vt.add(4));
1918
+ let mut buf = FastcallResult::default();
1919
+ unlock_fn(surface, &mut buf, data_ptr);
1920
+ }
1921
+ }
1922
+ }
1923
+ }
1924
+
1925
+ // Destroy stream reader
1926
+ GfxDirStream::destroy_raw(stream);
1927
+ 1
1928
+ }
1929
+
1930
+ /// Free a LayerSprite and its associated surfaces.
1931
+ ///
1932
+ /// Port of FUN_0056a2f0 (usercall EDI=sprite, plain RET).
1933
+ /// Destroys each LayerSpriteFrame's surface via `surface->vtable[0](1)`,
1934
+ /// frees the counted array, then frees the sprite itself.
1935
+ ///
1936
+ /// # Safety
1937
+ /// `sprite` must be a valid LayerSprite pointer allocated via `wa_malloc`.
1938
+ pub unsafe fn free_layer_sprite(sprite: *mut LayerSprite) {
1939
+ use crate::wa_alloc::wa_free;
1940
+
1941
+ let frame_array = (*sprite).frame_array as *mut u8;
1942
+ if !frame_array.is_null() {
1943
+ let count_ptr = (frame_array as *mut u32).sub(1);
1944
+ let count = *count_ptr as usize;
1945
+
1946
+ // Destroy each frame's surface in reverse order
1947
+ // (matches eh_vector_destructor_iterator behavior)
1948
+ for i in (0..count).rev() {
1949
+ let elem = frame_array.add(i * 0x14);
1950
+ let surface = *(elem.add(0x0C) as *const u32);
1951
+ if surface != 0 {
1952
+ let vt = *(surface as *const *const u32);
1953
+ let dtor: unsafe extern "thiscall" fn(u32, u32) = core::mem::transmute(*vt);
1954
+ dtor(surface, 1);
1955
+ }
1956
+ }
1957
+
1958
+ wa_free(count_ptr);
1959
+ }
1960
+
1961
+ wa_free(sprite);
1962
+ }
1963
+
1964
  /// Port of DisplayGfx::LoadSpriteByLayer (vtable slot 37, 0x56A4C0).
1965
  ///
1966
  /// Simplified sprite loading that stores into DisplayGfx::sprite_table
1967
  /// (offset 0x3DD4) instead of DisplayBase::sprite_ptrs. Allocates a raw
1968
+ /// 0x70-byte LayerSprite, partially initializes it, then loads via
1969
+ /// `load_sprite_by_name` (pure Rust port of FUN_005733b0).
1970
  ///
1971
  /// # Safety
1972
  /// `this` must be a valid `*mut DisplayGfx`.
 
 
1973
  pub unsafe fn load_sprite_by_layer(
1974
  this: *mut DisplayGfx,
1975
  layer: u32,
1976
  id: u32,
1977
  gfx: *mut u8,
1978
  name: *const core::ffi::c_char,
 
 
 
 
 
 
 
1979
  ) -> i32 {
1980
+ use crate::wa_alloc::wa_malloc_zeroed;
1981
+
1982
  // Bit 23 set = already loaded sentinel
1983
  if id & 0x80_0000 != 0 {
1984
  return 1;
1985
  }
1986
 
1987
+ // Call set_active_layer (vtable slot 5) — returns PaletteContext*
1988
+ let palette_ctx = set_active_layer(this, layer as i32) as *mut PaletteContext;
1989
 
1990
  if !is_valid_sprite_id(id as i32) {
1991
  return 0;
 
1997
  }
1998
 
1999
  // Allocate 0x70 bytes + 0x20 guard (matching WA_MallocMemset behavior)
2000
+ let sprite = wa_malloc_zeroed(0x90) as *mut LayerSprite;
 
2001
  if sprite.is_null() {
2002
  return 0;
2003
  }
2004
 
2005
  // Partial init (NOT ConstructSprite — different from load_sprite)
2006
+ (*sprite).display_gfx = this;
2007
+ (*sprite).frame_count = 0;
2008
+ (*sprite).frame_array = core::ptr::null_mut();
2009
+ (*sprite).gfx_dir = core::ptr::null_mut();
2010
 
2011
+ // Load sprite data — pure Rust port of FUN_005733b0
2012
+ let result = load_sprite_by_name(sprite, gfx, palette_ctx, name);
2013
  if result == 0 {
2014
+ free_layer_sprite(sprite);
2015
  return 0;
2016
  }
2017
 
2018
  // Store in sprite_table (DisplayGfx offset 0x3DD4)
2019
  (*this).sprite_table[id as usize] = sprite as u32;
2020
+
2021
  1
2022
  }
2023
 
crates/openwa-core/src/render/palette.rs CHANGED
@@ -102,6 +102,38 @@ pub unsafe fn palette_map_color(ctx: *mut PaletteContext, rgb: u32) -> u32 {
102
  slot_idx as u32
103
  }
104
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
105
  crate::define_addresses! {
106
  class "PaletteContext" {
107
  /// PaletteContext__Init — usercall EAX=ctx* (no stack params)
 
102
  slot_idx as u32
103
  }
104
 
105
+ /// Remap each pixel in a buffer through a 256-byte lookup table.
106
+ ///
107
+ /// Port of FUN_005b2beb (stdcall, RET 0x14). Used by `load_sprite_by_name`
108
+ /// to apply the palette mapping to freshly-loaded sprite pixel data.
109
+ ///
110
+ /// Processes `width_dwords * 4` bytes per row, advancing by `pitch` bytes
111
+ /// between rows.
112
+ ///
113
+ /// # Safety
114
+ /// - `data` must point to a pixel buffer with at least `height` rows of
115
+ /// `pitch` bytes each.
116
+ /// - `lut` must point to a 256-byte lookup table.
117
+ /// - `width_dwords * 4` must not exceed `pitch`.
118
+ pub unsafe fn remap_pixels_through_lut(
119
+ data: *mut u8,
120
+ pitch: u32,
121
+ lut: *const u8,
122
+ width_dwords: u32,
123
+ height: u32,
124
+ ) {
125
+ let pixel_count = width_dwords * 4;
126
+ let mut row_ptr = data;
127
+ for _ in 0..height {
128
+ let mut p = row_ptr;
129
+ for _ in 0..pixel_count {
130
+ *p = *lut.add(*p as usize);
131
+ p = p.add(1);
132
+ }
133
+ row_ptr = row_ptr.add(pitch as usize);
134
+ }
135
+ }
136
+
137
  crate::define_addresses! {
138
  class "PaletteContext" {
139
  /// PaletteContext__Init — usercall EAX=ctx* (no stack params)
crates/openwa-core/src/render/sprite/gfx_dir.rs CHANGED
@@ -430,6 +430,62 @@ pub(crate) unsafe fn call_gfx_load_and_wrap(
430
  result
431
  }
432
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
433
  static mut GFX_LOAD_DIR_ADDR: u32 = 0;
434
 
435
  // GfxDir__LoadImage is usercall(ESI=gfx_dir) + 1 stack(name), RET 0x4.
@@ -454,7 +510,7 @@ pub(crate) unsafe fn call_gfx_load_dir(handler: *mut u8, addr: u32) -> i32 {
454
 
455
  #[cfg(target_arch = "x86")]
456
  #[unsafe(naked)]
457
- unsafe extern "C" fn call_gfx_load_image(
458
  _gfx_dir: *mut u8,
459
  _name: *const core::ffi::c_char,
460
  ) -> *mut u8 {
 
430
  result
431
  }
432
 
433
+ /// Stream reader returned by `GfxDir__LoadImage` (vtable 0x66A1C0).
434
+ ///
435
+ /// A 12-byte object wrapping a cached read position within a `.dir` archive.
436
+ /// Created by `GfxDir__LoadImage`, destroyed by calling `vtable[0](1)`.
437
+ ///
438
+ /// The vtable provides a sequential read interface over the cached resource data.
439
+ #[repr(C)]
440
+ pub struct GfxDirStream {
441
+ /// 0x00: Vtable pointer (0x66A1C0).
442
+ pub vtable: *const GfxDirStreamVtable,
443
+ /// 0x04: Cache slot index within the parent GfxDir.
444
+ pub slot_index: u32,
445
+ /// 0x08: Parent GfxDir pointer.
446
+ pub gfx_dir: *mut u8,
447
+ }
448
+
449
+ /// Vtable for GfxDirStream (6 slots at 0x66A1C0).
450
+ #[repr(C)]
451
+ pub struct GfxDirStreamVtable {
452
+ /// Slot 0 (0x5661E0): Destructor — releases cache slot, optionally frees.
453
+ pub destructor: unsafe extern "thiscall" fn(this: *mut GfxDirStream, flags: u32),
454
+ /// Slot 1 (0x566210): Returns 1 if read position < end position.
455
+ pub has_data: unsafe extern "thiscall" fn(this: *mut GfxDirStream) -> u32,
456
+ /// Slot 2 (0x566240): Returns remaining bytes (end - current position).
457
+ pub remaining: unsafe extern "thiscall" fn(this: *mut GfxDirStream) -> u32,
458
+ /// Slot 3 (0x566270): Unknown.
459
+ pub _slot_3: usize,
460
+ /// Slot 4 (0x5662C0): Unknown.
461
+ pub _slot_4: usize,
462
+ /// Slot 5 (0x5662F0): Read `size` bytes into `dest`.
463
+ pub read: unsafe extern "thiscall" fn(this: *mut GfxDirStream, dest: *mut u8, size: u32),
464
+ }
465
+
466
+ impl GfxDirStream {
467
+ /// Read `size` bytes from the stream into `dest`.
468
+ ///
469
+ /// # Safety
470
+ /// `this` must be a valid stream pointer. `dest` must have room for `size` bytes.
471
+ #[inline]
472
+ pub unsafe fn read_raw(this: *mut Self, dest: *mut u8, size: u32) {
473
+ ((*(*this).vtable).read)(this, dest, size);
474
+ }
475
+
476
+ /// Returns the number of bytes remaining in the stream.
477
+ #[inline]
478
+ pub unsafe fn remaining_raw(this: *mut Self) -> u32 {
479
+ ((*(*this).vtable).remaining)(this)
480
+ }
481
+
482
+ /// Destroy the stream reader, releasing its cache slot.
483
+ #[inline]
484
+ pub unsafe fn destroy_raw(this: *mut Self) {
485
+ ((*(*this).vtable).destructor)(this, 1);
486
+ }
487
+ }
488
+
489
  static mut GFX_LOAD_DIR_ADDR: u32 = 0;
490
 
491
  // GfxDir__LoadImage is usercall(ESI=gfx_dir) + 1 stack(name), RET 0x4.
 
510
 
511
  #[cfg(target_arch = "x86")]
512
  #[unsafe(naked)]
513
+ pub unsafe extern "C" fn call_gfx_load_image(
514
  _gfx_dir: *mut u8,
515
  _name: *const core::ffi::c_char,
516
  ) -> *mut u8 {
crates/openwa-core/src/render/sprite/sprite.rs CHANGED
@@ -180,6 +180,66 @@ pub struct SpriteBankVtable {
180
  pub slot_1: fn(this: *mut SpriteBank),
181
  }
182
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
183
  crate::define_addresses! {
184
  class "Sprite" {
185
  /// ConstructSprite — usercall EAX=sprite_ptr, ECX=context_ptr
 
180
  pub slot_1: fn(this: *mut SpriteBank),
181
  }
182
 
183
+ /// Layer sprite — 0x70-byte object used by `load_sprite_by_layer` (vtable slot 37).
184
+ ///
185
+ /// Unlike `Sprite` (which has a vtable and is created via ConstructSprite), this
186
+ /// is a raw allocation with partial init by the caller. Used for background layers
187
+ /// (back.spr, layer.spr) which load DirectDraw surfaces directly from `.dir` files.
188
+ #[repr(C)]
189
+ pub struct LayerSprite {
190
+ pub _pad_00: u32,
191
+ /// 0x04: Sprite name (null-terminated, max 0x50 bytes including null).
192
+ pub name: [u8; 0x50],
193
+ /// 0x54: GfxDir pointer (set by load_sprite_by_name).
194
+ pub gfx_dir: *mut u8,
195
+ /// 0x58: DisplayGfx pointer (set by caller before load).
196
+ pub display_gfx: *mut crate::render::display::gfx::DisplayGfx,
197
+ /// 0x5C: PaletteContext pointer (as u32, set by load_sprite_by_name).
198
+ pub palette_ctx: u32,
199
+ /// 0x60: Header field from stream (4 bytes).
200
+ pub field_60: u32,
201
+ /// 0x64: Header field from stream (2 bytes).
202
+ pub field_64: u16,
203
+ /// 0x66: Frame count (zeroed, then read from stream).
204
+ pub frame_count: u16,
205
+ /// 0x68: Header field from stream (2 bytes).
206
+ pub field_68: u16,
207
+ /// 0x6A: Header field from stream (2 bytes).
208
+ pub field_6a: u16,
209
+ /// 0x6C: Pointer to LayerSpriteFrame array (count stored at ptr[-4]).
210
+ pub frame_array: *mut LayerSpriteFrame,
211
+ }
212
+
213
+ const _: () = assert!(core::mem::size_of::<LayerSprite>() == 0x70);
214
+
215
+ /// Per-frame surface element for LayerSprite (0x14 bytes).
216
+ ///
217
+ /// Holds bounding box coordinates and a DirectDraw surface pointer.
218
+ /// Allocated in counted arrays: `malloc(count * 0x14 + 4)`, count at `[-4]`.
219
+ ///
220
+ /// Ghidra name: `CBitmap` (unrelated to `BitGrid`/`DisplayBitGrid`).
221
+ /// Constructor: 0x573C30 (sets vtable, zeroes surface).
222
+ /// Destructor: 0x5732E0 (releases surface via `surface->vtable[0](1)`).
223
+ #[repr(C)]
224
+ pub struct LayerSpriteFrame {
225
+ /// 0x00: Frame start X coordinate.
226
+ pub start_x: i16,
227
+ /// 0x02: Frame start Y coordinate.
228
+ pub start_y: i16,
229
+ /// 0x04: Frame end X coordinate.
230
+ pub end_x: i16,
231
+ /// 0x06: Frame end Y coordinate.
232
+ pub end_y: i16,
233
+ /// 0x08: CBitmap vtable pointer (set by constructor).
234
+ pub bitmap_vtable: u32,
235
+ /// 0x0C: Surface object pointer (created lazily by alloc_surface).
236
+ pub surface: u32,
237
+ /// 0x10: Reserved/padding.
238
+ pub _pad_10: u32,
239
+ }
240
+
241
+ const _: () = assert!(core::mem::size_of::<LayerSpriteFrame>() == 0x14);
242
+
243
  crate::define_addresses! {
244
  class "Sprite" {
245
  /// ConstructSprite — usercall EAX=sprite_ptr, ECX=context_ptr
crates/openwa-dll/src/replacements/render.rs CHANGED
@@ -1603,14 +1603,19 @@ unsafe extern "cdecl" fn wa_load_sprite_from_vfs(
1603
 
1604
  static mut LOAD_SPRITE_FROM_VFS_ADDR: u32 = 0;
1605
 
1606
- // LoadSpriteByLayer (vtable slot 37, 0x56A4C0) is NOT ported — the internal
1607
- // loader FUN_005733b0 is a 379-instruction DirectDraw surface creator with
1608
- // complex usercall conventions and caller-frame reads. Left as original WA code.
1609
 
1610
- // LoadSpriteComplex (slot 33) and LoadSpriteByLayer (slot 37) are NOT ported —
1611
- // their internal functions (FUN_005733b0, FUN_004FAD30, FUN_004F9710) have
1612
- // complex usercall conventions with caller-frame reads and DirectDraw surface
1613
- // creation. Left as original WA code.
 
 
 
 
 
1614
 
1615
  // ---------------------------------------------------------------------------
1616
  // Display installation
@@ -1679,8 +1684,9 @@ fn install_display() -> Result<(), String> {
1679
  update_palette => display_vtable::update_palette,
1680
  set_font_palette => set_font_palette,
1681
  slot 19 => blit_sprite,
 
1682
  })?;
1683
- let _ = log_line("[Display] DisplayGfx: patched 28 methods -> Rust");
1684
  }
1685
 
1686
  Ok(())
 
1603
 
1604
  static mut LOAD_SPRITE_FROM_VFS_ADDR: u32 = 0;
1605
 
1606
+ // LoadSpriteComplex (slot 33) is NOT ported — its internal functions
1607
+ // (0x4FAD30, 0x4F9710) use ESI for sprite/bank pointers in complex
1608
+ // usercall conventions that are impractical to bridge.
1609
 
1610
+ unsafe extern "thiscall" fn load_sprite_by_layer(
1611
+ this: *mut DisplayGfx,
1612
+ layer: u32,
1613
+ id: u32,
1614
+ gfx: *mut u8,
1615
+ name: *const core::ffi::c_char,
1616
+ ) -> i32 {
1617
+ display_vtable::load_sprite_by_layer(this, layer, id, gfx, name)
1618
+ }
1619
 
1620
  // ---------------------------------------------------------------------------
1621
  // Display installation
 
1684
  update_palette => display_vtable::update_palette,
1685
  set_font_palette => set_font_palette,
1686
  slot 19 => blit_sprite,
1687
+ load_sprite_by_layer => load_sprite_by_layer,
1688
  })?;
1689
+ let _ = log_line("[Display] DisplayGfx: patched 29 methods -> Rust");
1690
  }
1691
 
1692
  Ok(())