Skip to content

armgit / gecko

Public Imported from GitHub
0

A GameCube/Wii emulator and debugger written in Rust.

texture pack support

Laylec0324fcf20f3
diff --git a/Cargo.lock b/Cargo.lock
index 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.md
index 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.rs
index 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.rs
index 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.rs
index 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, &params, 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.rs
index 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.toml
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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 = self
diff --git a/crates/backend-wgpu/src/sink.rs b/crates/backend-wgpu/src/sink.rs
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.lock
index 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",
+]