Skip to content

armgit / gecko

Public Imported from GitHub
0

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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
new file mode 100644
index 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(&reg)
+ || (BP_IND_CMD_0..BP_IND_CMD_0 + BP_IND_CMD_COUNT).contains(&reg)
+ || (BP_RAS1_TREF0..BP_RAS1_TREF0 + BP_RAS1_TREF_COUNT).contains(&reg)
+ || (BP_SU_SSIZE0..BP_SU_SIZE_END).contains(&reg)
+ || (BP_TX_SETMODE0_I0..BP_TX_SETTLUT_I0 + 4).contains(&reg)
+ || (BP_TX_SETMODE0_I4..BP_TX_SETTLUT_I4 + 4).contains(&reg)
+ || (BP_TEV_COLOR_ENV_0..BP_TEV_COLOR_ENV_0 + 32).contains(&reg)
+ || (BP_TEV_REGISTERL_0..BP_TEV_REGISTERL_0 + 8).contains(&reg)
+ || (BP_TEV_KSEL_0..BP_TEV_KSEL_0 + 8).contains(&reg)
+}
+
+pub(super) fn cp_implemented(reg: usize) -> bool {
+ matches!(reg, VCD_LO_REG | VCD_HI_REG)
+ || (VATA_REG..VATA_REG + 8).contains(&reg)
+ || (VATB_REG..VATB_REG + 8).contains(&reg)
+ || (VATC_REG..VATC_REG + 8).contains(&reg)
+ || (ARRAY_BASE_REG..ARRAY_BASE_REG + 16).contains(&reg)
+ || (ARRAY_STRIDE_REG..ARRAY_STRIDE_REG + 16).contains(&reg)
+}
+
+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(&reg)
+ || (XF_VIEWPORT_BASE..=XF_VIEWPORT_END).contains(&reg)
+ || (XF_PROJECTION_BASE..=XF_PROJECTION_END).contains(&reg)
+ || (XF_TEXGEN_BASE..XF_TEXGEN_BASE + 8).contains(&reg)
+ || (XF_DUALTEX_BASE..XF_DUALTEX_BASE + 8).contains(&reg)
+}
diff --git a/crates/gecko/src/flipper/gx/recorder.rs b/crates/gecko/src/flipper/gx/recorder.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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(&reg);
@@ -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 changed
diff --git a/crates/gecko/src/host.rs b/crates/gecko/src/host.rs
index 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.rs
index 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 layouts
w.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"));