A GameCube/Wii emulator and debugger written in Rust.
texture pack support
Laylec0324fcf20f3
diff --git a/Cargo.lock b/Cargo.lockindex 3a1d3a7..8caaf97 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -543,13 +543,18 @@ dependencies = ["bytemuck","chapa","crossbeam-channel",+ "ddsfile","gecko","glam 0.33.7","hotpath",+ "image 0.25.10","png","renderdoc","rustc-hash 2.1.2",+ "texture2ddecoder","tracing",+ "twox-hash",+ "walkdir","wesl","wgpu",]@@ -1574,6 +1579,18 @@ dependencies = ["image 0.1.0",]+[[package]]+name = "ddsfile"+version = "0.6.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "8be425797f9962624aba78dee473dad28c15999e6ee6feb28ad3ee7928a3bc5b"+dependencies = [+ "bitflags 2.11.1",+ "byteorder",+ "enum-primitive-derive",+ "num-traits",+]+[[package]]name = "debugger"version = "0.1.0"@@ -1883,6 +1900,17 @@ version = "1.1.1"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "66b7e2430c6dff6a955451e2cfc438f09cea1965a9d6f87f7e3b90decc014099"+[[package]]+name = "enum-primitive-derive"+version = "0.3.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "ba7795da175654fe16979af73f81f26a8ea27638d8d9823d317016888a63dc4c"+dependencies = [+ "num-traits",+ "quote",+ "syn",+]+[[package]]name = "enumflags2"version = "0.7.12"@@ -6654,6 +6682,15 @@ version = "1.0.0"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "d4d1330fe7f7f872cd05165130b10602d667b205fd85be09be2814b115d4ced9"+[[package]]+name = "texture2ddecoder"+version = "0.1.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "427ae8ec7f2f0fdd3146b77cfa44bea880caf066f7e55398a8467afe2645c832"+dependencies = [+ "paste",+]+[[package]]name = "thiserror"version = "1.0.69"@@ -7077,9 +7114,9 @@ dependencies = [[[package]]name = "twox-hash"-version = "2.1.2"+version = "2.1.4"source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "9ea3136b675547379c4bd395ca6b938e5ad3c3d20fad76e7fe85f9e0d011419c"+checksum = "5283634e518fe9e82c7b20520bb4bc209009fd16c82077c802f8111ecbb0117a"dependencies = ["rand",]diff --git a/README.md b/README.mdindex ba3d083..fa17e0e 100644--- a/README.md+++ b/README.md@@ -32,6 +32,8 @@ Gecko is developed with homebrew development and reverse engineering in mind, bu- Cranelift based JITs- PowerPC, DSP, vertex decoder- Upscaling 1x - 4x+- Texture packs+ - Implements Dolphin style pack support- Controller support- Xbox, Steam, etc.- PS5 DualSense Wiimote motion control@@ -235,6 +237,16 @@ Nunchuk:</details>+### Texture packs++The main `gecko` app and `tinyapp` load Dolphin `tex1_` texture packs automatically from+`texturepacks/<game ID>/` in the data directory (the working directory by default,+or `GECKO_DATA_DIR`).++In the Gecko app, use **Settings -> Graphics -> Texture Packs (restart game)** to+toggle replacements. In tinyapp, use `--no-texture-packs` to disable them or+`--texture-pack-dir <directory>` to select a different pack root.+### Savestates`tinyapp`, `debugger` and the `gecko` player support saving and loading GameCube and Wii emulation state with `F5` and `F7`. The debugger also provides Save State and Load State menu actions. In `gecko`, these hotkeys are configurable under `Settings > Keyboard Bindings`; requests made while paused are processed after emulation resumes.diff --git a/crates/app/src/app.rs b/crates/app/src/app.rsindex 3d3bf15..eb8f12b 100644--- a/crates/app/src/app.rs+++ b/crates/app/src/app.rs@@ -64,6 +64,7 @@ pub enum Message {MenuToggleSram,MenuSetTheme(ThemePreference),MenuSetUpscale(u32),+ MenuToggleTexturePacks,MenuSetAspect(AspectMode),MenuAbout,AboutClose,@@ -603,6 +604,11 @@ impl App {self.persist_config();Task::none()}+ Message::MenuToggleTexturePacks => {+ self.config.texture_packs = !self.config.texture_packs;+ self.persist_config();+ Task::none()+ }Message::MenuSetAspect(aspect) => {self.config.aspect = aspect;self.persist_config();@@ -950,6 +956,7 @@ impl App {self.config.ipl_hle,self.config.skip_ipl,self.config.upscale,+ self.config.texture_packs,self.config.aspect,self.config.memcard_enabled,self.config.sram_enabled,diff --git a/crates/app/src/config.rs b/crates/app/src/config.rsindex b2bf549..c287214 100644--- a/crates/app/src/config.rs+++ b/crates/app/src/config.rs@@ -22,6 +22,7 @@ pub struct Config {pub skip_ipl: bool,#[serde(default = "self::default_upscale")]pub upscale: u32,+ pub texture_packs: bool,pub aspect: AspectMode,#[serde(default = "self::default_memcard_enabled")]pub memcard_enabled: bool,@@ -180,6 +181,7 @@ impl Default for Config {ipl_hle: false,skip_ipl: self::default_skip_ipl(),upscale: self::default_upscale(),+ texture_packs: true,aspect: AspectMode::default(),memcard_enabled: self::default_memcard_enabled(),sram_enabled: self::default_sram_enabled(),diff --git a/crates/app/src/player/state.rs b/crates/app/src/player/state.rsindex e249863..478ee5c 100644--- a/crates/app/src/player/state.rs+++ b/crates/app/src/player/state.rs@@ -29,6 +29,7 @@ struct BootParams {memcard_path: Option<PathBuf>,execution_mode: gecko::ExecutionMode,input_config: hostinput::InputConfig,+ texture_packs: bool,}struct Initialized {@@ -110,6 +111,7 @@ impl PlayerState {memcard_path: config.memcard_enabled.then(|| config::data_relative(MEMCARD_A_FILE)),execution_mode: config.cpu_mode.into(),input_config: config.input.clone(),+ texture_packs: config.texture_packs,})),initialized: OnceLock::new(),shutdown: Arc::new(AtomicBool::new(false)),@@ -368,6 +370,9 @@ fn finish_boot<const S: gecko::system::SystemId>(mut emu: gecko::system::System<S>,game_id: String,) {+ if params.texture_packs {+ sink.load_texture_pack(&gecko::paths::resolve("texturepacks"), &game_id);+ }self::configure_emu(&mut emu, ¶ms, sink, state.fps.clone());if S == system::WII {emu.starlet.set_widescreen(state.aspect.is_widescreen());diff --git a/crates/app/src/widgets/menubar.rs b/crates/app/src/widgets/menubar.rsindex 075690a..2215abc 100644--- a/crates/app/src/widgets/menubar.rs+++ b/crates/app/src/widgets/menubar.rs@@ -17,6 +17,7 @@ pub fn menubar(ipl_hle: bool,skip_ipl: bool,upscale: u32,+ texture_packs: bool,aspect: AspectMode,memcard_enabled: bool,sram_enabled: bool,@@ -36,6 +37,7 @@ pub fn menubar(ipl_hle,skip_ipl,upscale,+ texture_packs,aspect,memcard_enabled,sram_enabled,@@ -239,6 +241,7 @@ fn settings_menu(ipl_hle: bool,skip_ipl: bool,upscale: u32,+ texture_packs: bool,aspect: AspectMode,memcard_enabled: bool,sram_enabled: bool,@@ -278,6 +281,12 @@ fn settings_menu(palette,"Graphics",vec![+ check(+ "Texture Packs (restart game)",+ Message::MenuToggleTexturePacks,+ texture_packs,+ ),+ Item::new(self::separator(palette)),Item::new(self::section_header(palette, "Internal Resolution")),check("1x (Native)", Message::MenuSetUpscale(1), upscale == 1),check("2x", Message::MenuSetUpscale(2), upscale == 2),diff --git a/crates/backend-wgpu/Cargo.toml b/crates/backend-wgpu/Cargo.tomlindex 8e55367..5d36be1 100644--- a/crates/backend-wgpu/Cargo.toml+++ b/crates/backend-wgpu/Cargo.toml@@ -23,3 +23,10 @@ rustc-hash = "2.1.2"png = "0.18.1"renderdoc = { version = "0.12.1", optional = true }hotpath = { version = "0.16.0", optional = true }++[target.'cfg(not(target_arch = "wasm32"))'.dependencies]+ddsfile = "0.6.0"+texture2ddecoder = "0.1.2"+walkdir = "2.5.0"+image-codec = { package = "image", version = "0.25.10", default-features = false, features = ["png"] }+twox-hash = { version = "2.1.4", default-features = false, features = ["xxhash64"] }diff --git a/crates/backend-wgpu/src/action.rs b/crates/backend-wgpu/src/action.rsindex f1aa2d0..6237209 100644--- a/crates/backend-wgpu/src/action.rs+++ b/crates/backend-wgpu/src/action.rs@@ -1,8 +1,8 @@use crate::pipeline::{FullPipelineKey, PipelineKey, UberPipelineKey};use crate::shader_specialization::{self, ShaderKey, ShaderSpecializationKey};use crate::{- BindGroupCacheKey, DRAW_UNIFORMS_SIZE, DrawUniforms, FRAME_UNIFORMS_SIZE, FrameUniforms, GxRenderer, SamplerKey,- helpers,+ BindGroupCacheKey, CachedTexture, DRAW_UNIFORMS_SIZE, DrawUniforms, FRAME_UNIFORMS_SIZE, FrameUniforms, GxRenderer,+ SamplerKey, helpers,};use gecko::flipper::gx::draw::Primitive;use gecko::flipper::gx::regs::CullMode;@@ -304,57 +304,85 @@ impl GxRenderer {.retain(|key, _| !key.tex_keys.iter().flatten().any(|k| k.ram_addr == tid.ram_addr));}- if let Some((_, cached_tex, _)) = self.texture_cache.get(&tid) {- let size = cached_tex.size();- if size.width == *width && size.height == *height && cached_tex.mip_level_count() == *mip_levels {- if let Some(data) = data {- let cached_tex = cached_tex.clone();- self.decode_texture_levels(device, queue, &cached_tex, *fmt, data);- }-- if let Some((cached_fmt, _, _)) = self.texture_cache.get_mut(&tid) {- *cached_fmt = *fmt;+ #[cfg(not(target_arch = "wasm32"))]+ let replacement = match data {+ Some(data) if !keep_cached => self.texture_pack.lookup(device, queue, *width, *height, *fmt, data),+ _ => None,+ };+ #[cfg(target_arch = "wasm32")]+ let replacement = None;++ let (tex, view) = match replacement {+ Some(replacement) => replacement,+ None => {+ if let Some(cached) = self.texture_cache.get_mut(&tid) {+ let size = cached.texture.size();+ if cached.texture.usage().contains(crate::LOAD_TEXTURE_USAGE)+ && size.width == *width+ && size.height == *height+ && cached.texture.mip_level_count() == *mip_levels+ {+ cached.fmt = *fmt;+ if let Some(data) = data {+ let cached_tex = cached.texture.clone();+ self.decode_texture_levels(device, queue, &cached_tex, *fmt, data);+ }++ return;+ }}- return;- }- }+ let pooled = self+ .texture_pool+ .get_mut(&(*width, *height, *mip_levels))+ .and_then(|v| v.pop());- let pooled = self- .texture_pool- .get_mut(&(*width, *height, *mip_levels))- .and_then(|v| v.pop());+ let tex = pooled.unwrap_or_else(|| {+ let texture_label = format!(+ "gx_tex addr={:#010x}/{:08x} fmt={:?} size={}x{}",+ id.ram_addr, id.variant, *fmt, *width, *height+ );+ device.create_texture(&wgpu::TextureDescriptor {+ label: Some(&texture_label),+ size: copy_size,+ mip_level_count: *mip_levels,+ sample_count: 1,+ dimension: wgpu::TextureDimension::D2,+ format: wgpu::TextureFormat::Rgba8Unorm,+ usage: crate::LOAD_TEXTURE_USAGE,+ view_formats: &[],+ })+ });- let tex = pooled.unwrap_or_else(|| {- let texture_label = format!(- "gx_tex addr={:#010x}/{:08x} fmt={:?} size={}x{}",- id.ram_addr, id.variant, *fmt, *width, *height- );- device.create_texture(&wgpu::TextureDescriptor {- label: Some(&texture_label),- size: copy_size,- mip_level_count: *mip_levels,- sample_count: 1,- dimension: wgpu::TextureDimension::D2,- format: wgpu::TextureFormat::Rgba8Unorm,- usage: crate::LOAD_TEXTURE_USAGE,- view_formats: &[],- })- });+ if let Some(data) = data {+ self.decode_texture_levels(device, queue, &tex, *fmt, data);+ }+ let view = tex.create_view(&Default::default());+ (tex, view)+ }+ };- if let Some(data) = data {- self.decode_texture_levels(device, queue, &tex, *fmt, data);+ if self.texture_cache.get(&tid).is_some_and(|cached| cached.texture == tex) {+ return;}- let view = tex.create_view(&Default::default());// Cached bind groups still hold the old TextureView for this// key. Drop them so they get rebuilt against the new one.self.bind_group_cache- .retain(|key, _| !key.tex_keys.iter().any(|k| *k == Some(tid)));-- let prior = self.texture_cache.insert(tid, (*fmt, tex, view));- if let Some((_, old_tex, _)) = prior {- self.return_load_texture_to_pool(old_tex);+ .retain(|key, _| !key.tex_keys.contains(&Some(tid)));++ let prior = self.texture_cache.insert(+ tid,+ CachedTexture {+ fmt: *fmt,+ native_w: *width,+ native_h: *height,+ texture: tex,+ view,+ },+ );+ if let Some(prior) = prior {+ self.return_load_texture_to_pool(prior.texture);}}GxAction::LoadEfbPalette {@@ -379,15 +407,15 @@ impl GxRenderer {.clone();debug_assert_eq!((source.width(), source.height()), (*width, *height));- let existing = self.texture_cache.get(id).filter(|(_, texture, _)| {- texture.width() == *width- && texture.height() == *height- && texture.mip_level_count() == 1- && texture.usage().contains(wgpu::TextureUsages::RENDER_ATTACHMENT)+ let existing = self.texture_cache.get(id).filter(|cached| {+ cached.texture.width() == *width+ && cached.texture.height() == *height+ && cached.texture.mip_level_count() == 1+ && cached.texture.usage().contains(wgpu::TextureUsages::RENDER_ATTACHMENT)});- let (texture, view) = if let Some((_, texture, view)) = existing {- (texture.clone(), view.clone())+ let (texture, view) = if let Some(cached) = existing {+ (cached.texture.clone(), cached.view.clone())} else {if self.texture_cache.contains_key(id) {self.bind_group_cache@@ -416,8 +444,16 @@ impl GxRenderer {self.palette_converter.encode(device, queue, &mut encoder, &source, format, palette, &view);self.current_encoder = Some(encoder);- self.texture_cache- .insert(*id, (gecko::flipper::gx::draw::TextureFormat::CI8, texture, view));+ self.texture_cache.insert(+ *id,+ CachedTexture {+ fmt: gecko::flipper::gx::draw::TextureFormat::CI8,+ native_w: *width,+ native_h: *height,+ texture,+ view,+ },+ );}GxAction::InvalidateCaches => {self.flush_pending_draws(device, queue);@@ -568,14 +604,13 @@ impl GxRenderer {continue;};- let Some((_, tex, _)) = self.texture_cache.get(tid) else {+ let Some(cached) = self.texture_cache.get(tid) else {continue;};- let size = tex.size();let c = (slot % 2) * 2;- tex_dims[slot / 2][c] = size.width;- tex_dims[slot / 2][c + 1] = size.height;+ tex_dims[slot / 2][c] = cached.native_w;+ tex_dims[slot / 2][c + 1] = cached.native_h;}let draw_uniform = DrawUniforms {@@ -864,19 +899,19 @@ impl GxRenderer {for slot in 0..8 {if let Some(tid) = &bg_key.tex_keys[slot] {let tex_entry = self.texture_cache.get(tid);- let efb_match = tex_entry.and_then(|(tex_fmt, tex_tex, _)| {- if tex_tex.mip_level_count() != 1 {+ let efb_match = tex_entry.and_then(|cached| {+ if cached.texture.mip_level_count() != 1 {return None;}- let size = tex_tex.size();+ let size = cached.texture.size();self.efb_copy_cache.get(&tid.ram_addr)- .filter(|e| e.matches(*tex_fmt, size.width, size.height))+ .filter(|e| e.matches(cached.fmt, size.width, size.height)).map(|e| &e.view)});- if let Some(view) = efb_match.or_else(|| tex_entry.map(|(_, _, v)| v)) {+ if let Some(view) = efb_match.or_else(|| tex_entry.map(|cached| &cached.view)) {tex_views[slot] = view;} else {tracing::warn!(diff --git a/crates/backend-wgpu/src/dump.rs b/crates/backend-wgpu/src/dump.rsindex 5b6efe7..72bbfb0 100644--- a/crates/backend-wgpu/src/dump.rs+++ b/crates/backend-wgpu/src/dump.rs@@ -2,7 +2,7 @@ use std::path::{Path, PathBuf};use std::time::{Duration, SystemTime, UNIX_EPOCH};use crate::capture::{self, CapturedFrame};-use crate::{GxRenderer, align_up};+use crate::{CachedTexture, GxRenderer, align_up};impl GxRenderer {pub(crate) fn dump_textures(&mut self, device: &wgpu::Device, queue: &wgpu::Queue, dir: &Path) {@@ -17,7 +17,7 @@ impl GxRenderer {}let mut saved = 0usize;- for (cache_id, (fmt, tex, _)) in self.texture_cache.iter() {+ for (cache_id, CachedTexture { fmt, texture: tex, .. }) in self.texture_cache.iter() {let size = tex.size();let width = size.width;let height = size.height;diff --git a/crates/backend-wgpu/src/lib.rs b/crates/backend-wgpu/src/lib.rsindex ad5db6d..d7ae9ac 100644--- a/crates/backend-wgpu/src/lib.rs+++ b/crates/backend-wgpu/src/lib.rs@@ -12,6 +12,8 @@ mod renderdoc_capture;mod shader_specialization;pub mod sink;mod texture_decode;+#[cfg(not(target_arch = "wasm32"))]+mod texture_pack;use gecko::common::Address;#[cfg(feature = "renderdoc-capture")]@@ -243,6 +245,14 @@ pub const EFB_HEIGHT: u32 = 528;pub const EFB_SAMPLE_COUNT: u32 = 4;pub const MAX_EFB_SCALE: u32 = 4;+pub(crate) struct CachedTexture {+ pub(crate) fmt: TextureFormat,+ pub(crate) native_w: u32,+ pub(crate) native_h: u32,+ pub(crate) texture: wgpu::Texture,+ pub(crate) view: wgpu::TextureView,+}+pub(crate) struct EfbCopyEntry {pub(crate) format: gecko::flipper::gx::texture::CopyFormat,/// Guest dimensions. The GPU texture itself is `efb_scale`@@ -308,7 +318,9 @@ pub struct GxRenderer {pub(crate) efb_depth_view: wgpu::TextureView,pub(crate) efb_needs_clear: bool,pub(crate) sampler_cache: FxHashMap<SamplerKey, wgpu::Sampler>,- pub(crate) texture_cache: FxHashMap<TextureKey, (TextureFormat, wgpu::Texture, wgpu::TextureView)>,+ pub(crate) texture_cache: FxHashMap<TextureKey, CachedTexture>,+ #[cfg(not(target_arch = "wasm32"))]+ pub(crate) texture_pack: texture_pack::TexturePack,// Retired LoadTexture allocations grouped by (w, h, mip levels).pub(crate) texture_pool: FxHashMap<(u32, u32, u32), Vec<wgpu::Texture>>,pub(crate) efb_copy_cache: FxHashMap<Address, EfbCopyEntry>,@@ -976,6 +988,8 @@ impl GxRenderer {m},texture_cache: FxHashMap::default(),+ #[cfg(not(target_arch = "wasm32"))]+ texture_pack: texture_pack::TexturePack::default(),texture_pool: FxHashMap::default(),efb_copy_cache: FxHashMap::default(),palette_converter,diff --git a/crates/backend-wgpu/src/render.rs b/crates/backend-wgpu/src/render.rsindex b4e1931..544cd07 100644--- a/crates/backend-wgpu/src/render.rs+++ b/crates/backend-wgpu/src/render.rs@@ -522,10 +522,14 @@ impl GxRenderer {pub(crate) fn return_load_texture_to_pool(&mut self, tex: wgpu::Texture) {const PER_BUCKET_CAP: usize = 8;+ // Pack textures are immutable and may be shared by several guest keys.+ if !tex.usage().contains(crate::LOAD_TEXTURE_USAGE) {+ return;+ }+debug_assert_eq!(tex.format(), wgpu::TextureFormat::Rgba8Unorm);debug_assert_eq!(tex.sample_count(), 1);debug_assert_eq!(tex.dimension(), wgpu::TextureDimension::D2);- debug_assert!(tex.usage().contains(crate::LOAD_TEXTURE_USAGE));let size = tex.size();let bucket = selfdiff --git a/crates/backend-wgpu/src/sink.rs b/crates/backend-wgpu/src/sink.rsindex 672c5cf..724c4dd 100644--- a/crates/backend-wgpu/src/sink.rs+++ b/crates/backend-wgpu/src/sink.rs@@ -121,6 +121,7 @@ struct EfbDrainRequest {#[cfg(not(target_arch = "wasm32"))]enum WorkerCommand {+ LoadTexturePack(Box<crate::texture_pack::TexturePack>),Actions(ActionBatch),DrainEfbCopies(EfbDrainRequest),PeekEfbDepth {@@ -137,6 +138,7 @@ impl RenderWorker {fn run(mut self, work_rx: crossbeam_channel::Receiver<WorkerCommand>) {while let Ok(command) = work_rx.recv() {match command {+ WorkerCommand::LoadTexturePack(pack) => self.gx.texture_pack = *pack,WorkerCommand::Actions(batch) => self.exec_batch(batch),WorkerCommand::DrainEfbCopies(request) => self.drain_efb_copies(request),WorkerCommand::PeekEfbDepth {@@ -288,6 +290,12 @@ impl RenderWorker {#[cfg(not(target_arch = "wasm32"))]impl ThreadedSink {+ /// Configure replacements before attaching this sink to an emulator.+ pub fn load_texture_pack(&self, root: &std::path::Path, game_id: &str) {+ let pack = crate::texture_pack::TexturePack::discover(root, game_id);+ let _ = self.work_tx.send(WorkerCommand::LoadTexturePack(Box::new(pack)));+ }+fn reclaim_batch(&mut self) {if !self.pending_actions.is_empty() || !self.scratch.is_empty() {return;diff --git a/crates/backend-wgpu/src/texture_pack.rs b/crates/backend-wgpu/src/texture_pack.rsnew file mode 100644index 0000000..573494b--- /dev/null+++ b/crates/backend-wgpu/src/texture_pack.rs@@ -0,0 +1,391 @@+use gecko::flipper::gx::draw::TextureFormat;+use gecko::flipper::gx::texture::{EncodedTexture, mip_dimensions, raw_data_size};+use image_codec::{ImageReader, RgbaImage};+use rustc_hash::{FxHashMap, FxHashSet};+use std::collections::{BTreeMap, btree_map};+use std::path::{Path, PathBuf};++const CACHE_BYTES: usize = 256 * 1024 * 1024;+const MAX_IMAGE_BYTES: u64 = 64 * 1024 * 1024;+const MAX_FILE_BYTES: u64 = 512 * 1024 * 1024;++type Error = Box<dyn std::error::Error + Send + Sync>;++type Entry = BTreeMap<u32, PathBuf>;++struct Replacement {+ texture: wgpu::Texture,+ view: wgpu::TextureView,+ bytes: usize,+ last_used: u64,+}++#[derive(Default)]+pub struct TexturePack {+ entries: BTreeMap<String, Entry>,+ loaded: FxHashMap<String, Replacement>,+ failed: FxHashSet<String>,+ bytes: usize,+ tick: u64,+}++impl TexturePack {+ pub fn discover(root: &Path, game_id: &str) -> Self {+ if game_id.len() != 6 || !game_id.bytes().all(|b| b.is_ascii_alphanumeric()) {+ return Self::default();+ }++ let exact = root.join(game_id);+ let directory = if exact.is_dir() {+ exact+ } else {+ root.join(&game_id[..3])+ };++ let files = walkdir::WalkDir::new(directory)+ .sort_by_file_name()+ .into_iter()+ .filter_map(Result::ok)+ .filter(|entry| entry.file_type().is_file())+ .map(walkdir::DirEntry::into_path);++ let mut pack = Self::default();+ for path in files {+ let Some(extension) = path.extension().and_then(|s| s.to_str()) else {+ continue;+ };+ if !extension.eq_ignore_ascii_case("png") && !extension.eq_ignore_ascii_case("dds") {+ continue;+ }+ let Some(stem) = path.file_stem().and_then(|s| s.to_str()) else {+ continue;+ };+ if !stem.starts_with("tex1_") {+ continue;+ }++ let stem = stem.replace("_arb", "");+ let (name, level) = match stem.rsplit_once("_mip") {+ Some((name, level)) => match level.parse::<u32>() {+ Ok(level) if level > 0 && level < 32 => (name, level),+ _ => continue,+ },+ None => (stem.as_str(), 0),+ };+ match pack.entries.entry(name.to_owned()).or_default().entry(level) {+ btree_map::Entry::Vacant(slot) => {+ slot.insert(path);+ }+ btree_map::Entry::Occupied(_) => {+ tracing::warn!(path = %path.display(), "duplicate texture replacement; using first path");+ }+ }+ }++ pack.entries.retain(|_, levels| levels.contains_key(&0));+ if !pack.entries.is_empty() {+ tracing::info!(game_id, textures = pack.entries.len(), "indexed Dolphin texture pack");+ }++ pack+ }++ pub(crate) fn lookup(+ &mut self,+ device: &wgpu::Device,+ queue: &wgpu::Queue,+ width: u32,+ height: u32,+ format: TextureFormat,+ data: &EncodedTexture,+ ) -> Option<(wgpu::Texture, wgpu::TextureView)> {+ if self.entries.is_empty() {+ return None;+ }++ let names = self::texture_names(width, height, format, data)?;+ let name = names.into_iter().find(|name| self.entries.contains_key(name))?;+ if self.failed.contains(&name) {+ return None;+ }++ self.tick += 1;+ if let Some(cached) = self.loaded.get_mut(&name) {+ cached.last_used = self.tick;+ return Some((cached.texture.clone(), cached.view.clone()));+ }++ let limit = device.limits().max_texture_dimension_2d;+ let levels = match self::load_entry(&self.entries[&name], limit, data.mipmaps_enabled) {+ Ok(levels) => levels,+ Err(err) => {+ tracing::warn!(name, %err, "texture replacement failed; using guest texture");+ self.failed.insert(name);+ return None;+ }+ };++ let replacement = self::upload(device, queue, &name, &levels, self.tick);+ while self.bytes + replacement.bytes > CACHE_BYTES {+ let Some(oldest) = self+ .loaded+ .iter()+ .min_by_key(|(_, r)| r.last_used)+ .map(|(n, _)| n.clone())+ else {+ break;+ };+ self.bytes -= self.loaded.remove(&oldest).unwrap().bytes;+ }++ tracing::debug!(name, "loaded texture replacement");++ let handles = (replacement.texture.clone(), replacement.view.clone());+ self.bytes += replacement.bytes;+ self.loaded.insert(name, replacement);++ Some(handles)+ }+}++fn texture_names(width: u32, height: u32, format: TextureFormat, data: &EncodedTexture) -> Option<[String; 3]> {+ let bytes = data.bytes.get(..raw_data_size(width, height, format))?;+ let hash = twox_hash::xxhash64::Hasher::oneshot(0, bytes);++ let mut palette = String::new();+ if format.is_paletted() {+ let (mut min, mut max) = (usize::MAX, 0);+ let mut index = |value: usize| {+ min = min.min(value);+ max = max.max(value);+ };++ match format {+ TextureFormat::CI4 => {+ for &b in bytes {+ index((b & 15) as usize);+ index((b >> 4) as usize);+ }+ }+ TextureFormat::CI8 => {+ for &b in bytes {+ index(b as usize);+ }+ }+ TextureFormat::CI14 => {+ for b in bytes.chunks_exact(2) {+ index((u16::from_be_bytes([b[0], b[1]]) & 0x3fff) as usize);+ }+ }+ _ => unreachable!(),+ }++ let used: Vec<u8> = data+ .palette+ .get(min..=max)?+ .iter()+ .flat_map(|p| p.to_be_bytes())+ .collect();+ palette = format!("_{:016x}", twox_hash::xxhash64::Hasher::oneshot(0, &used));+ }++ let base = format!("tex1_{width}x{height}{}", if data.mipmaps_enabled { "_m" } else { "" });+ let fmt = format as u8;+ Some([+ format!("{base}_{hash:016x}{palette}_{fmt}"),+ format!("{base}_{hash:016x}_$_{fmt}"),+ format!("{base}_${palette}_{fmt}"),+ ])+}++fn validate_size(width: u32, height: u32, limit: u32) -> Result<(), Error> {+ if width == 0+ || height == 0+ || width > limit+ || height > limit+ || u64::from(width) * u64::from(height) * 4 > MAX_IMAGE_BYTES+ {+ return Err("replacement dimensions exceed image or device limits".into());+ }+ Ok(())+}++fn load_entry(entry: &Entry, limit: u32, mipmapped: bool) -> Result<Vec<RgbaImage>, Error> {+ let (mut levels, skipped) = self::load_image(&entry[&0], limit)?;+ if !mipmapped {+ levels.truncate(1);+ return Ok(levels);+ }++ let (width, height) = levels[0].dimensions();+ let count = width.max(height).ilog2() + 1;+ for (&source_level, path) in entry.range(1..) {+ let Some(level) = source_level.checked_sub(skipped) else {+ continue;+ };++ let Some(expected) = mip_dimensions(width, height, count).nth(level as usize) else {+ return Err("replacement mip level exceeds texture dimensions".into());+ };++ let (mut images, sidecar_skipped) = self::load_image(path, limit)?;+ if sidecar_skipped != 0 {+ return Err("replacement mip exceeds image limits".into());+ }++ let image = images.swap_remove(0);+ if image.dimensions() != expected {+ return Err("replacement mip dimensions do not match base level".into());+ }++ while levels.len() <= level as usize {+ self::append_mip(&mut levels);+ }++ levels[level as usize] = image;+ }++ while levels.len() < count as usize {+ self::append_mip(&mut levels);+ }++ Ok(levels)+}++fn append_mip(levels: &mut Vec<RgbaImage>) {+ let last = levels.last().unwrap();+ levels.push(image_codec::imageops::resize(+ last,+ (last.width() / 2).max(1),+ (last.height() / 2).max(1),+ image_codec::imageops::FilterType::Triangle,+ ));+}++fn load_image(path: &Path, limit: u32) -> Result<(Vec<RgbaImage>, u32), Error> {+ if std::fs::metadata(path)?.len() > MAX_FILE_BYTES {+ return Err("replacement file too large".into());+ }++ if path.extension().is_some_and(|ext| ext.eq_ignore_ascii_case("dds")) {+ return self::decode_dds(std::fs::File::open(path)?, limit);+ }++ let mut reader = ImageReader::open(path)?.with_guessed_format()?;+ let mut limits = image_codec::Limits::default();+ limits.max_image_width = Some(limit);+ limits.max_image_height = Some(limit);+ limits.max_alloc = Some(MAX_IMAGE_BYTES);+ reader.limits(limits);++ let image = reader.decode()?.to_rgba8();+ self::validate_size(image.width(), image.height(), limit)?;++ Ok((vec![image], 0))+}++fn decode_dds(reader: impl std::io::Read, limit: u32) -> Result<(Vec<RgbaImage>, u32), Error> {+ use ddsfile::{D3DFormat as D3d, DxgiFormat as Dxgi};++ let dds = ddsfile::Dds::read(reader)?;+ let (width, height) = (dds.get_width(), dds.get_height());+ if width == 0 || height == 0 {+ return Err("invalid DDS dimensions".into());+ }++ if dds.get_depth() != 1 || dds.get_num_array_layers() != 1 {+ return Err("only 2D DDS replacements are supported".into());+ }++ type Decoder = fn(&[u8], usize, usize, &mut [u32]) -> Result<(), &'static str>;+ let (block_size, decoder): (usize, Decoder) = match (dds.get_d3d_format(), dds.get_dxgi_format()) {+ (Some(D3d::DXT1), _) | (_, Some(Dxgi::BC1_UNorm | Dxgi::BC1_UNorm_sRGB)) => (8, texture2ddecoder::decode_bc1a),+ (Some(D3d::DXT3), _) | (_, Some(Dxgi::BC2_UNorm | Dxgi::BC2_UNorm_sRGB)) => (16, texture2ddecoder::decode_bc2),+ (Some(D3d::DXT5), _) | (_, Some(Dxgi::BC3_UNorm | Dxgi::BC3_UNorm_sRGB)) => (16, texture2ddecoder::decode_bc3),+ (_, Some(Dxgi::BC7_UNorm | Dxgi::BC7_UNorm_sRGB)) => (16, texture2ddecoder::decode_bc7),+ _ => return Err("unsupported DDS format (expected BC1/DXT1, BC2/DXT3, BC3/DXT5 or BC7)".into()),+ };++ let count = dds.get_num_mipmap_levels();+ if count == 0 || count > width.max(height).ilog2() + 1 {+ return Err("invalid DDS mip count".into());+ }++ let mut offset = 0;+ let mut levels = Vec::new();+ let mut skipped = 0;+ for (w, h) in mip_dimensions(width, height, count) {+ let len = w.div_ceil(4) as usize * h.div_ceil(4) as usize * block_size;+ let source = dds.data.get(offset..offset + len).ok_or("truncated DDS mip data")?;++ offset += len;+ if self::validate_size(w, h, limit).is_err() {+ skipped += 1;+ continue;+ }++ let mut pixels = vec![0; w as usize * h as usize];+ decoder(source, w as usize, h as usize, &mut pixels)?;++ let rgba = pixels+ .into_iter()+ .flat_map(|p| {+ let [b, g, r, a] = p.to_le_bytes();+ [r, g, b, a]+ })+ .collect();+ levels.push(RgbaImage::from_raw(w, h, rgba).ok_or("invalid DDS dimensions")?);+ }++ if levels.is_empty() {+ return Err("DDS has no mip within image or device limits".into());+ }++ Ok((levels, skipped))+}++fn upload(device: &wgpu::Device, queue: &wgpu::Queue, name: &str, levels: &[RgbaImage], tick: u64) -> Replacement {+ let texture = device.create_texture(&wgpu::TextureDescriptor {+ label: Some(name),+ size: wgpu::Extent3d {+ width: levels[0].width(),+ height: levels[0].height(),+ depth_or_array_layers: 1,+ },+ mip_level_count: levels.len() as u32,+ sample_count: 1,+ dimension: wgpu::TextureDimension::D2,+ format: wgpu::TextureFormat::Rgba8Unorm,+ usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST | wgpu::TextureUsages::COPY_SRC,+ view_formats: &[],+ });++ for (level, image) in levels.iter().enumerate() {+ queue.write_texture(+ wgpu::TexelCopyTextureInfo {+ mip_level: level as u32,+ ..texture.as_image_copy()+ },+ image.as_raw(),+ wgpu::TexelCopyBufferLayout {+ offset: 0,+ bytes_per_row: Some(image.width() * 4),+ rows_per_image: Some(image.height()),+ },+ wgpu::Extent3d {+ width: image.width(),+ height: image.height(),+ depth_or_array_layers: 1,+ },+ );+ }++ let view = texture.create_view(&Default::default());++ Replacement {+ texture,+ view,+ bytes: levels.iter().map(|image| image.as_raw().len()).sum(),+ last_used: tick,+ }+}diff --git a/crates/gecko/src/flipper/gx/bp.rs b/crates/gecko/src/flipper/gx/bp.rsindex 6295987..dbbaca3 100644--- a/crates/gecko/src/flipper/gx/bp.rs+++ b/crates/gecko/src/flipper/gx/bp.rs@@ -308,8 +308,10 @@ impl GraphicsProcessor {// tmem_offset would silently let the latest load clobber the earlier// ones, since bind groups are built lazily and resolve to whichever// GPU texture is current at render-pass time.+ let mipmapped = mode0.min_filter().uses_mipmaps();let mip_levels = texture::mip_level_count(width, height, mode0.min_filter(), mode1.max_lod());- let cache_id = self::texture_cache_id(ram_addr, format, tlut, palette, mip_levels);+ let lod_key = if mipmapped { mip_levels } else { 0 };+ let 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@@ -380,6 +382,7 @@ impl GraphicsProcessor {fmt: format,mip_levels,data: Some(texture::EncodedTexture {+ mipmaps_enabled: mipmapped,bytes: tex_slice.unwrap().to_vec(),palette: palette[..format.palette_entries().min(palette.len())].to_vec(),tlut_format: tlut.format,@@ -405,7 +408,7 @@ impl GraphicsProcessor {wrap_t: mode0.wrap_t(),mag_filter: mode0.mag_filter(),min_filter: mode0.min_filter(),- lod: if mode0.min_filter().uses_mipmaps() {+ lod: if mipmapped {TextureLod {min: mode1.min_lod().min(mode1.max_lod()),max: mode1.max_lod(),@@ -808,7 +811,7 @@ fn texture_cache_id(format: draw::TextureFormat,tlut: draw::TlutRef,palette: &[u16],- mip_levels: u32,+ lod_key: u32,) -> TextureKey {let variant = if format.is_paletted() {let palette_bytes: &[u8] = bytemuck::cast_slice(&palette[..format.palette_entries().min(palette.len())]);@@ -822,7 +825,7 @@ fn texture_cache_id(};TextureKey {ram_addr: ram_addr as u32,- variant: variant ^ (mip_levels - 1).wrapping_mul(0x9e37_79b9),+ variant: variant ^ lod_key.wrapping_mul(0x9e37_79b9),}}diff --git a/crates/gecko/src/flipper/gx/texture.rs b/crates/gecko/src/flipper/gx/texture.rsindex 3471da2..8e88050 100644--- a/crates/gecko/src/flipper/gx/texture.rs+++ b/crates/gecko/src/flipper/gx/texture.rs@@ -5,6 +5,8 @@ use multiversion::multiversion;/// decodes this on the GPU; debug consumers can explicitly request a CPU preview.#[derive(Debug)]pub struct EncodedTexture {+ /// The sampler enables mipmaps, even if MAX_LOD only requests level zero.+ pub mipmaps_enabled: bool,pub bytes: Vec<u8>,pub palette: Vec<u16>,pub tlut_format: TlutFormat,diff --git a/crates/gecko/src/host.rs b/crates/gecko/src/host.rsindex e4a2b57..8314987 100644--- a/crates/gecko/src/host.rs+++ b/crates/gecko/src/host.rs@@ -11,7 +11,7 @@ use std::path::PathBuf;/// frame) silently overwrite each other and bind groups built lazily at/// render-pass time all resolve to whichever decode landed last.///-/// `variant` combines mip count with a 32-bit hash of+/// `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`.#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]diff --git a/crates/tinyapp/src/main.rs b/crates/tinyapp/src/main.rsindex 686e3c2..d4022e7 100644--- a/crates/tinyapp/src/main.rs+++ b/crates/tinyapp/src/main.rs@@ -88,6 +88,14 @@ struct Args {#[arg(long)]immediate: bool,+ /// Disable Dolphin texture replacements from the texturepacks directory+ #[arg(long)]+ no_texture_packs: bool,++ /// Override the texture pack root (defaults to texturepacks in the data directory)+ #[arg(long)]+ texture_pack_dir: Option<std::path::PathBuf>,+/// Disable ANSI escape codes#[arg(long)]no_ansi: bool,@@ -405,6 +413,15 @@ fn run<const SYSTEM: SystemId>(args.upscale,);+ if !args.no_texture_packs+ && let Some(id) = game_id.as_deref()+ {+ let root = args+ .texture_pack_dir+ .clone()+ .unwrap_or_else(|| gecko::paths::resolve("texturepacks"));+ sink.load_texture_pack(&root, id);+ }emulator.render_sink = Box::new(sink);let audio_stream = install_audio_sink(args, &mut emulator);diff --git a/crates/web/Cargo.lock b/crates/web/Cargo.lockindex 9a8242a..7424c2c 100644--- a/crates/web/Cargo.lock+++ b/crates/web/Cargo.lock@@ -167,11 +167,16 @@ dependencies = ["bytemuck","chapa","crossbeam-channel",+ "ddsfile","gecko","glam",+ "image 0.25.10","png","rustc-hash 2.1.2",+ "texture2ddecoder","tracing",+ "twox-hash",+ "walkdir","wesl","wgpu",]@@ -271,6 +276,18 @@ dependencies = ["syn",]+[[package]]+name = "byteorder"+version = "1.5.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"++[[package]]+name = "byteorder-lite"+version = "0.1.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "8f1fe948ff07f4bd06c30984e69f5b4899c516a3ef74f34df92a2df2ab535495"+[[package]]name = "bytes"version = "1.11.1"@@ -534,7 +551,19 @@ dependencies = ["egui-phosphor","gecko","glam",- "image",+ "image 0.1.0",+]++[[package]]+name = "ddsfile"+version = "0.6.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "8be425797f9962624aba78dee473dad28c15999e6ee6feb28ad3ee7928a3bc5b"+dependencies = [+ "bitflags 2.11.1",+ "byteorder",+ "enum-primitive-derive",+ "num-traits",][[package]]@@ -735,6 +764,17 @@ dependencies = ["log",]+[[package]]+name = "enum-primitive-derive"+version = "0.3.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "ba7795da175654fe16979af73f81f26a8ea27638d8d9823d317016888a63dc4c"+dependencies = [+ "num-traits",+ "quote",+ "syn",+]+[[package]]name = "epaint"version = "0.34.2"@@ -928,7 +968,7 @@ dependencies = ["dff","disasm","glam",- "image",+ "image 0.1.0","libc","multiversion","rustc-hash 2.1.2",@@ -936,6 +976,7 @@ dependencies = ["tracing","twox-hash","zerocopy",+ "zstd",][[package]]@@ -985,9 +1026,9 @@ dependencies = [[[package]]name = "glam"-version = "0.32.1"+version = "0.33.10"source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "f70749695b063ecbf6b62949ccccde2e733ec3ecbbd71d467dca4e5c6c97cca0"+checksum = "928452f9c953e142b2f0973e4bd5f34445fcaa8069556ea97a3c9d34d15a4cf8"dependencies = ["bytemuck",]@@ -1209,6 +1250,19 @@ dependencies = ["zip",]+[[package]]+name = "image"+version = "0.25.10"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "85ab80394333c02fe689eaf900ab500fbd0c2213da414687ebf995a65d5a6104"+dependencies = [+ "bytemuck",+ "byteorder-lite",+ "moxcms",+ "num-traits",+ "png",+]+[[package]]name = "indexmap"version = "2.14.0"@@ -1578,6 +1632,16 @@ dependencies = ["simd-adler32",]+[[package]]+name = "moxcms"+version = "0.8.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "bb85c154ba489f01b25c0d36ae69a87e4a1c73a72631fc6c0eb6dde34a73e44b"+dependencies = [+ "num-traits",+ "pxfm",+]+[[package]]name = "multiversion"version = "0.8.0"@@ -2028,6 +2092,12 @@ dependencies = ["windows-link",]+[[package]]+name = "paste"+version = "1.0.15"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"+[[package]]name = "peniko"version = "0.6.0"@@ -2200,6 +2270,12 @@ version = "1.0.17"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "3eb8486b569e12e2c32ad3e204dbaba5e4b5b216e9367044f25f1dba42341773"+[[package]]+name = "pxfm"+version = "0.1.30"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "d55d956fa96f5ec02be2e13af0e20391a5aa83d6a074e3ad368959d0fab299ea"+[[package]]name = "quick-xml"version = "0.39.2"@@ -2672,6 +2748,15 @@ dependencies = ["winapi-util",]+[[package]]+name = "texture2ddecoder"+version = "0.1.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "427ae8ec7f2f0fdd3146b77cfa44bea880caf066f7e55398a8467afe2645c832"+dependencies = [+ "paste",+]+[[package]]name = "thiserror"version = "1.0.69"@@ -2816,9 +2901,9 @@ checksum = "d2df906b07856748fa3f6e0ad0cbaa047052d4a7dd609e231c4f72cee8c36f31"[[package]]name = "twox-hash"-version = "2.1.2"+version = "2.1.4"source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "9ea3136b675547379c4bd395ca6b938e5ad3c3d20fad76e7fe85f9e0d011419c"+checksum = "5283634e518fe9e82c7b20520bb4bc209009fd16c82077c802f8111ecbb0117a"dependencies = ["rand",]@@ -3120,7 +3205,7 @@ dependencies = ["egui-winit","gecko","getrandom",- "image",+ "image 0.1.0","wasm-bindgen","wasm-bindgen-futures","web-sys",@@ -3770,18 +3855,18 @@ dependencies = [[[package]]name = "zerocopy"-version = "0.8.48"+version = "0.8.58"source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "eed437bf9d6692032087e337407a86f04cd8d6a16a37199ed57949d415bd68e9"+checksum = "c17e8fafad82b542ff3717217ecdc736231b59e387768c9630123b4ce4d2db44"dependencies = ["zerocopy-derive",][[package]]name = "zerocopy-derive"-version = "0.8.48"+version = "0.8.58"source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "70e3cd084b1788766f53af483dd21f93881ff30d7320490ec3ef7526d203bad4"+checksum = "595f56e044df4f46a0c9a626f65c3d99eb8488f7e8a8baa12dd76326d9710bf2"dependencies = ["proc-macro2","quote",@@ -3873,3 +3958,31 @@ dependencies = ["log","simd-adler32",]++[[package]]+name = "zstd"+version = "0.13.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "e91ee311a569c327171651566e07972200e76fcfe2242a4fa446149a3881c08a"+dependencies = [+ "zstd-safe",+]++[[package]]+name = "zstd-safe"+version = "7.3.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "64d80649ab6db9d9f6f9c80a40becd948eda4714a0a5ac8c4d157a32231c7882"+dependencies = [+ "zstd-sys",+]++[[package]]+name = "zstd-sys"+version = "2.1.0+zstd.1.5.7"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "0ef0a8027ec3ee71300ab3bcbcd0393f434aa72b91ca6d635a39941deae8eea0"+dependencies = [+ "cc",+ "pkg-config",+]