feat: port LoadSpriteByLayer (slot 37) and LoadSpriteByName to pure Rust
Browse filesPort 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>
|
@@ -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
|
| 1667 |
-
///
|
| 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) —
|
| 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 |
-
|
| 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 |
-
|
| 1713 |
-
|
| 1714 |
-
|
| 1715 |
-
|
| 1716 |
|
| 1717 |
-
// Load
|
| 1718 |
-
let result =
|
| 1719 |
if result == 0 {
|
| 1720 |
-
|
| 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 |
|
|
@@ -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)
|
|
@@ -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 {
|
|
@@ -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
|
|
@@ -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 |
-
//
|
| 1607 |
-
//
|
| 1608 |
-
//
|
| 1609 |
|
| 1610 |
-
|
| 1611 |
-
|
| 1612 |
-
|
| 1613 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 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
|
| 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(())
|