A GameCube/Wii emulator and debugger written in Rust.
gx texture prealoding. fixes cel damage
Layle8f8ebd69e7d5
diff --git a/crates/dbglib/src/windows/gx.rs b/crates/dbglib/src/windows/gx.rsindex 4e6a844..7fa1732 100644--- a/crates/dbglib/src/windows/gx.rs+++ b/crates/dbglib/src/windows/gx.rs@@ -289,7 +289,7 @@ pub fn show_gx<const SYSTEM: SystemId>();let tlut = gx.cur_tluts[slot];let base = (tlut.tmem_offset as usize) * 256;- let palette = gx.palette_mem.get(base..).unwrap_or(&[]);+ let palette = gx.tmem.get(base..).unwrap_or(&[]);ui.collapsing(heading, |ui| {texture_preview(ui, tex, &mmio.ram, palette, tlut);});diff --git a/crates/fifoplayer/src/playback.rs b/crates/fifoplayer/src/playback.rsindex 2cd6e80..f1f9ca4 100644--- a/crates/fifoplayer/src/playback.rs+++ b/crates/fifoplayer/src/playback.rs@@ -1,10 +1,10 @@-use gecko::flipper::gx::constants::{BP_REG_SIZE, CP_REG_SIZE};+use gecko::flipper::gx::constants::{BP_LOAD_TLUT1, BP_PRELOAD_MODE, BP_REG_SIZE, CP_REG_SIZE};use gecko::flipper::gx::{GraphicsProcessor, texture};use gecko::host::{DrawData, DrawSegment, DrawVertex, GxAction, RenderSink, XfbPart};use gecko::mmio::{Mmio, RamViewMut};use gecko::system::SystemId;-const BP_RESTORE_SKIP: &[usize] = &[0x45, 0x47, 0x48, 0x52, 0x65, 0xFE];+const BP_RESTORE_SKIP: &[usize] = &[0x45, 0x47, 0x48, 0x52, BP_PRELOAD_MODE, BP_LOAD_TLUT1, 0xFE];pub struct PlayerSink {inner: Box<dyn RenderSink>,@@ -101,14 +101,7 @@ impl<const SYSTEM: SystemId> Playback<SYSTEM> {}pub fn load_state(&mut self, file: &dff::DffFile, sink: &mut PlayerSink) {- for (i, entry) in self.gx.palette_mem.iter_mut().enumerate() {- let off = i * 2;- if off + 2 > file.tex_mem.len() {- break;- }-- *entry = u16::from_be_bytes([file.tex_mem[off], file.tex_mem[off + 1]]);- }+ self.gx.load_tmem(&file.tex_mem);let mut stream: Vec<u8> = Vec::with_capacity(32 * 1024);diff --git a/crates/gecko/src/flipper/gx.rs b/crates/gecko/src/flipper/gx.rsindex e1a99e9..46375bf 100644--- a/crates/gecko/src/flipper/gx.rs+++ b/crates/gecko/src/flipper/gx.rs@@ -1,6 +1,7 @@mod bp;pub mod constants;pub mod depth;+mod diagnostics;pub mod draw;pub mod fifo;#[cfg(feature = "jit")]@@ -11,6 +12,7 @@ pub mod regs;pub mod tev;mod texgen;pub mod texture;+mod tmem;mod vertex;mod xf;@@ -58,10 +60,10 @@ pub struct GraphicsProcessor {// Per-texture-slot TLUT binding (tmem offset + palette pixel format),// populated by BP_TX_SETTLUT writes.pub cur_tluts: [draw::TlutRef; 8],- // Palette TMEM: backing store for indexed texture palettes. Addressed as- // u16 entries; a LOADTLUT copies count*16 entries starting at- // (tmem_offset * 256). Fixed-size so indexing is branch-free.- pub palette_mem: Vec<u16>,+ // Shared 1 MiB TMEM for palettes and manually preloaded textures.+ // Entries hold guest big-endian u16s decoded to native order.+ pub tmem: Vec<u16>,+ pub(crate) tmem_generation: u64,pub cur_tev_color_env: [TevColorEnv; 16],pub cur_tev_alpha_env: [TevAlphaEnv; 16],pub cur_tev_color_regs_lo: [TevRegisterL; 4],@@ -216,7 +218,8 @@ impl GraphicsProcessor {cur_textures: Default::default(),tex_dirty: 0,cur_tluts: [draw::TlutRef::default(); 8],- palette_mem: vec![0u16; TLUT_MEM_ENTRIES],+ tmem: vec![0u16; constants::TMEM_SIZE / 2],+ tmem_generation: 0,cur_tev_color_env: Default::default(),cur_tev_alpha_env: Default::default(),cur_tev_color_regs_lo: Default::default(),@@ -598,7 +601,8 @@ impl GraphicsProcessor {w.bytes(bytemuck::cast_slice(&self.bp_regs));w.bytes(bytemuck::cast_slice(&self.cp_regs));w.bytes(bytemuck::cast_slice(&self.xf_mem));- w.bytes(bytemuck::cast_slice(&self.palette_mem));+ // Keep the original half-MiB layout; newer states append the rest.+ w.bytes(bytemuck::cast_slice(&self.tmem[..TLUT_MEM_ENTRIES]));w.bytes(&self.fifo);w.pod(&self.cur_textures);@@ -668,7 +672,7 @@ impl GraphicsProcessor {r.bytes_into(bytemuck::cast_slice_mut(&mut self.bp_regs))?;r.bytes_into(bytemuck::cast_slice_mut(&mut self.cp_regs))?;r.bytes_into(bytemuck::cast_slice_mut(&mut self.xf_mem))?;- r.bytes_into(bytemuck::cast_slice_mut(&mut self.palette_mem))?;+ r.bytes_into(bytemuck::cast_slice_mut(&mut self.tmem[..TLUT_MEM_ENTRIES]))?;self.fifo.clear();self.fifo.extend_from_slice(r.bytes()?);diff --git a/crates/gecko/src/flipper/gx/bp.rs b/crates/gecko/src/flipper/gx/bp.rsindex dbbaca3..53993ba 100644--- a/crates/gecko/src/flipper/gx/bp.rs+++ b/crates/gecko/src/flipper/gx/bp.rs@@ -1,7 +1,7 @@use super::constants::*;use super::recorder::MemoryUpdateType;use super::regs::*;-use super::{GraphicsProcessor, draw, texture};+use super::{GraphicsProcessor, diagnostics, draw, texture};use crate::host::{GxAction, RenderSink, TextureKey, TextureLod};use crate::mmio::{Mmio, RamView, RamViewMut};@@ -25,9 +25,13 @@ impl GraphicsProcessor {self.stats.bp_writes += 1;}+ if !diagnostics::bp_implemented(idx) {+ diagnostics::unimplemented("BP", idx, val);+ }+let command_write = matches!(idx,- BP_BP_MASK | BP_LOAD_TLUT1 | BP_PE_DONE | BP_PE_TOKEN | BP_PE_TOKEN_INT | BP_PE_COPY_CMD+ BP_BP_MASK | BP_LOAD_TLUT1 | BP_PRELOAD_MODE | BP_PE_DONE | BP_PE_TOKEN | BP_PE_TOKEN_INT | BP_PE_COPY_CMD);if val == old && !command_write {return;@@ -82,20 +86,14 @@ impl GraphicsProcessor {// LOADTLUT: writing TLUT1 triggers a copy from main RAM (address in// TLUT0, stored pre-shifted by 5) into our palette TMEM. Any paletted- // texture already bound is now looking at fresh palette bytes, so we- // must redecode it. We don't know which slots' TLUT regions overlap- // the load, so rescan all paletted slots (saw this in Dolphin @- // TMEM::InvalidateAll on LOADTLUT1).+ // texture already bound is now looking at fresh palette bytes.+ // Palettes and preloaded textures share TMEM, so invalidate both.if idx == BP_LOAD_TLUT1 {self.load_tlut(&ram.as_view(), val);- for slot in 0..self.cur_textures.len() {- let image0 = TxSetImage0::from_raw(- self.bp_regs[self::tx_slot_reg(BP_TX_SETIMAGE0_I0, BP_TX_SETIMAGE0_I4, slot)],- );- if image0.format().is_paletted() {- self.tex_dirty |= 1 << slot;- }- }+ self.invalidate_tmem();+ }+ if idx == BP_PRELOAD_MODE {+ self.preload_texture(&ram.as_view(), PreloadMode::from_raw(val));}if (BP_SU_SSIZE0..BP_SU_SIZE_END).contains(&idx) {@@ -299,7 +297,7 @@ impl GraphicsProcessor {);let tlut = self.cur_tluts[slot];- let palette = slot_palette(&self.palette_mem, tlut.tmem_offset);+ let palette = slot_palette(&self.tmem, tlut.tmem_offset);// Cache id mixes a hash of the bound palette content + tlut identity// into the high 32 bits so each distinct palette state for a CI*@@ -311,22 +309,37 @@ impl GraphicsProcessor {let mipmapped = mode0.min_filter().uses_mipmaps();let mip_levels = texture::mip_level_count(width, height, mode0.min_filter(), mode1.max_lod());let lod_key = if mipmapped { mip_levels } else { 0 };- let cache_id = self::texture_cache_id(ram_addr, format, tlut, palette, lod_key);+ let preloaded = self.texture_is_preloaded(slot);+ let mut cache_id = self::texture_cache_id(ram_addr, format, tlut, palette, lod_key);// Resolve the texture's raw bytes once, against MEM1 or MEM2. If the// address doesn't fall in either bank, leave the slot's last binding// alone but skip the decode (the renderer will keep its previous// texture for this id).let raw_size = texture::mip_data_size(width, height, format, mip_levels);- let tex_slice = ram.slice(ram_addr, raw_size);+ let tmem_bytes;+ let (tex_slice, generation) = if preloaded {+ let [even, odd] = self.texture_tmem_bases(slot);+ // Preloaded descriptors may leave IMAGE3 stale or share it among+ // unrelated textures. Keep these out of RAM/EFB cache entries.+ cache_id.ram_addr = 0x8000_0000 | even as u32;+ cache_id.variant ^= (odd as u32).wrapping_mul(0x85eb_ca6b);+ tmem_bytes = self.preloaded_texture_bytes(slot, width, height, format, mip_levels);+ (tmem_bytes.as_deref(), self.tmem_generation)+ } else {+ let generation = ram.range_generation(ram_addr, raw_size).unwrap_or(u64::MAX);+ (ram.slice(ram_addr, raw_size), generation)+ };- if tex_slice.is_some()+ if !preloaded+ && tex_slice.is_some()&& let Some(rec) = self.recorder.as_deref_mut(){rec.use_memory(ram, ram_addr as u32, raw_size, MemoryUpdateType::TextureMap);}- let gpu_copy = self.is_pending_gpu_copy(renderer, ram_addr as u32, width, height, format, mip_levels);+ let gpu_copy =+ !preloaded && self.is_pending_gpu_copy(renderer, ram_addr as u32, width, height, format, mip_levels);let changed = !gpu_copy&& match tex_slice {Some(tex) => self::texture_data_changed(@@ -335,7 +348,7 @@ impl GraphicsProcessor {cache_id,palette,tlut,- ram.range_generation(ram_addr, raw_size).unwrap_or(u64::MAX),+ generation,(width, height, format, mip_levels),),None => {@@ -480,6 +493,9 @@ impl GraphicsProcessor {while dirty != 0 {let slot = dirty.trailing_zeros() as usize;dirty &= !(1 << slot);+ if self.texture_is_preloaded(slot) {+ continue;+ }let image0 =TxSetImage0::from_raw(self.bp_regs[self::tx_slot_reg(BP_TX_SETIMAGE0_I0, BP_TX_SETIMAGE0_I4, slot)]);@@ -786,13 +802,13 @@ impl GraphicsProcessor {/// Texture slot to BP register index: slots 0-3 live at `base_i0`, slots 4-7/// at `base_i4` (TX_SETMODE*/TX_SETIMAGE*/TX_SETTLUT all share this layout).#[inline(always)]-fn tx_slot_reg(base_i0: usize, base_i4: usize, slot: usize) -> usize {+pub(super) fn tx_slot_reg(base_i0: usize, base_i4: usize, slot: usize) -> usize {if slot < 4 { base_i0 + slot } else { base_i4 + (slot - 4) }}-fn slot_palette(palette_mem: &[u16], tmem_offset: u16) -> &[u16] {+fn slot_palette(tmem: &[u16], tmem_offset: u16) -> &[u16] {let base = (tmem_offset as usize) * TLUT_ENTRIES_PER_UNIT;- palette_mem.get(base..).unwrap_or(&[])+ tmem.get(base..).unwrap_or(&[])}/// Mint the renderer cache key for the given texture binding.@@ -877,9 +893,10 @@ impl GraphicsProcessor {/// into palette TMEM starting at `tmem_offset * 256`. The source address/// can fall in either MEM1 or MEM2 on Wii titles.fn load_tlut(&mut self, ram: &RamView<'_>, load_val: u32) {- let tmem_offset = (load_val & 0x3FF) as usize;- let count = ((load_val >> 10) & 0x7FF) as usize;- let ram_base = (self.bp_regs[BP_LOAD_TLUT0] as usize) << 5;+ let load = LoadTlut1::from_raw(load_val);+ let tmem_offset = usize::from(load.tmem_offset());+ let count = usize::from(load.count());+ let ram_base = PreloadAddress::from_raw(self.bp_regs[BP_LOAD_TLUT0]).byte_address();let entries = count * TLUT_LOAD_ENTRIES_PER_UNIT;let byte_count = entries * 2;let dst_base = tmem_offset * TLUT_ENTRIES_PER_UNIT;@@ -901,20 +918,17 @@ impl GraphicsProcessor {if let Some(rec) = self.recorder.as_deref_mut() {rec.use_memory(ram, ram_base as u32, byte_count, MemoryUpdateType::Tmem);}- if dst_base.saturating_add(entries) > self.palette_mem.len() {+ if dst_base.saturating_add(entries) > self.tmem.len() {tracing::warn!(dst_base,entries,- tmem_limit = self.palette_mem.len(),+ tmem_limit = self.tmem.len(),"LOADTLUT: destination palette range OOB, skipping");return;}- let dst = &mut self.palette_mem[dst_base..dst_base + entries];- for (entry, chunk) in dst.iter_mut().zip(src.chunks_exact(2)) {- *entry = u16::from_be_bytes([chunk[0], chunk[1]]);- }+ self.write_tmem(dst_base * 2, src);tracing::debug!(ram_base = format!("{ram_base:#010X}"), tmem_offset, entries, "LOADTLUT");}diff --git a/crates/gecko/src/flipper/gx/constants.rs b/crates/gecko/src/flipper/gx/constants.rsindex 5a18ae3..7eac62d 100644--- a/crates/gecko/src/flipper/gx/constants.rs+++ b/crates/gecko/src/flipper/gx/constants.rs@@ -110,6 +110,12 @@ pub const BP_TX_SETTLUT_I4: usize = 0xB8; // TX_SETTLUT maps 4-7// register), LOAD_TLUT1 triggers the copy and carries tmem_offset / count.pub const BP_LOAD_TLUT0: usize = 0x64;pub const BP_LOAD_TLUT1: usize = 0x65;+pub const BP_PRELOAD_ADDR: usize = 0x60;+pub const BP_PRELOAD_TMEM_EVEN: usize = 0x61;+pub const BP_PRELOAD_TMEM_ODD: usize = 0x62;+pub const BP_PRELOAD_MODE: usize = 0x63;+pub const TMEM_SIZE: usize = dff::TEX_MEM_SIZE;+pub const TMEM_LINE_SIZE: usize = 32;// Palette TMEM layout: tmem_offset is in 256-entry (512-byte) units.pub const TLUT_ENTRIES_PER_UNIT: usize = 256;diff --git a/crates/gecko/src/flipper/gx/diagnostics.rs b/crates/gecko/src/flipper/gx/diagnostics.rsnew file mode 100644index 0000000..a2cdef4--- /dev/null+++ b/crates/gecko/src/flipper/gx/diagnostics.rs@@ -0,0 +1,78 @@+use super::constants::*;++pub(super) fn unimplemented(bank: &str, reg: usize, value: u32) {+ tracing::warn!(+ target: "gecko::gx::unimplemented",+ %bank, reg = format_args!("{reg:#06X}"), value = format_args!("{value:#010X}"),+ "unimplemented GX register write"+ );+}++pub(super) fn bp_implemented(reg: usize) -> bool {+ matches!(+ reg,+ BP_GEN_MODE+ | BP_SU_SCIS_TL+ | BP_SU_SCIS_BR+ | BP_SU_SCIS_OFFSET+ | BP_RAS1_SS0+ | BP_RAS1_SS1+ | BP_RAS1_IREF+ | BP_PE_ZMODE+ | BP_PE_CMODE0+ | BP_PE_CMODE1+ | BP_PE_ZCOMPARE+ | BP_PE_DONE+ | BP_PE_TOKEN+ | BP_PE_TOKEN_INT+ | BP_PE_COPY_SRC+ | BP_PE_COPY_DIMS+ | BP_PE_COPY_DST+ | BP_PE_COPY_DST_STRIDE+ | BP_PE_COPY_YSCALE+ | BP_PE_COPY_CLEAR_AR+ | BP_PE_COPY_CLEAR_GB+ | BP_PE_COPY_CLEAR_Z+ | BP_PE_COPY_CMD+ | BP_PRELOAD_ADDR+ | BP_PRELOAD_TMEM_EVEN+ | BP_PRELOAD_TMEM_ODD+ | BP_PRELOAD_MODE+ | BP_LOAD_TLUT0+ | BP_LOAD_TLUT1+ | BP_PE_ALPHA_COMPARE+ | BP_TEV_ZTEX1+ | BP_TEV_ZTEX2+ | BP_BP_MASK+ ) || (BP_IND_MTX_A0..=BP_IND_MTX_C2).contains(®)+ || (BP_IND_CMD_0..BP_IND_CMD_0 + BP_IND_CMD_COUNT).contains(®)+ || (BP_RAS1_TREF0..BP_RAS1_TREF0 + BP_RAS1_TREF_COUNT).contains(®)+ || (BP_SU_SSIZE0..BP_SU_SIZE_END).contains(®)+ || (BP_TX_SETMODE0_I0..BP_TX_SETTLUT_I0 + 4).contains(®)+ || (BP_TX_SETMODE0_I4..BP_TX_SETTLUT_I4 + 4).contains(®)+ || (BP_TEV_COLOR_ENV_0..BP_TEV_COLOR_ENV_0 + 32).contains(®)+ || (BP_TEV_REGISTERL_0..BP_TEV_REGISTERL_0 + 8).contains(®)+ || (BP_TEV_KSEL_0..BP_TEV_KSEL_0 + 8).contains(®)+}++pub(super) fn cp_implemented(reg: usize) -> bool {+ matches!(reg, VCD_LO_REG | VCD_HI_REG)+ || (VATA_REG..VATA_REG + 8).contains(®)+ || (VATB_REG..VATB_REG + 8).contains(®)+ || (VATC_REG..VATC_REG + 8).contains(®)+ || (ARRAY_BASE_REG..ARRAY_BASE_REG + 16).contains(®)+ || (ARRAY_STRIDE_REG..ARRAY_STRIDE_REG + 16).contains(®)+}++pub(super) fn xf_implemented(reg: usize) -> bool {+ reg < dff::XF_MEM_SIZE+ || matches!(+ reg,+ XF_MATRIX_INDEX_A | XF_MATRIX_INDEX_B | XF_DUAL_TEX_ENABLE | XF_NUM_TEXGENS+ )+ || (XF_AMBIENT_COLOR0..=XF_ALPHA_CTRL1).contains(®)+ || (XF_VIEWPORT_BASE..=XF_VIEWPORT_END).contains(®)+ || (XF_PROJECTION_BASE..=XF_PROJECTION_END).contains(®)+ || (XF_TEXGEN_BASE..XF_TEXGEN_BASE + 8).contains(®)+ || (XF_DUALTEX_BASE..XF_DUALTEX_BASE + 8).contains(®)+}diff --git a/crates/gecko/src/flipper/gx/recorder.rs b/crates/gecko/src/flipper/gx/recorder.rsindex 482aa8b..8df668e 100644--- a/crates/gecko/src/flipper/gx/recorder.rs+++ b/crates/gecko/src/flipper/gx/recorder.rs@@ -194,7 +194,7 @@ impl FifoRecorder {let regs = &gp.xf_mem[dff::XF_MEM_SIZE..dff::XF_MEM_SIZE + dff::XF_REGS_SIZE];self.file.xf_regs.copy_from_slice(regs);- for (i, entry) in gp.palette_mem.iter().enumerate() {+ for (i, entry) in gp.tmem.iter().enumerate() {let off = i * 2;if off + 2 > self.file.tex_mem.len() {break;diff --git a/crates/gecko/src/flipper/gx/regs.rs b/crates/gecko/src/flipper/gx/regs.rsindex f9e512c..1f369e9 100644--- a/crates/gecko/src/flipper/gx/regs.rs+++ b/crates/gecko/src/flipper/gx/regs.rs@@ -590,6 +590,67 @@ pub struct TxSetImage0 {pub format: TextureFormat,}+#[chapa::bitfield(u32, order = lsb0)]+#[derive(Debug, Clone, Copy)]+pub struct TxSetImage1 {+ #[bits(0..=14)]+ pub tmem_even: u16,+ #[bits(15..=17)]+ pub cache_width: u8,+ #[bits(18..=20)]+ pub cache_height: u8,+ #[bits(21)]+ pub manually_managed: bool,+}++#[chapa::bitfield(u32, order = lsb0)]+#[derive(Debug, Clone, Copy)]+pub struct TxSetImage2 {+ #[bits(0..=14)]+ pub tmem_odd: u16,+ #[bits(15..=17)]+ pub cache_width: u8,+ #[bits(18..=20)]+ pub cache_height: u8,+}++#[chapa::bitfield(u32, order = lsb0)]+#[derive(Debug, Clone, Copy)]+pub struct PreloadMode {+ #[bits(0..=14)]+ pub count: u16,+ #[bits(15..=16)]+ pub tile_type: u8,+}++impl PreloadMode {+ pub fn split_banks(&self) -> bool {+ self.tile_type() == 3+ }+}++#[chapa::bitfield(u32, order = lsb0)]+#[derive(Debug, Clone, Copy)]+pub struct PreloadAddress {+ #[bits(0..=23)]+ pub address: u32,+}++impl PreloadAddress {+ pub fn byte_address(&self) -> usize {+ self.address() as usize * super::constants::TMEM_LINE_SIZE+ }+}++#[chapa::bitfield(u32, order = lsb0)]+#[derive(Debug, Clone, Copy)]+pub struct LoadTlut1 {+ #[bits(0..=9)]+ pub tmem_offset: u16,+ #[bits(10..=20)]+ pub count: u16,+}+#[chapa::bitfield(u32, order = lsb0)]#[derive(Debug, Clone, Copy)]pub struct TxSetImage3 {diff --git a/crates/gecko/src/flipper/gx/tmem.rs b/crates/gecko/src/flipper/gx/tmem.rsnew file mode 100644index 0000000..6ad41a7--- /dev/null+++ b/crates/gecko/src/flipper/gx/tmem.rs@@ -0,0 +1,128 @@+use super::bp::tx_slot_reg;+use super::constants::*;+use super::draw::TextureFormat;+use super::recorder::MemoryUpdateType;+use super::regs::{PreloadAddress, PreloadMode, TxSetImage0, TxSetImage1, TxSetImage2};+use super::{GraphicsProcessor, texture};+use crate::mmio::RamView;+use crate::savestate::{StateError, StateReader, StateWriter};++impl GraphicsProcessor {+ pub fn load_tmem(&mut self, bytes: &[u8]) {+ self.tmem.fill(0);+ self.write_tmem(0, bytes);+ self.invalidate_tmem();+ }++ pub(crate) fn save_tmem_tail(&self, w: &mut StateWriter) {+ w.bytes(bytemuck::cast_slice(&self.tmem[TLUT_MEM_ENTRIES..]));+ }++ pub(crate) fn load_tmem_tail(&mut self, r: &mut StateReader<'_>, present: bool) -> Result<(), StateError> {+ let tail = &mut self.tmem[TLUT_MEM_ENTRIES..];+ if !present {+ tail.fill(0);+ return Ok(());+ }++ r.bytes_into(bytemuck::cast_slice_mut(tail))+ }++ pub fn texture_is_preloaded(&self, slot: usize) -> bool {+ TxSetImage1::from_raw(self.bp_regs[tx_slot_reg(BP_TX_SETIMAGE1_I0, BP_TX_SETIMAGE1_I4, slot)])+ .manually_managed()+ }++ pub(crate) fn texture_tmem_bases(&self, slot: usize) -> [usize; 2] {+ let image1 = TxSetImage1::from_raw(self.bp_regs[tx_slot_reg(BP_TX_SETIMAGE1_I0, BP_TX_SETIMAGE1_I4, slot)]);+ let image2 = TxSetImage2::from_raw(self.bp_regs[tx_slot_reg(BP_TX_SETIMAGE2_I0, BP_TX_SETIMAGE2_I4, slot)]);+ [image1.tmem_even(), image2.tmem_odd()].map(|line| usize::from(line) * TMEM_LINE_SIZE)+ }++ pub(crate) fn invalidate_tmem(&mut self) {+ self.tmem_generation = self.tmem_generation.wrapping_add(1);++ for slot in 0..self.cur_textures.len() {+ let image0 = TxSetImage0::from_raw(self.bp_regs[tx_slot_reg(BP_TX_SETIMAGE0_I0, BP_TX_SETIMAGE0_I4, slot)]);+ if image0.format().is_paletted() || self.texture_is_preloaded(slot) {+ self.tex_dirty |= 1 << slot;+ }+ }+ }++ pub(crate) fn preload_texture(&mut self, ram: &RamView<'_>, mode: PreloadMode) {+ let split_banks = mode.split_banks();+ let src = PreloadAddress::from_raw(self.bp_regs[BP_PRELOAD_ADDR]).byte_address();+ let even = PreloadAddress::from_raw(self.bp_regs[BP_PRELOAD_TMEM_EVEN]).byte_address();+ let odd = PreloadAddress::from_raw(self.bp_regs[BP_PRELOAD_TMEM_ODD]).byte_address();+ let len = usize::from(mode.count()) * TMEM_LINE_SIZE * if split_banks { 2 } else { 1 };++ if len == 0 {+ return;+ }+ let Some(bytes) = ram.slice(src, len) else {+ return;+ };++ if let Some(rec) = self.recorder.as_deref_mut() {+ rec.use_memory(ram, src as u32, len, MemoryUpdateType::Tmem);+ }++ if split_banks {+ for (i, tile) in bytes.chunks_exact(2 * TMEM_LINE_SIZE).enumerate() {+ self.write_tmem(even + i * TMEM_LINE_SIZE, &tile[..TMEM_LINE_SIZE]);+ self.write_tmem(odd + i * TMEM_LINE_SIZE, &tile[TMEM_LINE_SIZE..]);+ }+ } else {+ self.write_tmem(even, bytes);+ }++ self.invalidate_tmem();+ }++ pub(super) fn write_tmem(&mut self, addr: usize, bytes: &[u8]) {+ let Some(dst) = self.tmem.get_mut(addr / 2..) else {+ return;+ };++ for (entry, pair) in dst.iter_mut().zip(bytes.chunks_exact(2)) {+ *entry = u16::from_be_bytes([pair[0], pair[1]]);+ }+ }++ fn read_tmem(&self, addr: usize, len: usize, out: &mut Vec<u8>) -> Option<()> {+ let entries = self.tmem.get(addr / 2..(addr + len) / 2)?;+ out.extend(entries.iter().flat_map(|entry| entry.to_be_bytes()));+ Some(())+ }++ pub(crate) fn preloaded_texture_bytes(+ &self,+ slot: usize,+ width: u32,+ height: u32,+ format: TextureFormat,+ levels: u32,+ ) -> Option<Vec<u8>> {+ let mut bases = self.texture_tmem_bases(slot);+ let mut out = Vec::with_capacity(texture::mip_data_size(width, height, format, levels));++ for (level, (w, h)) in texture::mip_dimensions(width, height, levels).enumerate() {+ let len = texture::raw_data_size(w, h, format);+ if format == TextureFormat::RGBA8 {+ for _ in 0..len / (2 * TMEM_LINE_SIZE) {+ for base in &mut bases {+ self.read_tmem(*base, TMEM_LINE_SIZE, &mut out)?;+ *base += TMEM_LINE_SIZE;+ }+ }+ } else {+ let base = &mut bases[level % 2];+ self.read_tmem(*base, len, &mut out)?;+ *base += len;+ }+ }++ Some(out)+ }+}diff --git a/crates/gecko/src/flipper/gx/vertex.rs b/crates/gecko/src/flipper/gx/vertex.rsindex cd44db2..d96ad9d 100644--- a/crates/gecko/src/flipper/gx/vertex.rs+++ b/crates/gecko/src/flipper/gx/vertex.rs@@ -152,6 +152,7 @@ impl GraphicsProcessor {let vf = self.build_vertex_format(cmd);let view = mmio.ram_view();let mip_levels: [u32; 8] = std::array::from_fn(|slot| self.texture_mip_levels(slot));+ let preloaded: [bool; 8] = std::array::from_fn(|slot| self.texture_is_preloaded(slot));let rec = self.recorder.as_deref_mut().unwrap();let mut offset = 0;@@ -162,6 +163,9 @@ impl GraphicsProcessor {}for (slot, desc) in self.cur_textures.iter().enumerate() {+ if preloaded[slot] {+ continue;+ }let Some(desc) = desc else {continue;};diff --git a/crates/gecko/src/flipper/gx/xf.rs b/crates/gecko/src/flipper/gx/xf.rsindex 16df4ec..34ea464 100644--- a/crates/gecko/src/flipper/gx/xf.rs+++ b/crates/gecko/src/flipper/gx/xf.rs@@ -1,6 +1,6 @@use super::constants::*;use super::math::Vec3;-use super::{GraphicsProcessor, draw};+use super::{GraphicsProcessor, diagnostics, draw};use crate::host::{GxAction, RenderSink};use crate::mmio::RamView;@@ -36,6 +36,9 @@ impl GraphicsProcessor {for (i, val) in values.enumerate() {let reg = base + i;+ if !diagnostics::xf_implemented(reg) {+ diagnostics::unimplemented("XF", reg, val);+ }if reg < self.xf_mem.len() {if tracked && self.xf_mem[reg] != val {dirty.texgen |= (XF_NUM_TEXGENS..XF_TEXGEN_END).contains(®);@@ -157,9 +160,18 @@ impl GraphicsProcessor {pub fn load_cp(&mut self, data: &[u8]) {let idx = data[0] as usize;let val = u32::from_be_bytes([data[1], data[2], data[3], data[4]]);++ if !diagnostics::cp_implemented(idx) {+ diagnostics::unimplemented("CP", idx, val);+ }++ let Some(register) = self.cp_regs.get_mut(idx) else {+ return;+ };+#[cfg(feature = "jit")]- let changed = self.cp_regs[idx] != val;- self.cp_regs[idx] = val;+ let changed = *register != val;+ *register = val;#[cfg(feature = "jit")]if changeddiff --git a/crates/gecko/src/host.rs b/crates/gecko/src/host.rsindex 8314987..a7a2b57 100644--- a/crates/gecko/src/host.rs+++ b/crates/gecko/src/host.rs@@ -13,7 +13,8 @@ use std::path::PathBuf;////// `variant` combines mip count and mipmap enablement with a 32-bit hash of/// `(palette content, tlut.format, tmem_offset)` for paletted textures.-/// Single-level, non-paletted textures use `0`.+/// Single-level, non-paletted RAM textures use `0`. Preloaded textures also+/// mix in their odd-bank TMEM address.#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]pub struct TextureKey {pub ram_addr: Address,diff --git a/crates/gecko/src/savestate.rs b/crates/gecko/src/savestate.rsindex d342f53..224270e 100644--- a/crates/gecko/src/savestate.rs+++ b/crates/gecko/src/savestate.rs@@ -2,7 +2,7 @@ use crate::system::{System, SystemId, WII};use std::path::PathBuf;pub const STATE_MAGIC: [u8; 4] = *b"GKST";-pub const STATE_VERSION: u32 = 3;+pub const STATE_VERSION: u32 = 4;const COMPRESSION_LEVEL: i32 = 1;@@ -275,6 +275,8 @@ impl<const SYSTEM: SystemId> System<SYSTEM> {// Version 2 appends the DSP exception latch to preserve version 1 layoutsw.u8(self.dsp.pending_exceptions);w.pod(&self.gx.zfreeze_plane);+ // Version 4 extends the old palette-only snapshot to all of TMEM.+ self.gx.save_tmem_tail(&mut w);self::pack(SYSTEM, &w.into_inner())}@@ -315,6 +317,7 @@ impl<const SYSTEM: SystemId> System<SYSTEM> {self.dsp.pending_exceptions = if version >= 2 { r.u8()? } else { 0 };self.gx.zfreeze_plane = if version >= 3 { r.pod()? } else { Default::default() };+ self.gx.load_tmem_tail(&mut r, version >= 4)?;if r.remaining() != 0 {return Err(StateError::Corrupt("trailing data"));