A GameCube/Wii emulator and debugger written in Rust.
refactor, save games, faster gx (dls causing recalcs despite no state change)
Layle006dcd5a866e
diff --git a/Cargo.lock b/Cargo.lockindex 36e8816..b2cb5d5 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -2310,6 +2310,7 @@ dependencies = ["twox-hash","windows-sys 0.61.2","zerocopy",+ "zstd",][[package]]diff --git a/crates/app/src/app.rs b/crates/app/src/app.rsindex 0798384..04cfec7 100644--- a/crates/app/src/app.rs+++ b/crates/app/src/app.rs@@ -81,6 +81,8 @@ pub enum Message {PlayerToggleUncapped(window::Id),PlayerTogglePause(window::Id),PlayerScreenshot(window::Id),+ PlayerSaveState(window::Id),+ PlayerLoadState(window::Id),}#[derive(Debug, Clone)]@@ -682,6 +684,24 @@ impl App {player.toast = Some(Toast::new(title, detail));Task::none()}+ Message::PlayerSaveState(id) => {+ let Some(player) = self.players.get_mut(&id) else {+ return Task::none();+ };++ player.state.request_save_state();+ player.toast = Some(Toast::new("Saving state", player.game.game_id.clone()));+ Task::none()+ }+ Message::PlayerLoadState(id) => {+ let Some(player) = self.players.get_mut(&id) else {+ return Task::none();+ };++ player.state.request_load_state();+ player.toast = Some(Toast::new("Loading state", player.game.game_id.clone()));+ Task::none()+ }}}diff --git a/crates/app/src/keybinds.rs b/crates/app/src/keybinds.rsindex dd9f9d3..ad39c47 100644--- a/crates/app/src/keybinds.rs+++ b/crates/app/src/keybinds.rs@@ -59,6 +59,8 @@ pub struct HotkeysConfig {pub fullscreen: Option<String>,pub overlay: Option<String>,pub screenshot: Option<String>,+ pub save_state: Option<String>,+ pub load_state: Option<String>,}#[derive(Debug, Clone, Copy)]@@ -154,6 +156,8 @@ pub struct Hotkeys {pub fullscreen: Code,pub overlay: Code,pub screenshot: Code,+ pub save_state: Code,+ pub load_state: Code,}impl Default for Hotkeys {@@ -164,6 +168,8 @@ impl Default for Hotkeys {fullscreen: Code::F10,overlay: Code::F11,screenshot: Code::F12,+ save_state: Code::F5,+ load_state: Code::F7,}}}@@ -182,6 +188,8 @@ pub enum Hotkey {Fullscreen,Overlay,Screenshot,+ SaveState,+ LoadState,}impl Hotkeys {@@ -196,6 +204,10 @@ impl Hotkeys {Some(Hotkey::Overlay)} else if key == self.screenshot {Some(Hotkey::Screenshot)+ } else if key == self.save_state {+ Some(Hotkey::SaveState)+ } else if key == self.load_state {+ Some(Hotkey::LoadState)} else {None}@@ -241,6 +253,8 @@ pub enum KeyTarget {HotkeyFullscreen,HotkeyOverlay,HotkeyScreenshot,+ HotkeySaveState,+ HotkeyLoadState,}pub const GC_KEY_TARGETS: &[(KeyTarget, &str)] = &[@@ -287,6 +301,8 @@ pub const HOTKEY_TARGETS: &[(KeyTarget, &str)] = &[(KeyTarget::HotkeyFullscreen, "Fullscreen"),(KeyTarget::HotkeyOverlay, "Overlay"),(KeyTarget::HotkeyScreenshot, "Screenshot"),+ (KeyTarget::HotkeySaveState, "Save State"),+ (KeyTarget::HotkeyLoadState, "Load State"),];pub fn field(config: &mut KeyboardConfig, target: KeyTarget) -> &mut Option<String> {@@ -328,6 +344,8 @@ pub fn field(config: &mut KeyboardConfig, target: KeyTarget) -> &mut Option<StriKeyTarget::HotkeyFullscreen => &mut config.hotkeys.fullscreen,KeyTarget::HotkeyOverlay => &mut config.hotkeys.overlay,KeyTarget::HotkeyScreenshot => &mut config.hotkeys.screenshot,+ KeyTarget::HotkeySaveState => &mut config.hotkeys.save_state,+ KeyTarget::HotkeyLoadState => &mut config.hotkeys.load_state,}}@@ -371,6 +389,8 @@ impl Keymap {KeyTarget::HotkeyFullscreen => self.hotkeys.fullscreen,KeyTarget::HotkeyOverlay => self.hotkeys.overlay,KeyTarget::HotkeyScreenshot => self.hotkeys.screenshot,+ KeyTarget::HotkeySaveState => self.hotkeys.save_state,+ KeyTarget::HotkeyLoadState => self.hotkeys.load_state,}}}@@ -418,6 +438,8 @@ impl KeyboardConfig {self::set(&mut keymap.hotkeys.fullscreen, &self.hotkeys.fullscreen);self::set(&mut keymap.hotkeys.overlay, &self.hotkeys.overlay);self::set(&mut keymap.hotkeys.screenshot, &self.hotkeys.screenshot);+ self::set(&mut keymap.hotkeys.save_state, &self.hotkeys.save_state);+ self::set(&mut keymap.hotkeys.load_state, &self.hotkeys.load_state);keymap}diff --git a/crates/app/src/player/emu_thread.rs b/crates/app/src/player/emu_thread.rsindex 8c3b515..7089c4c 100644--- a/crates/app/src/player/emu_thread.rs+++ b/crates/app/src/player/emu_thread.rs@@ -13,6 +13,9 @@ pub fn run<const SYSTEM: SystemId>(throttle: Arc<AtomicBool>,paused: Arc<AtomicBool>,shutdown: Arc<AtomicBool>,+ savestate_path: std::path::PathBuf,+ save_state: Arc<AtomicBool>,+ load_state: Arc<AtomicBool>,) {let sleeper = SpinSleeper::default();let throttle_step = Duration::from_micros(5);@@ -38,6 +41,20 @@ pub fn run<const SYSTEM: SystemId>(}emulator.run_until_vsync();++ if save_state.swap(false, Ordering::Relaxed) {+ match emulator.save_state_to_file(&savestate_path) {+ Ok(()) => tracing::info!(path = %savestate_path.display(), "savestate saved"),+ Err(err) => tracing::error!(%err, "savestate save failed"),+ }+ }++ if load_state.swap(false, Ordering::Relaxed) {+ match emulator.load_state_from_file(&savestate_path) {+ Ok(()) => tracing::info!(path = %savestate_path.display(), "savestate loaded"),+ Err(err) => tracing::error!(%err, "savestate load failed"),+ }+ }}if let Some(game_id) = game_id.as_deref() {diff --git a/crates/app/src/player/state.rs b/crates/app/src/player/state.rsindex 0169ade..1373fc9 100644--- a/crates/app/src/player/state.rs+++ b/crates/app/src/player/state.rs@@ -42,6 +42,8 @@ pub struct PlayerState {shutdown: Arc<AtomicBool>,throttle: Arc<AtomicBool>,paused: Arc<AtomicBool>,+ save_state: Arc<AtomicBool>,+ load_state: Arc<AtomicBool>,aspect: TargetAspect,upscale: u32,input: Arc<Mutex<HostInput>>,@@ -99,6 +101,8 @@ impl PlayerState {shutdown: Arc::new(AtomicBool::new(false)),throttle: Arc::new(AtomicBool::new(true)),paused: Arc::new(AtomicBool::new(false)),+ save_state: Arc::new(AtomicBool::new(false)),+ load_state: Arc::new(AtomicBool::new(false)),aspect,upscale: config.upscale,input: Arc::new(Mutex::new(neutral)),@@ -233,6 +237,14 @@ impl PlayerState {self.paused.fetch_xor(true, Ordering::Relaxed);}+ pub fn request_save_state(&self) {+ self.save_state.store(true, Ordering::Relaxed);+ }++ pub fn request_load_state(&self) {+ self.load_state.store(true, Ordering::Relaxed);+ }+pub fn is_paused(&self) -> bool {self.paused.load(Ordering::Relaxed)}@@ -320,6 +332,8 @@ fn finish_boot<const S: gecko::system::SystemId>(let _ = emu.load_jit_cache(&game_id);self::set_initialized(&state, renderer, audio, &game_id);+ let savestate_path = gecko::savestate::state_path(Some(&game_id));+emu_thread::run::<S>(emu,state.input.clone(),@@ -328,6 +342,9 @@ fn finish_boot<const S: gecko::system::SystemId>(state.throttle.clone(),state.paused.clone(),state.shutdown.clone(),+ savestate_path,+ state.save_state.clone(),+ state.load_state.clone(),);}diff --git a/crates/app/src/player/widget.rs b/crates/app/src/player/widget.rsindex a3f20da..32979f8 100644--- a/crates/app/src/player/widget.rs+++ b/crates/app/src/player/widget.rs@@ -21,6 +21,8 @@ fn hotkey_message(hotkey: Hotkey, window: window::Id) -> Message {Hotkey::Fullscreen => Message::PlayerToggleFullscreen(window),Hotkey::Overlay => Message::PlayerToggleOverlay(window),Hotkey::Screenshot => Message::PlayerScreenshot(window),+ Hotkey::SaveState => Message::PlayerSaveState(window),+ Hotkey::LoadState => Message::PlayerLoadState(window),}}diff --git a/crates/backend-wgpu/src/action.rs b/crates/backend-wgpu/src/action.rsindex cde4fa8..732db9e 100644--- a/crates/backend-wgpu/src/action.rs+++ b/crates/backend-wgpu/src/action.rs@@ -6,12 +6,12 @@ use crate::{};use gecko::flipper::gx::draw::Primitive;use gecko::flipper::gx::regs::{CullMode, MagFilter, MinFilter, WrapMode};-use gecko::host::{DrawData, GxAction};+use gecko::host::{DrawData, DrawState, GxAction};use glam::{Mat4, UVec4, Vec4};#[cfg(feature = "gx-stats")]use std::sync::atomic::Ordering;-fn draw_active_slot_mask(draw: &DrawData) -> u8 {+fn draw_active_slot_mask(draw: &DrawState) -> u8 {let mut mask: u8 = 0;let num_stages = (draw.num_tev_stages as usize).min(draw.tev_orders.len());@@ -60,6 +60,48 @@ fn pack_u32_slice_to_uvec4x4(data: &[u32]) -> [UVec4; 4] {]}+fn build_frame_uniform(draw: &DrawState, alpha_cmp: gecko::flipper::gx::regs::AlphaCompare) -> FrameUniforms {+ FrameUniforms {+ tev_color_regs: draw.tev_color_regs.map(Vec4::from),+ tev_konst_colors: draw.tev_konst_colors.map(Vec4::from),+ tev_color_env: pack_u32_slice_to_uvec4x4(&draw.tev_color_env),+ tev_alpha_env: pack_u32_slice_to_uvec4x4(&draw.tev_alpha_env),+ tev_orders: pack_u32_slice_to_uvec4x4(&draw.tev_orders),+ tev_ksel: pack_u32_slice_to_uvec4x4(&draw.tev_ksel),+ num_tev_stages: draw.num_tev_stages as u32,+ alpha_ref0: alpha_cmp.ref0() as f32 / 255.0,+ alpha_ref1: alpha_cmp.ref1() as f32 / 255.0,+ alpha_comp0: alpha_cmp.comp0() as u32,+ alpha_comp1: alpha_cmp.comp1() as u32,+ alpha_op: alpha_cmp.op() as u32,+ _pad0: [0; 2],+ indirect_matrices: draw.indirect_matrices.map(glam::IVec4::from),+ indirect_scales: draw.indirect_scales.map(glam::UVec4::from),+ indirect_refs: draw.indirect_refs,+ num_indirect_stages: draw.num_indirect_stages as u32,+ bump_imask: draw.bump_imask,+ _pad1: 0,+ tev_indirect: pack_u32_slice_to_uvec4x4(&draw.tev_indirect),+ light_colors: draw.lights.each_ref().map(|l| Vec4::from(l.color)),+ light_cosatt: draw.lights.each_ref().map(|l| Vec4::from(l.cosatt)),+ light_distatt: draw.lights.each_ref().map(|l| Vec4::from(l.distatt)),+ light_pos: draw.lights.each_ref().map(|l| Vec4::from(l.position)),+ light_dir: draw.lights.each_ref().map(|l| Vec4::from(l.direction)),+ color_ctrl0: draw.color_ctrl[0].raw(),+ alpha_ctrl0: draw.alpha_ctrl[0].raw(),+ color_ctrl1: draw.color_ctrl[1].raw(),+ alpha_ctrl1: draw.alpha_ctrl[1].raw(),+ ambient_color0: Vec4::from(draw.ambient_color[0]),+ ambient_color1: Vec4::from(draw.ambient_color[1]),+ material_color0: Vec4::from(draw.material_color[0]),+ material_color1: Vec4::from(draw.material_color[1]),+ ztex_bias: draw.ztex_bias,+ ztex_type: draw.ztex_type as u32,+ ztex_op: draw.ztex_op as u32,+ _pad2: 0,+ }+}+impl GxRenderer {fn current_pipeline_key(&self, ztex: bool) -> PipelineKey {let blend = self.current_blend_mode;@@ -89,6 +131,22 @@ impl GxRenderer {}}+ /// Append `draw`'s vertices and indices onto the draw already recorded at+ /// `previous`, rebasing the indices onto the merged vertex range.+ fn merge_into_previous(&mut self, previous: usize, draw: &DrawData) {+ let vertex_bias = self.scratch_draws[previous].vertex_count;+ let (_, additional_indices) = self::emit_draw_indices(draw, &mut self.scratch_indices, vertex_bias);++ let merged = &mut self.scratch_draws[previous];+ merged.vertex_count += draw.vertex_count;+ merged.index_count += additional_indices;++ #[cfg(feature = "renderdoc-capture")]+ {+ self.draw_primitives[previous] = Primitive::Triangles;+ }+ }+/// Replace the renderer's vertex scratch with `new_scratch`, returning the/// previous buffer. For sinks (like web) that decouple vertex appending/// from action processing vertices are collected in a shared `Vec`@@ -137,6 +195,10 @@ impl GxRenderer {let frame_stride = self.frame_stride;let frame_struct_size = FRAME_UNIFORMS_SIZE.get() as usize;+ if !matches!(action, GxAction::Draw(_)) {+ self.draw_fast_path_compatible = false;+ }+match action {GxAction::SetProjection { matrix, is_perspective } => {self.current_projection = Mat4::from_cols_array_2d(matrix);@@ -277,12 +339,62 @@ impl GxRenderer {}GxAction::Draw(draw) => {+ let state_changed = draw.state.is_some();+ if let Some(state) = draw.state.as_ref() {+ self.current_draw_state.clone_from(state);+ let shader_key = ShaderKey::from_draw(state, self.current_alpha_compare);+ self.current_shader_key = Some(shader_key);+ self.current_specialization_key =+ ShaderSpecializationKey::from_draw(state, self.current_alpha_compare, shader_key);+ self.current_active_texture_mask = draw_active_slot_mask(state);+ }+if cull_all_suppresses_draw(self.current_cull_mode, draw.primitive) {self.last_frame_uniform_index = None;+ self.draw_fast_path_compatible = false;+ return;+ }++ if !draw_emits_triangles(draw) {+ tracing::warn!("draw call produced zero vertices, skipping");+ self.draw_fast_path_compatible = false;return;}- let shader_key = ShaderKey::from_draw(draw, self.current_alpha_compare);+ if !state_changed+ && self.draw_fast_path_compatible+ && let Some(previous) = self.scratch_draws.len().checked_sub(1)+ && let Some(shader_key) = self.current_shader_key+ {+ let stride = crate::packed_vertex_stride(shader_key.active_texcoords);+ let previous_draw = self.scratch_draws[previous];+ if previous_draw.src_vertex_index + previous_draw.vertex_count == draw.base_vertex+ && previous_draw.packed_vertex_stride == stride+ {+ self.merge_into_previous(previous, draw);+ return;+ }+ }++ let state = &self.current_draw_state;++ let shader_key = self+ .current_shader_key+ .unwrap_or_else(|| ShaderKey::from_draw(state, self.current_alpha_compare));+ let specialization = if self.current_shader_key.is_some() {+ self.current_specialization_key+ } else {+ ShaderSpecializationKey::from_draw(state, self.current_alpha_compare, shader_key)+ };+ let ztex_enabled = state.ztex_op != 0;+ let active = if self.current_shader_key.is_some() {+ self.current_active_texture_mask+ } else {+ draw_active_slot_mask(state)+ };+ let num_indirect_stages = state.num_indirect_stages;+ let next_frame_uniform = (state_changed || self.last_frame_uniform_index.is_none())+ .then(|| build_frame_uniform(state, self.current_alpha_compare));if !self.shader_cache.contains_key(&shader_key) {#[cfg(feature = "gx-stats")]let shader_started = std::time::Instant::now();@@ -301,10 +413,10 @@ impl GxRenderer {}tracing::info!(?shader_key, "compiled specialized shader variant");}- let pipeline_key = self.current_pipeline_key(draw.ztex_op != 0);+ let pipeline_key = self.current_pipeline_key(ztex_enabled);let full_key = FullPipelineKey {shader: shader_key,- specialization: ShaderSpecializationKey::from_draw(draw, self.current_alpha_compare, shader_key),+ specialization,fixed: pipeline_key,};if !self.pipeline_cache.contains_key(&full_key) {@@ -334,10 +446,6 @@ impl GxRenderer {let first_vertex = draw.base_vertex;let vertex_count = draw.vertex_count;- if !draw_emits_triangles(draw) {- tracing::warn!("draw call produced zero vertices, skipping");- return;- }// Build per-draw uniform using tracked projection. The// freecam view transform only applies to perspective draws@@ -347,10 +455,8 @@ impl GxRenderer {} else {self.current_projection};- let active = draw_active_slot_mask(draw);-let mut tex_dims = [UVec4::splat(1); 4];- if draw.num_indirect_stages > 0 {+ if num_indirect_stages > 0 {for slot in 0..8 {if (active >> slot) & 1 == 0 {continue;@@ -372,58 +478,14 @@ impl GxRenderer {let draw_uniform = DrawUniforms { mvp, tex_dims };let draw_uniform_bytes = bytemuck::bytes_of(&draw_uniform);let bg_key = trim_bg_key(self.current_bind_group_key(), active);- // Matches the WESL `VsIn` layout gated by- // `TEXCOORD_N_ENABLED`: 5 fixed attrs (68b) + N texcoord- // attrs (12 bytes each).- let stride = 68 + 12 * shader_key.active_texcoords as u32;+ let stride = crate::packed_vertex_stride(shader_key.active_texcoords);// Build a fresh FrameUniforms slot only when the producer// signaled state changed since the last draw or this is the// first draw of the flush.let frame_bytes_len_before = self.frame_uniform_bytes.len();let mut frame_was_pushed = false;- let frame_idx = if draw.frame_dirty || self.last_frame_uniform_index.is_none() {- let alpha_cmp = self.current_alpha_compare;- let frame_uniform = FrameUniforms {- tev_color_regs: draw.tev_color_regs.map(Vec4::from),- tev_konst_colors: draw.tev_konst_colors.map(Vec4::from),- tev_color_env: pack_u32_slice_to_uvec4x4(&draw.tev_color_env),- tev_alpha_env: pack_u32_slice_to_uvec4x4(&draw.tev_alpha_env),- tev_orders: pack_u32_slice_to_uvec4x4(&draw.tev_orders),- tev_ksel: pack_u32_slice_to_uvec4x4(&draw.tev_ksel),- num_tev_stages: draw.num_tev_stages as u32,- alpha_ref0: alpha_cmp.ref0() as f32 / 255.0,- alpha_ref1: alpha_cmp.ref1() as f32 / 255.0,- alpha_comp0: alpha_cmp.comp0() as u32,- alpha_comp1: alpha_cmp.comp1() as u32,- alpha_op: alpha_cmp.op() as u32,- _pad0: [0; 2],- indirect_matrices: draw.indirect_matrices.map(glam::IVec4::from),- indirect_scales: draw.indirect_scales.map(glam::UVec4::from),- indirect_refs: draw.indirect_refs,- num_indirect_stages: draw.num_indirect_stages as u32,- bump_imask: draw.bump_imask,- _pad1: 0,- tev_indirect: pack_u32_slice_to_uvec4x4(&draw.tev_indirect),- light_colors: draw.lights.each_ref().map(|l| Vec4::from(l.color)),- light_cosatt: draw.lights.each_ref().map(|l| Vec4::from(l.cosatt)),- light_distatt: draw.lights.each_ref().map(|l| Vec4::from(l.distatt)),- light_pos: draw.lights.each_ref().map(|l| Vec4::from(l.position)),- light_dir: draw.lights.each_ref().map(|l| Vec4::from(l.direction)),- color_ctrl0: draw.color_ctrl[0].raw(),- alpha_ctrl0: draw.alpha_ctrl[0].raw(),- color_ctrl1: draw.color_ctrl[1].raw(),- alpha_ctrl1: draw.alpha_ctrl[1].raw(),- ambient_color0: Vec4::from(draw.ambient_color[0]),- ambient_color1: Vec4::from(draw.ambient_color[1]),- material_color0: Vec4::from(draw.material_color[0]),- material_color1: Vec4::from(draw.material_color[1]),- ztex_bias: draw.ztex_bias,- ztex_type: draw.ztex_type as u32,- ztex_op: draw.ztex_op as u32,- _pad2: 0,- };-+ let frame_idx = if let Some(frame_uniform) = next_frame_uniform {let fstart = self.frame_uniform_bytes.len();self.frame_uniform_bytes.resize(fstart + frame_stride, 0);self.frame_uniform_bytes[fstart..fstart + frame_struct_size]@@ -465,15 +527,7 @@ impl GxRenderer {frame_was_pushed = false;}- let vertex_bias = self.scratch_draws[previous].vertex_count;- let (_, additional_indices) = emit_draw_indices(draw, &mut self.scratch_indices, vertex_bias);- let merged = &mut self.scratch_draws[previous];- merged.vertex_count += vertex_count;- merged.index_count += additional_indices;- #[cfg(feature = "renderdoc-capture")]- {- self.draw_primitives[previous] = Primitive::Triangles;- }+ self.merge_into_previous(previous, draw);} else {let first_index = self.scratch_indices.len() as u32;let (_, index_count) = emit_draw_indices(draw, &mut self.scratch_indices, 0);@@ -506,6 +560,7 @@ impl GxRenderer {}debug_assert!(!frame_was_pushed || self.last_frame_uniform_index == Some(frame_idx));+ self.draw_fast_path_compatible = true;}GxAction::CopyXfb {diff --git a/crates/backend-wgpu/src/lib.rs b/crates/backend-wgpu/src/lib.rsindex 41572f0..846d1d5 100644--- a/crates/backend-wgpu/src/lib.rs+++ b/crates/backend-wgpu/src/lib.rs@@ -17,13 +17,13 @@ use gecko::flipper::gx::draw::Primitive;use gecko::flipper::gx::draw::{Scissor, TextureFormat, Viewport};use gecko::flipper::gx::regs::{AlphaCompare, BlendMode, CompareFunc, CullMode, MagFilter, MinFilter, WrapMode, ZMode};-use gecko::host::TextureKey;+use gecko::host::{DrawState, TextureKey};use glam::Mat4;use pipeline::{FullPipelineKey, UberPipelineKey};use rustc_hash::FxHashMap;#[cfg(not(target_arch = "wasm32"))]use rustc_hash::FxHashSet;-use shader_specialization::ShaderKey;+use shader_specialization::{ShaderKey, ShaderSpecializationKey};use std::num::NonZeroU64;#[cfg(feature = "gx-stats")]use std::sync::{@@ -340,6 +340,11 @@ pub struct GxRenderer {pub(crate) current_blend_mode: BlendMode,pub(crate) current_alpha_compare: AlphaCompare,pub(crate) current_cull_mode: CullMode,+ pub(crate) current_draw_state: DrawState,+ pub(crate) current_shader_key: Option<ShaderKey>,+ pub(crate) current_specialization_key: ShaderSpecializationKey,+ pub(crate) current_active_texture_mask: u8,+ pub(crate) draw_fast_path_compatible: bool,pub(crate) current_texture_ids: [Option<TextureKey>; 8],pub(crate) current_sampler_keys: [Option<SamplerKey>; 8],// XFB output texture: composited from per-copy snapshots by PresentXfb.@@ -394,11 +399,17 @@ pub(crate) struct DrawRecord {/// section of `draw_buffer` (relative to section start, not buffer/// start). Used to compute the buffer slice for `set_vertex_buffer`.pub packed_vertex_byte_offset: u32,- /// Bytes per vertex in the packed stream- /// (`68 + 12 * active_texcoords`).+ /// Bytes per vertex in the packed stream, see [`packed_vertex_stride`].pub packed_vertex_stride: u32,}+/// Bytes per vertex in the packed stream. Matches the WESL `VsIn` layout+/// gated by `TEXCOORD_N_ENABLED`: 5 fixed attrs (68b) + N texcoord attrs+/// (12 bytes each).+pub(crate) fn packed_vertex_stride(active_texcoords: u8) -> u32 {+ 68 + 12 * active_texcoords as u32+}+pub(crate) struct PendingWriteback {pub dest_addr: Address,pub staging: wgpu::Buffer,@@ -990,6 +1001,11 @@ impl GxRenderer {current_alpha_compare: AlphaCompare::from_raw(0).with_comp0(CompareFunc::Always).with_comp1(CompareFunc::Always),+ current_draw_state: DrawState::default(),+ current_shader_key: None,+ current_specialization_key: ShaderSpecializationKey::default(),+ current_active_texture_mask: 0,+ draw_fast_path_compatible: false,current_texture_ids: Default::default(),current_sampler_keys: Default::default(),xfb_texture,diff --git a/crates/backend-wgpu/src/shader_specialization.rs b/crates/backend-wgpu/src/shader_specialization.rsindex 1f7e6b5..acf75e0 100644--- a/crates/backend-wgpu/src/shader_specialization.rs+++ b/crates/backend-wgpu/src/shader_specialization.rs@@ -1,5 +1,5 @@use gecko::flipper::gx::regs::{AlphaCompare, AlphaOp, CompareFunc};-use gecko::host::DrawData;+use gecko::host::DrawState;use std::fs::File;use std::io::{BufWriter, Read, Write as IoWrite};use std::path::Path;@@ -130,7 +130,7 @@ const TEV_INDIRECT_NAMES: [&str; 16] = [];impl ShaderSpecializationKey {- pub(crate) fn from_draw(draw: &DrawData, alpha_cmp: AlphaCompare, shader: ShaderKey) -> Self {+ pub(crate) fn from_draw(draw: &DrawState, alpha_cmp: AlphaCompare, shader: ShaderKey) -> Self {let tev_stages = usize::from(shader.num_tev_stages.min(16));let indirect_stages = u32::from(shader.num_indirect_stages.min(4));@@ -307,7 +307,7 @@ impl ShaderSpecializationKey {}impl ShaderKey {- pub(crate) fn from_draw(draw: &DrawData, alpha_cmp: AlphaCompare) -> Self {+ pub(crate) fn from_draw(draw: &DrawState, alpha_cmp: AlphaCompare) -> Self {let num_tev_stages = draw.num_tev_stages.clamp(1, 16);let num_indirect_stages = draw.num_indirect_stages.min(4);let has_lighting_c0 = draw.color_ctrl[0].enable() || draw.alpha_ctrl[0].enable();diff --git a/crates/backend-wgpu/src/sink.rs b/crates/backend-wgpu/src/sink.rsindex a323f60..3820bcb 100644--- a/crates/backend-wgpu/src/sink.rs+++ b/crates/backend-wgpu/src/sink.rs@@ -66,6 +66,7 @@ pub struct ThreadedSink {worker_thread: Option<JoinHandle<()>>,pending_actions: Vec<GxAction>,scratch: Vec<DrawVertex>,+ efb_writeback_pending: bool,}#[cfg(not(target_arch = "wasm32"))]@@ -285,6 +286,10 @@ impl RenderSink for ThreadedSink {#[cfg(feature = "gx-stats")]self.stats.actions_sent.fetch_add(1, Ordering::Relaxed);+ if matches!(&action, GxAction::CopyEfbToTexture { .. }) {+ self.efb_writeback_pending = true;+ }+let resets_scratch = action_resets_vertex_scratch(&action);self.pending_actions.push(action);@@ -294,6 +299,10 @@ impl RenderSink for ThreadedSink {}fn flush_efb_copies(&mut self, ram: &mut gecko::mmio::RamViewMut<'_>) {+ if !self.efb_writeback_pending {+ return;+ }+let (done_tx, done_rx) = crossbeam_channel::bounded(0);let request = EfbDrainRequest {mem1_addr: ram.mem1.as_mut_ptr() as usize,@@ -323,6 +332,7 @@ impl RenderSink for ThreadedSink {debug_assert!(batch.actions.is_empty());self.pending_actions = batch.actions;self.scratch = batch.vertices;+ self.efb_writeback_pending = false;}fn vertex_scratch(&mut self) -> &mut Vec<DrawVertex> {@@ -575,6 +585,7 @@ impl Renderer {worker_thread: Some(worker_thread),pending_actions: Vec::new(),scratch: Vec::new(),+ efb_writeback_pending: false,};let renderer = Renderer {diff --git a/crates/dbglib/src/lib.rs b/crates/dbglib/src/lib.rsindex f9f4acc..30d3120 100644--- a/crates/dbglib/src/lib.rs+++ b/crates/dbglib/src/lib.rs@@ -4,15 +4,9 @@ pub mod windows;#[cfg(not(target_arch = "wasm32"))]use std::io::Write;-use gecko::scheduler::{DSP_BATCH_SIZE, ScheduledFn, cpu_cycles_per_dsp_tick, dsp_batch_handler};+use gecko::scheduler::{DSP_BATCH_SIZE, Handler, cpu_cycles_per_dsp_tick};use gecko::system::{System, SystemId};-/// Identify the DSP batch handler so the debugger can intercept it for per-instruction tracing.-#[inline(always)]-fn is_dsp_batch<const SYSTEM: SystemId>(f: ScheduledFn<SYSTEM>) -> bool {- (f as usize) == (dsp_batch_handler::<SYSTEM> as ScheduledFn<SYSTEM> as usize)-}-#[derive(Debug, PartialEq, Eq, Clone, Copy)]pub enum EmulatorState {Running,@@ -159,8 +153,8 @@ impl Debugger {/// Drain and process scheduler events, tracing DSP ticks when active.#[inline(always)]fn drain_events<const SYSTEM: SystemId>(&mut self, emulator: &mut System<SYSTEM>) {- while let Some(f) = emulator.scheduler.poll() {- if is_dsp_batch::<SYSTEM>(f) && self.is_dsp_tracing() {+ while let Some(handler) = emulator.scheduler.poll() {+ if handler == Handler::DspBatch && self.is_dsp_tracing() {for _ in 0..DSP_BATCH_SIZE {self.dsp_trace_step(emulator);if !emulator.step_dsp_instruction() {@@ -168,12 +162,11 @@ impl Debugger {}}gecko::flipper::dsp::refresh_interrupts(emulator);- emulator.scheduler.schedule_in(- cpu_cycles_per_dsp_tick(SYSTEM) * DSP_BATCH_SIZE,- dsp_batch_handler::<SYSTEM>,- );+ emulator+ .scheduler+ .schedule_in(cpu_cycles_per_dsp_tick(SYSTEM) * DSP_BATCH_SIZE, Handler::DspBatch);} else {- f(emulator);+ handler.resolve::<SYSTEM>()(emulator);}}}@@ -184,8 +177,8 @@ impl Debugger {#[inline(always)]fn drain_events_until_dsp<const SYSTEM: SystemId>(&mut self, emulator: &mut System<SYSTEM>) -> bool {let mut dsp_hit = false;- while let Some(f) = emulator.scheduler.poll() {- if is_dsp_batch::<SYSTEM>(f) {+ while let Some(handler) = emulator.scheduler.poll() {+ if handler == Handler::DspBatch {if self.is_dsp_tracing() {for _ in 0..DSP_BATCH_SIZE {self.dsp_trace_step(emulator);@@ -194,16 +187,15 @@ impl Debugger {}}gecko::flipper::dsp::refresh_interrupts(emulator);- emulator.scheduler.schedule_in(- cpu_cycles_per_dsp_tick(SYSTEM) * DSP_BATCH_SIZE,- dsp_batch_handler::<SYSTEM>,- );+ emulator+ .scheduler+ .schedule_in(cpu_cycles_per_dsp_tick(SYSTEM) * DSP_BATCH_SIZE, Handler::DspBatch);} else {- f(emulator);+ handler.resolve::<SYSTEM>()(emulator);}dsp_hit = true;} else {- f(emulator);+ handler.resolve::<SYSTEM>()(emulator);}}dsp_hitdiff --git a/crates/debugger/src/debugger.rs b/crates/debugger/src/debugger.rsindex b0bc834..7958e87 100644--- a/crates/debugger/src/debugger.rs+++ b/crates/debugger/src/debugger.rs@@ -38,6 +38,10 @@ pub struct DebuggerUi {pub fifo_last_result: String,pub fifo_action: Option<dbglib::windows::fifo::FifoRecorderAction>,pub freecam: dbglib::windows::gx::Freecam,+ pub savestate_path: std::path::PathBuf,+ pub save_state_requested: bool,+ pub load_state_requested: bool,+ pub savestate_last_result: String,}impl Default for DebuggerUi {@@ -72,6 +76,10 @@ impl Default for DebuggerUi {fifo_last_result: String::new(),fifo_action: None,freecam: Default::default(),+ savestate_path: gecko::savestate::state_path(None),+ save_state_requested: false,+ load_state_requested: false,+ savestate_last_result: String::new(),}}}diff --git a/crates/debugger/src/main.rs b/crates/debugger/src/main.rsindex e7cbdf3..b3d05f3 100644--- a/crates/debugger/src/main.rs+++ b/crates/debugger/src/main.rs@@ -271,6 +271,12 @@ impl ApplicationHandler<UserEvent> for App {_ => {}}}++ match key {+ KeyCode::F5 => self.ui.save_state_requested = true,+ KeyCode::F7 => self.ui.load_state_requested = true,+ _ => {}+ }}if !egui_consumed {@@ -409,6 +415,10 @@ struct Args {/// Force interpreter dispatch for CPU/DSP/Vertex (default: JIT)#[arg(long)]interpreter: bool,++ /// Load a savestate file right after boot+ #[arg(long)]+ load_state: Option<String>,}fn initial_window_size(target_aspect: TargetAspect) -> (u32, u32) {@@ -539,6 +549,7 @@ fn main() {let ui = DebuggerUi {symbols,+ savestate_path: gecko::savestate::state_path(game_id.as_deref()),..DebuggerUi::default()};@@ -549,6 +560,18 @@ fn main() {}}+ if let Some(ref path) = args.load_state {+ let path = std::path::Path::new(path);+ let result = match &mut emulator {+ EmulatorVariant::Gc(emu) => emu.load_state_from_file(path),+ EmulatorVariant::Wii(emu) => emu.load_state_from_file(path),+ };+ match result {+ Ok(()) => eprintln!("savestate loaded from {}", path.display()),+ Err(err) => eprintln!("failed to load savestate: {err}"),+ }+ }+let event_loop = EventLoop::<UserEvent>::with_user_event().build().unwrap();{diff --git a/crates/debugger/src/render.rs b/crates/debugger/src/render.rsindex f3f1ad9..5548d18 100644--- a/crates/debugger/src/render.rs+++ b/crates/debugger/src/render.rs@@ -188,6 +188,22 @@ impl RenderState {debugger_ui.debugger.set_state(EmulatorState::RunUntilDsp);ui.close();}++ ui.separator();++ if ui.button(format!("{} Save State (F5)", icons::FLOPPY_DISK)).clicked() {+ debugger_ui.save_state_requested = true;+ ui.close();+ }+ if ui.button(format!("{} Load State (F7)", icons::FOLDER_OPEN)).clicked() {+ debugger_ui.load_state_requested = true;+ ui.close();+ }++ if !debugger_ui.savestate_last_result.is_empty() {+ ui.separator();+ ui.label(debugger_ui.savestate_last_result.as_str());+ }});ui.menu_button("Windows", |ui| {@@ -378,13 +394,29 @@ impl RenderState {}}+ if std::mem::take(&mut debugger_ui.save_state_requested) {+ debugger_ui.savestate_last_result = match emulator.save_state_to_file(&debugger_ui.savestate_path) {+ Ok(()) => format!("state saved to {}", debugger_ui.savestate_path.display()),+ Err(err) => format!("state save failed: {err}"),+ };+ }++ if std::mem::take(&mut debugger_ui.load_state_requested) {+ debugger_ui.savestate_last_result = match emulator.load_state_from_file(&debugger_ui.savestate_path) {+ Ok(()) => format!("state loaded from {}", debugger_ui.savestate_path.display()),+ Err(err) => format!("state load failed: {err}"),+ };+ }+if std::mem::take(&mut debugger_ui.gx_invalidate_requested) {emulator.gx.texture_hashes.clear();emulator.render_sink.exec(gecko::host::GxAction::InvalidateCaches);}if let Some((matrix, enabled)) = debugger_ui.freecam.take_action() {- emulator.render_sink.exec(gecko::host::GxAction::SetFreelook { matrix, enabled });+ emulator+ .render_sink+ .exec(gecko::host::GxAction::SetFreelook { matrix, enabled });}#[cfg(not(target_arch = "wasm32"))]if std::mem::take(&mut debugger_ui.gx_dump_requested) {diff --git a/crates/gecko/Cargo.toml b/crates/gecko/Cargo.tomlindex 75e0f88..a32caf6 100644--- a/crates/gecko/Cargo.toml+++ b/crates/gecko/Cargo.toml@@ -47,6 +47,7 @@ rustc-hash = "2.1.2"smallvec = "1.15.1"crc32fast = "1.5.0"zerocopy = { version = "0.8.48", features = ["derive"] }+zstd = "0.13.3"cranelift-codegen = { version = "0.134.0", optional = true }cranelift-frontend = { version = "0.134.0", optional = true }cranelift-jit = { version = "0.134.0", optional = true }diff --git a/crates/gecko/src/dvd.rs b/crates/gecko/src/dvd.rsindex e6680f5..b85a72d 100644--- a/crates/gecko/src/dvd.rs+++ b/crates/gecko/src/dvd.rs@@ -127,19 +127,21 @@ pub fn start_transfer<const SYSTEM: SystemId>(sys: &mut System<SYSTEM>) {const DI_TRANSFER_DELAY_US: u64 = 20; // Based off of vxpm and hazel (~10k cycles at GC clock)sys.scheduler.schedule_in(crate::scheduler::microseconds_to_cycles(SYSTEM, DI_TRANSFER_DELAY_US),- |sys| {- sys.di.control.set_tstart(false);- // DMA length tracks the progress of the transfer, so when it hits 0, the- // transfer is complete. On failure, this would denote how many bytes were- // not transferred, but we close our eyes and just hope nothing depends on- // that!- sys.di.dma_length = regs::DiDmaLengthRegister::from_raw(0);- sys.di.status.set_transfer_complete(true);- self::refresh_interrupts(sys);- },+ crate::scheduler::Handler::DiTransferDone,);}+pub fn transfer_done_handler<const SYSTEM: SystemId>(sys: &mut System<SYSTEM>) {+ sys.di.control.set_tstart(false);+ // DMA length tracks the progress of the transfer, so when it hits 0, the+ // transfer is complete. On failure, this would denote how many bytes were+ // not transferred, but we close our eyes and just hope nothing depends on+ // that!+ sys.di.dma_length = regs::DiDmaLengthRegister::from_raw(0);+ sys.di.status.set_transfer_complete(true);+ self::refresh_interrupts(sys);+}+#[inline(always)]fn process_dvd_command<const SYSTEM: SystemId>(sys: &mut System<SYSTEM>, cmd: Command, dvd: &dyn image::Dvd) {match cmd {@@ -213,3 +215,35 @@ impl<const SYSTEM: SystemId> System<SYSTEM> {self::refresh_interrupts(self);}}++impl DvdInterface {+ pub fn save_state(&self, w: &mut crate::savestate::StateWriter) {+ w.pod(&self.status);+ w.pod(&self.cover);+ w.pod(&self.dma_address);+ w.pod(&self.dma_length);+ w.pod(&self.control);+ w.pod(&self.config);+ w.u32(self.cmdbuf0);+ w.u32(self.cmdbuf1);+ w.u32(self.cmdbuf2);+ w.u32(self.immbuf);+ }++ pub fn load_state(+ &mut self,+ r: &mut crate::savestate::StateReader<'_>,+ ) -> Result<(), crate::savestate::StateError> {+ self.status = r.pod()?;+ self.cover = r.pod()?;+ self.dma_address = r.pod()?;+ self.dma_length = r.pod()?;+ self.control = r.pod()?;+ self.config = r.pod()?;+ self.cmdbuf0 = r.u32()?;+ self.cmdbuf1 = r.u32()?;+ self.cmdbuf2 = r.u32()?;+ self.immbuf = r.u32()?;+ Ok(())+ }+}diff --git a/crates/gecko/src/flipper/ai.rs b/crates/gecko/src/flipper/ai.rsindex 213969b..4292ef2 100644--- a/crates/gecko/src/flipper/ai.rs+++ b/crates/gecko/src/flipper/ai.rs@@ -8,6 +8,7 @@ use crate::system::{System, SystemId};const AUDIO_DMA_BLOCK_BYTES: u32 = 32;const AUDIO_DMA_FRAMES_PER_BLOCK: u64 = 8;+#[derive(Clone, Copy)]pub struct AudioInterface {pub control: regs::AiControl,pub volume: regs::AiVolume,@@ -72,7 +73,7 @@ pub fn start_audio_dma<const SYSTEM: SystemId>(sys: &mut System<SYSTEM>) {return;}- sys.scheduler.cancel(self::audio_dma_block_handler);+ sys.scheduler.cancel(crate::scheduler::Handler::AiAudioDmaBlock);sys.ai.audio_dma_remaining_blocks = blocks;sys.ai.audio_dma_current_addr = sys.dsp.audio_dma_start_addr.raw();sys.dsp.csr.set_dma_status(true);@@ -82,13 +83,15 @@ pub fn start_audio_dma<const SYSTEM: SystemId>(sys: &mut System<SYSTEM>) {tracing::debug!(addr = format!("{addr:08X}"), len, "AID DMA started");- sys.scheduler- .schedule_in(cycles_per_audio_dma_block(sys), self::audio_dma_block_handler);+ sys.scheduler.schedule_in(+ cycles_per_audio_dma_block(sys),+ crate::scheduler::Handler::AiAudioDmaBlock,+ );}#[inline(always)]pub fn stop_audio_dma<const SYSTEM: SystemId>(sys: &mut System<SYSTEM>) {- sys.scheduler.cancel(self::audio_dma_block_handler);+ sys.scheduler.cancel(crate::scheduler::Handler::AiAudioDmaBlock);sys.ai.audio_dma_remaining_blocks = 0;sys.dsp.csr.set_dma_status(false);}@@ -141,8 +144,10 @@ pub fn audio_dma_block_handler<const SYSTEM: SystemId>(sys: &mut System<SYSTEM>)if sys.dsp.audio_dma_control.play() {sys.dsp.csr.set_dma_status(true);- sys.scheduler- .schedule_in(cycles_per_audio_dma_block(sys), self::audio_dma_block_handler);+ sys.scheduler.schedule_in(+ cycles_per_audio_dma_block(sys),+ crate::scheduler::Handler::AiAudioDmaBlock,+ );} else {stop_audio_dma(sys);}diff --git a/crates/gecko/src/flipper/cp.rs b/crates/gecko/src/flipper/cp.rsindex 279f7af..4fa4161 100644--- a/crates/gecko/src/flipper/cp.rs+++ b/crates/gecko/src/flipper/cp.rs@@ -8,6 +8,7 @@ pub const PUMP_INTERVAL_CYCLES: u64 = 1 << 16;const GP_PIPE_CAPACITY: usize = 64;+#[derive(Clone, Copy)]pub struct CommandProcessor {pub status: regs::CpStatus,pub control: regs::CpControl,@@ -262,7 +263,7 @@ pub fn gather_pipe_bursted<const SYSTEM: SystemId>(sys: &mut System<SYSTEM>) {pub fn pump_handler<const SYSTEM: SystemId>(sys: &mut System<SYSTEM>) {self::pump_fifo(sys);sys.scheduler- .schedule_in(PUMP_INTERVAL_CYCLES, self::pump_handler::<SYSTEM>);+ .schedule_in(PUMP_INTERVAL_CYCLES, crate::scheduler::Handler::CpPump);}pub fn pump_fifo<const SYSTEM: SystemId>(sys: &mut System<SYSTEM>) {diff --git a/crates/gecko/src/flipper/dsp.rs b/crates/gecko/src/flipper/dsp.rsindex 93997b5..ee873d9 100644--- a/crates/gecko/src/flipper/dsp.rs+++ b/crates/gecko/src/flipper/dsp.rs@@ -664,7 +664,7 @@ pub fn wake_dsp_scheduler<const SYSTEM: SystemId>(sys: &mut System<SYSTEM>) {sys.dsp.scheduler_suspended = false;sys.scheduler.schedule_in(crate::scheduler::dsp_batch_interval(SYSTEM),- crate::scheduler::dsp_batch_handler::<SYSTEM>,+ crate::scheduler::Handler::DspBatch,);#[cfg(feature = "jit-stats")]@@ -921,3 +921,89 @@ impl<const SYSTEM: SystemId> DspJitHandle for jit::JitEngine<SYSTEM> {tracing::warn!("feature `jit-stats` is not enabled. Rebuild with `--features jit-stats`.");}}++impl Dsp {+ pub fn save_state(&self, w: &mut crate::savestate::StateWriter) {+ w.pod(&self.registers);++ w.bytes(&*self.iram);+ w.bytes(&*self.irom);+ w.bytes(&*self.dram);+ w.bytes(&*self.coef);+ w.bytes(&*self.ifx);+ w.bytes(&*self.aram);++ w.pod(&self.csr);+ w.pod(&self.mailbox_to_dsp_hi);+ w.pod(&self.mailbox_to_dsp_lo);+ w.pod(&self.mailbox_to_cpu_hi);+ w.pod(&self.mailbox_to_cpu_lo);+ w.pod(&self.aram_info);+ w.pod(&self.aram_mode);+ w.pod(&self.aram_refresh);+ w.pod(&self.aram_dma_mmio_addr);+ w.pod(&self.aram_dma_aram_addr);+ w.pod(&self.aram_dma_control);+ w.pod(&self.audio_dma_start_addr);+ w.pod(&self.audio_dma_control);++ w.pod(&self.dma_control);+ w.u16(self.dma_length);+ w.u16(self.dma_dsp_addr);+ w.u16(self.dma_ram_addr_hi);+ w.u16(self.dma_ram_addr_lo);++ w.pod(&self.accelerator);+ w.bool(self.scheduler_suspended);+ }++ pub fn load_state(+ &mut self,+ r: &mut crate::savestate::StateReader<'_>,+ ) -> Result<(), crate::savestate::StateError> {+ self.registers = r.pod()?;++ r.bytes_into(&mut *self.iram)?;+ r.bytes_into(&mut *self.irom)?;+ r.bytes_into(&mut *self.dram)?;+ r.bytes_into(&mut *self.coef)?;+ r.bytes_into(&mut *self.ifx)?;+ r.bytes_into(&mut *self.aram)?;++ self.csr = r.pod()?;+ self.mailbox_to_dsp_hi = r.pod()?;+ self.mailbox_to_dsp_lo = r.pod()?;+ self.mailbox_to_cpu_hi = r.pod()?;+ self.mailbox_to_cpu_lo = r.pod()?;+ self.aram_info = r.pod()?;+ self.aram_mode = r.pod()?;+ self.aram_refresh = r.pod()?;+ self.aram_dma_mmio_addr = r.pod()?;+ self.aram_dma_aram_addr = r.pod()?;+ self.aram_dma_control = r.pod()?;+ self.audio_dma_start_addr = r.pod()?;+ self.audio_dma_control = r.pod()?;++ self.dma_control = r.pod()?;+ self.dma_length = r.u16()?;+ self.dma_dsp_addr = r.u16()?;+ self.dma_ram_addr_hi = r.u16()?;+ self.dma_ram_addr_lo = r.u16()?;++ self.accelerator = r.pod()?;+ self.scheduler_suspended = r.bool()?;++ self.rebuild_wait_table();++ #[cfg(feature = "jit")]+ {+ if let Some(jit) = self.jit.as_mut() {+ jit.flush();+ }+ self.chain_budget = 0;+ self.instr_count = 0;+ }++ Ok(())+ }+}diff --git a/crates/gecko/src/flipper/dsp/core.rs b/crates/gecko/src/flipper/dsp/core.rsindex 775511d..7a9b0c8 100644--- a/crates/gecko/src/flipper/dsp/core.rs+++ b/crates/gecko/src/flipper/dsp/core.rs@@ -39,6 +39,7 @@ pub mod reg {pub const AC1M: u8 = 31;}+#[derive(Clone, Copy)]pub struct Registers {pub pc: u16,pub nia: u16,diff --git a/crates/gecko/src/flipper/dsp/core/stack.rs b/crates/gecko/src/flipper/dsp/core/stack.rsindex c832522..be0f993 100644--- a/crates/gecko/src/flipper/dsp/core/stack.rs+++ b/crates/gecko/src/flipper/dsp/core/stack.rs@@ -1,3 +1,4 @@+#[derive(Clone, Copy)]pub struct DspStack<const N: usize> {data: [u16; N],ptr: u8,diff --git a/crates/gecko/src/flipper/dsp/regs.rs b/crates/gecko/src/flipper/dsp/regs.rsindex 661bff4..96e3b7c 100644--- a/crates/gecko/src/flipper/dsp/regs.rs+++ b/crates/gecko/src/flipper/dsp/regs.rs@@ -112,14 +112,12 @@ impl<const SYSTEM: SystemId> MmioAccess<System<SYSTEM>> for ControlStatus {match (was_active, now_active) {(false, true) => {sys.dsp.scheduler_suspended = false;- sys.scheduler.schedule_in(- scheduler::dsp_batch_interval(SYSTEM),- scheduler::dsp_batch_handler::<SYSTEM>,- );+ sys.scheduler+ .schedule_in(scheduler::dsp_batch_interval(SYSTEM), scheduler::Handler::DspBatch);}(true, false) => {sys.dsp.scheduler_suspended = false;- sys.scheduler.cancel(scheduler::dsp_batch_handler::<SYSTEM>);+ sys.scheduler.cancel(scheduler::Handler::DspBatch);}_ => {}}@@ -378,10 +376,12 @@ impl<const SYSTEM: SystemId> MmioAccess<System<SYSTEM>> for AramDmaControl {const ARAM_DMA_DELAY_US: u64 = 20;sys.scheduler.schedule_in(crate::scheduler::microseconds_to_cycles(SYSTEM, ARAM_DMA_DELAY_US),- |sys| {- sys.dsp.process_aram_dma(&mut sys.mmio);- dsp::refresh_interrupts(sys);- },+ scheduler::Handler::AramDma,);}}++pub fn aram_dma_handler<const SYSTEM: SystemId>(sys: &mut System<SYSTEM>) {+ sys.dsp.process_aram_dma(&mut sys.mmio);+ dsp::refresh_interrupts(sys);+}diff --git a/crates/gecko/src/flipper/exi.rs b/crates/gecko/src/flipper/exi.rsindex c4e29dc..e42a1d7 100644--- a/crates/gecko/src/flipper/exi.rs+++ b/crates/gecko/src/flipper/exi.rs@@ -6,6 +6,8 @@ pub mod regs;use crate::flipper::exi::regs::TransferType;use crate::system::{System, SystemId};+const DEVICE_STATE_CAPACITY: usize = 256;+pub struct ExternalInterface {// Channel 0pub ch0_csr: regs::Channel0Status,@@ -264,14 +266,14 @@ pub fn on_chip_select_written<const CHANNEL: usize, const SYSTEM: SystemId>(sys:&& let Some(delay) = sys.exi.devices[CHANNEL][slot].as_mut().and_then(|d| d.on_deselect()){sys.scheduler- .schedule_in(delay, self::memcard_cmd_done::<CHANNEL, SYSTEM>);+ .schedule_in(delay, crate::scheduler::Handler::memcard_cmd_done(CHANNEL));}}sys.exi.prev_cs[CHANNEL] = new_cs;}-fn memcard_cmd_done<const CHANNEL: usize, const SYSTEM: SystemId>(sys: &mut System<SYSTEM>) {+pub(crate) fn memcard_cmd_done<const CHANNEL: usize, const SYSTEM: SystemId>(sys: &mut System<SYSTEM>) {let raise = sys.exi.devices[CHANNEL][0].as_mut().is_some_and(|d| d.complete_command());@@ -371,3 +373,76 @@ pub fn run_dma<const CHANNEL: usize, const SYSTEM: SystemId>(sys: &mut System<SYsys.exi.finish_transfer::<CHANNEL>();}++impl ExternalInterface {+ pub fn save_state(&mut self, w: &mut crate::savestate::StateWriter) {+ w.pod(&self.ch0_csr);+ w.pod(&self.ch0_mar);+ w.pod(&self.ch0_length);+ w.pod(&self.ch0_cr);+ w.pod(&self.ch0_data);+ w.pod(&self.ch1_csr);+ w.pod(&self.ch1_mar);+ w.pod(&self.ch1_length);+ w.pod(&self.ch1_cr);+ w.pod(&self.ch1_data);+ w.pod(&self.ch2_csr);+ w.pod(&self.ch2_mar);+ w.pod(&self.ch2_length);+ w.pod(&self.ch2_cr);+ w.pod(&self.ch2_data);+ w.pod(&self.prev_cs);++ for device in self.devices.iter_mut().flatten() {+ match device {+ Some(device) => {+ w.bool(true);++ let mut inner = crate::savestate::StateWriter::with_capacity(DEVICE_STATE_CAPACITY);+ device.save_state(&mut inner);+ w.bytes(&inner.into_inner());+ }+ None => w.bool(false),+ }+ }+ }++ pub fn load_state(+ &mut self,+ r: &mut crate::savestate::StateReader<'_>,+ ) -> Result<(), crate::savestate::StateError> {+ self.ch0_csr = r.pod()?;+ self.ch0_mar = r.pod()?;+ self.ch0_length = r.pod()?;+ self.ch0_cr = r.pod()?;+ self.ch0_data = r.pod()?;+ self.ch1_csr = r.pod()?;+ self.ch1_mar = r.pod()?;+ self.ch1_length = r.pod()?;+ self.ch1_cr = r.pod()?;+ self.ch1_data = r.pod()?;+ self.ch2_csr = r.pod()?;+ self.ch2_mar = r.pod()?;+ self.ch2_length = r.pod()?;+ self.ch2_cr = r.pod()?;+ self.ch2_data = r.pod()?;+ self.prev_cs = r.pod()?;++ for device in self.devices.iter_mut().flatten() {+ let present = r.bool()?;+ if present != device.is_some() {+ return Err(crate::savestate::StateError::Corrupt(+ "EXI device topology mismatch (different boot configuration?)",+ ));+ }++ if let Some(device) = device {+ let payload = r.bytes()?;+ let mut inner = crate::savestate::StateReader::new(payload);+ device.load_state(&mut inner)?;+ }+ }++ Ok(())+ }+}diff --git a/crates/gecko/src/flipper/exi/device.rs b/crates/gecko/src/flipper/exi/device.rsindex 6513f1a..19f5ce0 100644--- a/crates/gecko/src/flipper/exi/device.rs+++ b/crates/gecko/src/flipper/exi/device.rs@@ -35,6 +35,12 @@ pub trait ExiDevice: Send {fn as_any_mut(&mut self) -> Option<&mut dyn std::any::Any> {None}++ fn save_state(&mut self, _w: &mut crate::savestate::StateWriter) {}++ fn load_state(&mut self, _r: &mut crate::savestate::StateReader<'_>) -> Result<(), crate::savestate::StateError> {+ Ok(())+ }}pub struct ExiDummy;diff --git a/crates/gecko/src/flipper/exi/macronix.rs b/crates/gecko/src/flipper/exi/macronix.rsindex cfe1e0b..70c479b 100644--- a/crates/gecko/src/flipper/exi/macronix.rs+++ b/crates/gecko/src/flipper/exi/macronix.rs@@ -216,6 +216,25 @@ impl super::device::ExiDevice for ExiMacronix {fn as_any_mut(&mut self) -> Option<&mut dyn std::any::Any> {Some(self)}++ fn save_state(&mut self, w: &mut crate::savestate::StateWriter) {+ w.pod(&self.sram.data);+ w.bool(self.sram_dirty);+ w.u32(self.command);+ w.u64(self.bytes_received as u64);+ w.u64(self.cursor as u64);+ }++ fn load_state(&mut self, r: &mut crate::savestate::StateReader<'_>) -> Result<(), crate::savestate::StateError> {+ self.sram.data = r.pod()?;+ self.sram_dirty = r.bool()?;+ self.command = r.u32()?;+ self.bytes_received = r.u64()? as usize;+ self.cursor = r.u64()? as usize;++ self.flush_sram();+ Ok(())+ }}#[derive(Debug, Clone)]diff --git a/crates/gecko/src/flipper/exi/memcard.rs b/crates/gecko/src/flipper/exi/memcard.rsindex 86b9e07..9c9f8fb 100644--- a/crates/gecko/src/flipper/exi/memcard.rs+++ b/crates/gecko/src/flipper/exi/memcard.rs@@ -42,6 +42,21 @@ impl Command {_ => Command::Unknown,}}++ fn to_byte(self) -> u8 {+ match self {+ Command::NintendoId => 0x00,+ Command::ReadArray => 0x52,+ Command::SetInterrupt => 0x81,+ Command::ReadStatus => 0x83,+ Command::ReadId => 0x85,+ Command::ClearStatus => 0x89,+ Command::SectorErase => 0xF1,+ Command::PageProgram => 0xF2,+ Command::ChipErase => 0xF4,+ Command::Unknown => 0xFF,+ }+ }}pub struct ExiMemoryCard {@@ -241,4 +256,29 @@ impl super::device::ExiDevice for ExiMemoryCard {}self.flush();}++ fn save_state(&mut self, w: &mut crate::savestate::StateWriter) {+ w.bytes(&self.data);+ w.u8(self.command.to_byte());+ w.u32(self.position);+ w.u32(self.address);+ w.u8(self.status);+ w.u8(self.interrupt_switch);+ w.pod(&self.program_buffer);+ }++ fn load_state(&mut self, r: &mut crate::savestate::StateReader<'_>) -> Result<(), crate::savestate::StateError> {+ r.bytes_into(&mut self.data)?;++ self.command = Command::from_byte(r.u8()?);++ self.position = r.u32()?;+ self.address = r.u32()?;+ self.status = r.u8()?;+ self.interrupt_switch = r.u8()?;+ self.program_buffer = r.pod()?;++ self.flush();+ Ok(())+ }}diff --git a/crates/gecko/src/flipper/gx.rs b/crates/gecko/src/flipper/gx.rsindex 8c2e1b3..b042a4c 100644--- a/crates/gecko/src/flipper/gx.rs+++ b/crates/gecko/src/flipper/gx.rs@@ -513,3 +513,157 @@ impl<const SYSTEM: SystemId> System<SYSTEM> {crate::flipper::pe::refresh_interrupts(self);}}++impl GraphicsProcessor {+ pub fn save_state(&self, w: &mut crate::savestate::StateWriter) {+ w.bool(self.raise_interrupt);+ w.bool(self.raise_token_interrupt);+ w.u16(self.pending_token);+ w.bool(self.token_dirty);+ w.pod(&self.projection);+ w.u32(self.bp_mask);++ 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));+ w.bytes(&self.fifo);++ w.pod(&self.cur_textures);+ w.pod(&self.cur_tluts);+ w.pod(&self.cur_tev_color_env);+ w.pod(&self.cur_tev_alpha_env);+ w.pod(&self.cur_tev_color_regs_lo);+ w.pod(&self.cur_tev_color_regs_hi);+ w.pod(&self.cur_tev_const_regs_lo);+ w.pod(&self.cur_tev_const_regs_hi);+ w.pod(&self.cur_tev_orders);+ w.u8(self.cur_num_tev_stages);+ w.pod(&self.cur_tev_konst_colors);+ w.pod(&self.cur_indirect_matrices);+ w.pod(&self.cur_indirect_scales);+ w.pod(&self.cur_indirect_refs);+ w.pod(&self.cur_tev_indirect);+ w.u8(self.cur_num_indirect_stages);+ w.u32(self.cur_bump_imask);+ w.pod(&self.cur_zmode);+ w.pod(&self.cur_pe_control);+ w.pod(&self.cur_blend_mode);+ w.pod(&self.cur_alpha_compare);+ w.pod(&self.cur_viewport);+ w.pod(&self.cur_scissor);+ w.i32(self.cur_scissor_offset_x);+ w.i32(self.cur_scissor_offset_y);++ w.u32(self.xfb_regions.len() as u32);+ for (&base, region) in &self.xfb_regions {+ w.u32(base);+ w.u32(region.stride);+ w.u64(region.first_seq);+ w.u64(region.copy_seq);+ w.u64(region.seen_present_seq);+ }++ w.bool(self.xfb_dirty);+ w.u64(self.xfb_copy_seq);+ w.u64(self.xfb_present_seq);+ w.u32(self.xfb_last_present_base);+ w.u32(self.xfb_last_seen_base);+ w.u32(self.xfb_prev_base);+ w.u32(self.xfb_fields_since_flip);+ w.u32(self.xfb_flip_interval);+ w.u32(self.xfb_fields_since_emit);+ w.u64(self.xfb_last_emit_gen);++ w.pod(&self.cached_color_ctrl);+ w.pod(&self.cached_alpha_ctrl);+ w.pod(&self.cached_ambient_color);+ w.pod(&self.cached_material_color);+ w.pod(&self.cached_lights);+ }++ pub fn load_state(+ &mut self,+ r: &mut crate::savestate::StateReader<'_>,+ ) -> Result<(), crate::savestate::StateError> {+ self.raise_interrupt = r.bool()?;+ self.raise_token_interrupt = r.bool()?;+ self.pending_token = r.u16()?;+ self.token_dirty = r.bool()?;+ self.projection = r.pod()?;+ self.bp_mask = r.u32()?;++ 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))?;++ self.fifo.clear();+ self.fifo.extend_from_slice(r.bytes()?);++ self.cur_textures = r.pod()?;+ self.cur_tluts = r.pod()?;+ self.cur_tev_color_env = r.pod()?;+ self.cur_tev_alpha_env = r.pod()?;+ self.cur_tev_color_regs_lo = r.pod()?;+ self.cur_tev_color_regs_hi = r.pod()?;+ self.cur_tev_const_regs_lo = r.pod()?;+ self.cur_tev_const_regs_hi = r.pod()?;+ self.cur_tev_orders = r.pod()?;+ self.cur_num_tev_stages = r.u8()?;+ self.cur_tev_konst_colors = r.pod()?;+ self.cur_indirect_matrices = r.pod()?;+ self.cur_indirect_scales = r.pod()?;+ self.cur_indirect_refs = r.pod()?;+ self.cur_tev_indirect = r.pod()?;+ self.cur_num_indirect_stages = r.u8()?;+ self.cur_bump_imask = r.u32()?;+ self.cur_zmode = r.pod()?;+ self.cur_pe_control = r.pod()?;+ self.cur_blend_mode = r.pod()?;+ self.cur_alpha_compare = r.pod()?;+ self.cur_viewport = r.pod()?;+ self.cur_scissor = r.pod()?;+ self.cur_scissor_offset_x = r.i32()?;+ self.cur_scissor_offset_y = r.i32()?;++ self.xfb_regions.clear();+ let region_count = r.u32()?;+ for _ in 0..region_count {+ let base = r.u32()?;+ let region = XfbRegion {+ stride: r.u32()?,+ first_seq: r.u64()?,+ copy_seq: r.u64()?,+ seen_present_seq: r.u64()?,+ };+ self.xfb_regions.insert(base, region);+ }++ self.xfb_dirty = r.bool()?;+ self.xfb_copy_seq = r.u64()?;+ self.xfb_present_seq = r.u64()?;+ self.xfb_last_present_base = r.u32()?;+ self.xfb_last_seen_base = r.u32()?;+ self.xfb_prev_base = r.u32()?;+ self.xfb_fields_since_flip = r.u32()?;+ self.xfb_flip_interval = r.u32()?;+ self.xfb_fields_since_emit = r.u32()?;+ self.xfb_last_emit_gen = r.u64()?;++ self.cached_color_ctrl = r.pod()?;+ self.cached_alpha_ctrl = r.pod()?;+ self.cached_ambient_color = r.pod()?;+ self.cached_material_color = r.pod()?;+ self.cached_lights = r.pod()?;++ self.dl_scratch.clear();+ self.texture_hashes.clear();+ self.tex_dirty = 0xFF;+ self.lighting_dirty = true;+ self.konst_dirty = true;+ self.frame_state_dirty = true;++ Ok(())+ }+}diff --git a/crates/gecko/src/flipper/gx/bp.rs b/crates/gecko/src/flipper/gx/bp.rsindex 207e87c..97622d1 100644--- a/crates/gecko/src/flipper/gx/bp.rs+++ b/crates/gecko/src/flipper/gx/bp.rs@@ -25,6 +25,14 @@ impl GraphicsProcessor {self.stats.bp_writes += 1;}+ 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+ );+ if val == old && !command_write {+ return;+ }+tracing::debug!(reg_idx = format!("{idx:02X}"),value = format!("{val:08X}"),diff --git a/crates/gecko/src/flipper/gx/vertex.rs b/crates/gecko/src/flipper/gx/vertex.rsindex c1272ad..049a802 100644--- a/crates/gecko/src/flipper/gx/vertex.rs+++ b/crates/gecko/src/flipper/gx/vertex.rs@@ -2,7 +2,7 @@ use super::constants::*;use super::math::{Vec3, unpack_rgba};use super::regs::{self, *};use super::{GraphicsProcessor, draw};-use crate::host::{DrawData, DrawVertex, GxAction, RenderSink};+use crate::host::{DrawData, DrawState, DrawVertex, GxAction, RenderSink};use crate::mmio::{Mmio, RamView};use crate::system::{ExecutionMode, SystemId};use std::io::{Cursor, Read};@@ -108,82 +108,76 @@ impl GraphicsProcessor {verts.reserve(vertex_count);self::dispatch_decode(self, mmio, cmd, data, vertex_count, &vf, verts);- let modelview = self.build_modelview_matrix(vf.default_pos_mtx_idx);-- let tev_color_regs = self.resolve_tev_color_regs();- let tev_orders = self.resolve_tev_orders();-- self.rebuild_lighting_cache_if_dirty();-- if self.konst_dirty {- self.resolve_konst_colors();- self.konst_dirty = false;- }-+ boxed.primitive = primitive;boxed.base_vertex = base_vertex;boxed.vertex_count = vertex_count as u32;+ boxed.state = self.frame_state_dirty.then(|| {+ let tev_color_regs = self.resolve_tev_color_regs();+ let tev_orders = self.resolve_tev_orders();- // Flatten the three indirect matrices to 6 rows. Row 2M is row- // 0 of matrix M, row 2M+1 is row 1. The .w lane carries the- // shared scale exponent (positive means right-shift, negative- // means left-shift of the mat-mul result).- let mut indirect_matrices = [[0i32; 4]; 6];- for m in 0..3 {- let mtx = &self.cur_indirect_matrices[m];- let exp = mtx.scale_exponent();- let r0 = mtx.row0();- let r1 = mtx.row1();- indirect_matrices[2 * m] = [r0[0], r0[1], r0[2], exp];- indirect_matrices[2 * m + 1] = [r1[0], r1[1], r1[2], exp];- }+ self.rebuild_lighting_cache_if_dirty();- let indirect_scales = [- [- self.cur_indirect_scales[0].ss0() as u32,- self.cur_indirect_scales[0].ts0() as u32,- self.cur_indirect_scales[0].ss1() as u32,- self.cur_indirect_scales[0].ts1() as u32,- ],- [- self.cur_indirect_scales[1].ss0() as u32,- self.cur_indirect_scales[1].ts0() as u32,- self.cur_indirect_scales[1].ss1() as u32,- self.cur_indirect_scales[1].ts1() as u32,- ],- ];+ if self.konst_dirty {+ self.resolve_konst_colors();+ self.konst_dirty = false;+ }- boxed.primitive = primitive;- boxed.modelview = modelview.0;- boxed.tev_color_env = std::array::from_fn(|i| self.cur_tev_color_env[i].raw());- boxed.tev_alpha_env = std::array::from_fn(|i| self.cur_tev_alpha_env[i].raw());- boxed.tev_orders = std::array::from_fn(|i| tev_orders[i].raw());- boxed.tev_ksel = std::array::from_fn(|i| self.bp_regs[BP_TEV_KSEL_0 + i]);- boxed.tev_color_regs = tev_color_regs;- boxed.tev_konst_colors = self.cur_tev_konst_colors;- boxed.num_tev_stages = self.cur_num_tev_stages;- boxed.indirect_matrices = indirect_matrices;- boxed.indirect_scales = indirect_scales;- boxed.indirect_refs = self.cur_indirect_refs.raw();- boxed.num_indirect_stages = self.cur_num_indirect_stages;- boxed.bump_imask = self.cur_bump_imask;- boxed.tev_indirect = std::array::from_fn(|i| self.cur_tev_indirect[i].raw());- boxed.color_ctrl = self.cached_color_ctrl;- boxed.alpha_ctrl = self.cached_alpha_ctrl;- boxed.ambient_color = self.cached_ambient_color;- boxed.material_color = self.cached_material_color;- boxed.lights = self.cached_lights;- boxed.active_texcoords = (self.xf_mem[crate::flipper::gx::constants::XF_NUM_TEXGENS] as u8).min(8);- // Z texture: only applied by hardware on the late-Z path; collapse to- // disabled under early-Z so the backend can keep early-Z pipelines.- let ztex2 = TevZtex2::from_raw(self.bp_regs[BP_TEV_ZTEX2]);- boxed.ztex_bias = TevZtex1::from_raw(self.bp_regs[BP_TEV_ZTEX1]).bias();- boxed.ztex_type = ztex2.tex_type();- boxed.ztex_op = if self.cur_pe_control.early_ztest() {- 0- } else {- ztex2.op()- };- boxed.frame_dirty = self.frame_state_dirty;+ let mut indirect_matrices = [[0i32; 4]; 6];+ for (m, rows) in indirect_matrices.chunks_exact_mut(2).enumerate() {+ let mtx = &self.cur_indirect_matrices[m];+ let exp = mtx.scale_exponent();+ let r0 = mtx.row0();+ let r1 = mtx.row1();+ rows[0] = [r0[0], r0[1], r0[2], exp];+ rows[1] = [r1[0], r1[1], r1[2], exp];+ }++ let indirect_scales = [+ [+ self.cur_indirect_scales[0].ss0() as u32,+ self.cur_indirect_scales[0].ts0() as u32,+ self.cur_indirect_scales[0].ss1() as u32,+ self.cur_indirect_scales[0].ts1() as u32,+ ],+ [+ self.cur_indirect_scales[1].ss0() as u32,+ self.cur_indirect_scales[1].ts0() as u32,+ self.cur_indirect_scales[1].ss1() as u32,+ self.cur_indirect_scales[1].ts1() as u32,+ ],+ ];++ let ztex2 = TevZtex2::from_raw(self.bp_regs[BP_TEV_ZTEX2]);++ DrawState {+ tev_color_env: std::array::from_fn(|i| self.cur_tev_color_env[i].raw()),+ tev_alpha_env: std::array::from_fn(|i| self.cur_tev_alpha_env[i].raw()),+ tev_orders: std::array::from_fn(|i| tev_orders[i].raw()),+ tev_ksel: std::array::from_fn(|i| self.bp_regs[BP_TEV_KSEL_0 + i]),+ tev_color_regs,+ tev_konst_colors: self.cur_tev_konst_colors,+ num_tev_stages: self.cur_num_tev_stages,+ indirect_matrices,+ indirect_scales,+ indirect_refs: self.cur_indirect_refs.raw(),+ num_indirect_stages: self.cur_num_indirect_stages,+ bump_imask: self.cur_bump_imask,+ tev_indirect: std::array::from_fn(|i| self.cur_tev_indirect[i].raw()),+ color_ctrl: self.cached_color_ctrl,+ alpha_ctrl: self.cached_alpha_ctrl,+ ambient_color: self.cached_ambient_color,+ material_color: self.cached_material_color,+ lights: self.cached_lights,+ active_texcoords: (self.xf_mem[crate::flipper::gx::constants::XF_NUM_TEXGENS] as u8).min(8),+ ztex_bias: TevZtex1::from_raw(self.bp_regs[BP_TEV_ZTEX1]).bias(),+ ztex_type: ztex2.tex_type(),+ ztex_op: if self.cur_pe_control.early_ztest() {+ 0+ } else {+ ztex2.op()+ },+ }+ });self.frame_state_dirty = false;renderer.exec(GxAction::Draw(boxed));@@ -507,36 +501,6 @@ impl GraphicsProcessor {}}- fn build_modelview_matrix(&self, pos_mtx_idx: u8) -> draw::Matrix4 {- let default_mtx_base = pos_mtx_idx as usize * XF_POS_MTX_STRIDE;- draw::Matrix4([- [- f32::from_bits(self.xf_mem[default_mtx_base]),- f32::from_bits(self.xf_mem[default_mtx_base + 4]),- f32::from_bits(self.xf_mem[default_mtx_base + 8]),- 0.0,- ],- [- f32::from_bits(self.xf_mem[default_mtx_base + 1]),- f32::from_bits(self.xf_mem[default_mtx_base + 5]),- f32::from_bits(self.xf_mem[default_mtx_base + 9]),- 0.0,- ],- [- f32::from_bits(self.xf_mem[default_mtx_base + 2]),- f32::from_bits(self.xf_mem[default_mtx_base + 6]),- f32::from_bits(self.xf_mem[default_mtx_base + 10]),- 0.0,- ],- [- f32::from_bits(self.xf_mem[default_mtx_base + 3]),- f32::from_bits(self.xf_mem[default_mtx_base + 7]),- f32::from_bits(self.xf_mem[default_mtx_base + 11]),- 1.0,- ],- ])- }-fn rebuild_lighting_cache_if_dirty(&mut self) {if !self.lighting_dirty {return;diff --git a/crates/gecko/src/flipper/gx/xf.rs b/crates/gecko/src/flipper/gx/xf.rsindex ff5840d..4f679ca 100644--- a/crates/gecko/src/flipper/gx/xf.rs+++ b/crates/gecko/src/flipper/gx/xf.rs@@ -13,7 +13,66 @@ fn ranges_overlap(a_begin: usize, a_end: usize, b_begin: usize, b_end: usize) ->a_begin < b_end && b_begin < a_end}+#[derive(Clone, Copy, Default)]+struct XfDirty {+ projection: bool,+ viewport: bool,+ lighting: bool,+}+impl GraphicsProcessor {+ fn store_xf_regs(&mut self, base: usize, values: impl ExactSizeIterator<Item = u32>) -> XfDirty {+ let end = base + values.len();++ let tracked = self::ranges_overlap(base, end, XF_PROJECTION_BASE, XF_PROJECTION_END + 1)+ || self::ranges_overlap(base, end, XF_VIEWPORT_BASE, XF_VIEWPORT_END + 1)+ || self::ranges_overlap(base, end, XF_LIGHT_BASE, XF_LIGHT_END)+ || self::ranges_overlap(base, end, XF_CHAN_CFG_BEGIN, XF_CHAN_CFG_END);++ let mut dirty = XfDirty::default();++ for (i, val) in values.enumerate() {+ let reg = base + i;+ if reg < self.xf_mem.len() {+ if tracked && self.xf_mem[reg] != val {+ dirty.projection |= (XF_PROJECTION_BASE..=XF_PROJECTION_END).contains(®);+ dirty.viewport |= (XF_VIEWPORT_BASE..=XF_VIEWPORT_END).contains(®);+ dirty.lighting |= (XF_LIGHT_BASE..XF_LIGHT_END).contains(®)+ || (XF_CHAN_CFG_BEGIN..XF_CHAN_CFG_END).contains(®);+ }+ self.xf_mem[reg] = val;+ }++ tracing::debug!(+ reg_idx = format!("{reg:04X}"),+ value = format!("{val:08X}"),+ "XF register write"+ );+ }++ dirty+ }++ fn apply_xf_dirty(&mut self, renderer: &mut dyn RenderSink, dirty: XfDirty) {+ if dirty.projection {+ self.rebuild_projection();+ renderer.exec(GxAction::SetProjection {+ matrix: self.projection.0,+ is_perspective: self.xf_mem[XF_PROJECTION_END] == 0,+ });+ }++ if dirty.viewport {+ self.rebuild_viewport();+ renderer.exec(GxAction::SetViewport(self.cur_viewport));+ }++ if dirty.lighting {+ self.lighting_dirty = true;+ self.frame_state_dirty = true;+ }+ }+#[inline(always)]pub fn xf_transform_3x4(&self, base: usize, v: [f32; 3]) -> Vec3 {let m: [f32; 12] = std::array::from_fn(|i| f32::from_bits(self.xf_mem[base + i]));@@ -104,49 +163,19 @@ impl GraphicsProcessor {let length = u16::from_be_bytes([data[0], data[1]]) as usize;let addr = u16::from_be_bytes([data[2], data[3]]) as usize;let n = length + 1;- let end = addr + n;#[cfg(feature = "gx-stats")]{self.stats.xf_writes += n as u64;}- for i in 0..n {- let offset = 4 + i * 4;- let val = u32::from_be_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]]);- let reg = addr + i;- if reg < self.xf_mem.len() {- self.xf_mem[reg] = val;- }-- tracing::debug!(- reg_idx = format!("{reg:04X}"),- value = format!("{val:08X}"),- "XF register write"- );- }-- // Rebuild projection if the write touched its address range- if addr <= XF_PROJECTION_END && end > XF_PROJECTION_BASE {- self.rebuild_projection();- renderer.exec(GxAction::SetProjection {- matrix: self.projection.0,- is_perspective: self.xf_mem[XF_PROJECTION_END] == 0,- });- }+ let values = data[4..4 + n * 4]+ .chunks_exact(4)+ .map(|c| u32::from_be_bytes([c[0], c[1], c[2], c[3]]));- // Rebuild viewport if the write touched its address range- if addr <= XF_VIEWPORT_END && end > XF_VIEWPORT_BASE {- self.rebuild_viewport();- renderer.exec(GxAction::SetViewport(self.cur_viewport));- }+ let dirty = self.store_xf_regs(addr, values);- if self::ranges_overlap(addr, end, XF_LIGHT_BASE, XF_LIGHT_END)- || self::ranges_overlap(addr, end, XF_CHAN_CFG_BEGIN, XF_CHAN_CFG_END)- {- self.lighting_dirty = true;- self.frame_state_dirty = true;- }+ self.apply_xf_dirty(renderer, dirty);}#[inline(always)]@@ -166,7 +195,6 @@ impl GraphicsProcessor {let src_addr = base + (index as usize) * stride;let dst_addr = xf_addr as usize;let n = xf_count as usize;- let end = dst_addr + n;let Some(src) = ram.slice(src_addr, n * 4) else {tracing::warn!(@@ -181,33 +209,12 @@ impl GraphicsProcessor {rec.use_memory(ram, src_addr as u32, n * 4, super::recorder::MemoryUpdateType::XfData);}- for i in 0..n {- let off = i * 4;- let val = u32::from_be_bytes([src[off], src[off + 1], src[off + 2], src[off + 3]]);- let reg = dst_addr + i;- if reg < self.xf_mem.len() {- self.xf_mem[reg] = val;- }- }+ let values = src+ .chunks_exact(4)+ .map(|c| u32::from_be_bytes([c[0], c[1], c[2], c[3]]));- if dst_addr <= XF_PROJECTION_END && end > XF_PROJECTION_BASE {- self.rebuild_projection();- renderer.exec(GxAction::SetProjection {- matrix: self.projection.0,- is_perspective: self.xf_mem[XF_PROJECTION_END] == 0,- });- }-- if dst_addr <= XF_VIEWPORT_END && end > XF_VIEWPORT_BASE {- self.rebuild_viewport();- renderer.exec(GxAction::SetViewport(self.cur_viewport));- }+ let dirty = self.store_xf_regs(dst_addr, values);- if self::ranges_overlap(dst_addr, end, XF_LIGHT_BASE, XF_LIGHT_END)- || self::ranges_overlap(dst_addr, end, XF_CHAN_CFG_BEGIN, XF_CHAN_CFG_END)- {- self.lighting_dirty = true;- self.frame_state_dirty = true;- }+ self.apply_xf_dirty(renderer, dirty);}}diff --git a/crates/gecko/src/flipper/mi.rs b/crates/gecko/src/flipper/mi.rsindex 741e25d..28e4ff7 100644--- a/crates/gecko/src/flipper/mi.rs+++ b/crates/gecko/src/flipper/mi.rs@@ -1,5 +1,6 @@pub mod regs;+#[derive(Clone, Copy)]pub struct MemoryInterface {pub interrupt_mask: regs::MiInterruptMask,}diff --git a/crates/gecko/src/flipper/pe.rs b/crates/gecko/src/flipper/pe.rsindex 6cbe82a..cb869ca 100644--- a/crates/gecko/src/flipper/pe.rs+++ b/crates/gecko/src/flipper/pe.rs@@ -3,6 +3,7 @@ pub mod regs;use crate::flipper::pi::InterruptFlag;use crate::system::{System, SystemId};+#[derive(Clone, Copy)]pub struct PixelEngine {pub zconf: regs::ZConfig,pub alphaconf: regs::AlphaConfig,diff --git a/crates/gecko/src/flipper/pi.rs b/crates/gecko/src/flipper/pi.rsindex 044aa10..7c70ab1 100644--- a/crates/gecko/src/flipper/pi.rs+++ b/crates/gecko/src/flipper/pi.rs@@ -1,5 +1,6 @@pub mod regs;+#[derive(Clone, Copy)]pub struct ProcessorInterface {pub intsr: regs::InterruptCause,pub intmr: regs::InterruptMask,diff --git a/crates/gecko/src/flipper/si.rs b/crates/gecko/src/flipper/si.rsindex 876c6ff..8461066 100644--- a/crates/gecko/src/flipper/si.rs+++ b/crates/gecko/src/flipper/si.rs@@ -24,6 +24,7 @@ impl Default for SerialChannel {}}+#[derive(Clone, Copy)]pub struct SerialInterface {pub channels: [SerialChannel; NUM_CHANNELS],pub poll: regs::SiPoll,diff --git a/crates/gecko/src/flipper/vi.rs b/crates/gecko/src/flipper/vi.rsindex 84f5ded..ff2678c 100644--- a/crates/gecko/src/flipper/vi.rs+++ b/crates/gecko/src/flipper/vi.rs@@ -5,6 +5,7 @@ use crate::system::{System, SystemId};const CLOCK_FREQUENCIES: [u64; 2] = [27_000_000, 54_000_000];+#[derive(Clone, Copy)]pub struct VideoInterface {pub vtr: regs::VerticalTiming,pub htr0: regs::HorizontalTiming0,@@ -289,34 +290,37 @@ pub fn ensure_half_line_scheduled<const SYSTEM: SystemId>(sys: &mut System<SYSTElet ticks_per_hl = sys.vi.ticks_per_half_line(SYSTEM);if ticks_per_hl > 0 {sys.vi.half_line_scheduled = true;- sys.scheduler.schedule_in(ticks_per_hl, |sys| {- let prev_hl = sys.vi.half_line_count;- sys.vi.on_half_line(sys.scheduler.cycles);- sys.vi.half_line_scheduled = false;-- let curr_hl = sys.vi.half_line_count;- if curr_hl != prev_hl {- let (odd_av_start, odd_av_end) = sys.vi.odd_field_active_half_lines();- let (even_av_start, even_av_end) = sys.vi.even_field_active_half_lines();-- if curr_hl == odd_av_start || curr_hl == even_av_start {- sys.vi.latched_xfb_base = sys.vi.xfb_addr();- sys.vi.latched_even_field = sys.vi.in_even_field();- }+ sys.scheduler+ .schedule_in(ticks_per_hl, crate::scheduler::Handler::ViHalfLine);+ }+ }+}- // Present at the end of active video so copies made while- // the field is scanning out are included (Another Code: R- // copies its split XFB halves mid-frame).- if curr_hl == odd_av_end || curr_hl == even_av_end {- crate::flipper::gx::present_xfb(sys);- }- }+pub fn half_line_handler<const SYSTEM: SystemId>(sys: &mut System<SYSTEM>) {+ let prev_hl = sys.vi.half_line_count;+ sys.vi.on_half_line(sys.scheduler.cycles);+ sys.vi.half_line_scheduled = false;++ let curr_hl = sys.vi.half_line_count;+ if curr_hl != prev_hl {+ let (odd_av_start, odd_av_end) = sys.vi.odd_field_active_half_lines();+ let (even_av_start, even_av_end) = sys.vi.even_field_active_half_lines();- self::ensure_half_line_scheduled(sys);- self::refresh_interrupts(sys);- });+ if curr_hl == odd_av_start || curr_hl == even_av_start {+ sys.vi.latched_xfb_base = sys.vi.xfb_addr();+ sys.vi.latched_even_field = sys.vi.in_even_field();+ }++ // Present at the end of active video so copies made while+ // the field is scanning out are included (Another Code: R+ // copies its split XFB halves mid-frame).+ if curr_hl == odd_av_end || curr_hl == even_av_end {+ crate::flipper::gx::present_xfb(sys);}}++ self::ensure_half_line_scheduled(sys);+ self::refresh_interrupts(sys);}#[inline(always)]diff --git a/crates/gecko/src/fps.rs b/crates/gecko/src/fps.rsindex 75b14b0..fedb149 100644--- a/crates/gecko/src/fps.rs+++ b/crates/gecko/src/fps.rs@@ -93,5 +93,5 @@ pub fn fps_handler<const SYSTEM: SystemId>(sys: &mut System<SYSTEM>) {sys.fps_counter.vsync_count = 0;sys.fps_counter.last_tick = now;sys.scheduler- .schedule_in(cpu_clock(SYSTEM), self::fps_handler::<SYSTEM>);+ .schedule_in(cpu_clock(SYSTEM), crate::scheduler::Handler::Fps);}diff --git a/crates/gecko/src/gekko.rs b/crates/gecko/src/gekko.rsindex 797a015..1593119 100644--- a/crates/gecko/src/gekko.rs+++ b/crates/gecko/src/gekko.rs@@ -27,8 +27,10 @@ pub mod lut_wii {pub const IPL_RESET_VECTOR: u32 = 0xFFF0_0100;#[repr(C, align(16))]+#[derive(Clone, Copy)]pub struct FprFile(pub [[f64; 2]; 32]);+#[derive(Clone, Copy)]pub struct Gekko {pub gprs: [u32; 32],pub fprs: FprFile,diff --git a/crates/gecko/src/gekko/dec.rs b/crates/gecko/src/gekko/dec.rsindex 26e5db3..efec2b5 100644--- a/crates/gecko/src/gekko/dec.rs+++ b/crates/gecko/src/gekko/dec.rs@@ -3,6 +3,7 @@ use crate::system::{System, SystemId};const DEC_INTERRUPT_BIT: u32 = 0x8000_0000;+#[derive(Clone, Copy)]pub struct Decrementer {start_cycle: u64,start_value: u32,@@ -57,8 +58,10 @@ pub fn cycles_until_underflow(value: u32) -> u64 {pub fn underflow_handler<const SYSTEM: SystemId>(sys: &mut System<SYSTEM>) {sys.gekko.dec.underflow(sys.scheduler.cycles);sys.gekko.spr.dec = u32::MAX;- sys.scheduler- .schedule_in(cycles_until_underflow(u32::MAX), self::underflow_handler);+ sys.scheduler.schedule_in(+ cycles_until_underflow(u32::MAX),+ crate::scheduler::Handler::DecUnderflow,+ );tracing::debug!(cycles = sys.scheduler.cycles,ee = sys.gekko.msr.external_interrupt_enable(),diff --git a/crates/gecko/src/gekko/interpreter/system.rs b/crates/gecko/src/gekko/interpreter/system.rsindex 64963c4..7a2ae9a 100644--- a/crates/gecko/src/gekko/interpreter/system.rs+++ b/crates/gecko/src/gekko/interpreter/system.rs@@ -32,12 +32,12 @@ pub fn spr<const OP: u32, const SYSTEM: SystemId>(ctx: &mut System<SYSTEM>, instlet val = ctx.gekko.read_gpr(instr.rs());match spr_num {22 => {- ctx.scheduler.cancel(crate::gekko::dec::underflow_handler::<SYSTEM>);+ ctx.scheduler.cancel(crate::scheduler::Handler::DecUnderflow);ctx.gekko.dec.write(ctx.scheduler.cycles, val);ctx.gekko.spr.dec = val;ctx.scheduler.schedule_in(crate::gekko::dec::cycles_until_underflow(val),- crate::gekko::dec::underflow_handler::<SYSTEM>,+ crate::scheduler::Handler::DecUnderflow,);tracing::debug!(cycles = ctx.scheduler.cycles, value = val, "decrementer set");}diff --git a/crates/gecko/src/gekko/jit/runtime.rs b/crates/gecko/src/gekko/jit/runtime.rsindex e5fdd80..94d92d8 100644--- a/crates/gecko/src/gekko/jit/runtime.rs+++ b/crates/gecko/src/gekko/jit/runtime.rs@@ -194,12 +194,12 @@ fn write_spr<const SYSTEM: SystemId>(sys: *mut System<SYSTEM>, num: u32, val: u3let sys = unsafe { &mut *sys };match num {22 => {- sys.scheduler.cancel(crate::gekko::dec::underflow_handler::<SYSTEM>);+ sys.scheduler.cancel(crate::scheduler::Handler::DecUnderflow);sys.gekko.dec.write(sys.scheduler.cycles, val);sys.gekko.spr.dec = val;sys.scheduler.schedule_in(crate::gekko::dec::cycles_until_underflow(val),- crate::gekko::dec::underflow_handler::<SYSTEM>,+ crate::scheduler::Handler::DecUnderflow,);}284 => sys.scheduler.set_timebase_lower(val),diff --git a/crates/gecko/src/gekko/spr.rs b/crates/gecko/src/gekko/spr.rsindex 19a022e..6ce678d 100644--- a/crates/gecko/src/gekko/spr.rs+++ b/crates/gecko/src/gekko/spr.rs@@ -44,7 +44,7 @@ pub struct Xer {pub byte_count: u8,}-#[derive(Default)]+#[derive(Clone, Copy, Default)]pub struct Spr {pub xer: Xer,pub lr: u32,diff --git a/crates/gecko/src/hollywood.rs b/crates/gecko/src/hollywood.rsindex 5d9c48b..393a79e 100644--- a/crates/gecko/src/hollywood.rs+++ b/crates/gecko/src/hollywood.rs@@ -4,6 +4,7 @@ pub mod ipc;pub mod irq;pub mod regs;+#[derive(Clone, Copy)]pub struct Hollywood {pub compat: compat::Compat,pub gpio: gpio::Gpio,diff --git a/crates/gecko/src/hollywood/compat.rs b/crates/gecko/src/hollywood/compat.rsindex d3ab3b3..f87c40e 100644--- a/crates/gecko/src/hollywood/compat.rs+++ b/crates/gecko/src/hollywood/compat.rs@@ -1,5 +1,6 @@use crate::hollywood::regs::{HwCompat, HwPllAi, HwPllAiExt};+#[derive(Clone, Copy)]pub struct Compat {pub compat: HwCompat,pub pll_ai: HwPllAi,diff --git a/crates/gecko/src/hollywood/gpio.rs b/crates/gecko/src/hollywood/gpio.rsindex ded31c8..e56139f 100644--- a/crates/gecko/src/hollywood/gpio.rs+++ b/crates/gecko/src/hollywood/gpio.rs@@ -3,6 +3,7 @@ use crate::hollywood::regs::{GpioIntFlag, GpioIntLvl, GpioIntMask, GpioOut, GpioOwner, GpioStraps,};+#[derive(Clone, Copy)]pub struct Gpio {pub ppc_out: GpioBOut,pub ppc_dir: GpioBDir,diff --git a/crates/gecko/src/hollywood/ipc.rs b/crates/gecko/src/hollywood/ipc.rsindex 9649556..e2ea659 100644--- a/crates/gecko/src/hollywood/ipc.rs+++ b/crates/gecko/src/hollywood/ipc.rs@@ -97,6 +97,16 @@ pub trait IosDevice: Send {false}+ fn save_state(&mut self, _w: &mut crate::savestate::StateWriter) {}++ fn load_state(&mut self, _r: &mut crate::savestate::StateReader<'_>) -> Result<(), crate::savestate::StateError> {+ Ok(())+ }++ fn host_file_state(&mut self) -> Option<(u32, u64)> {+ None+ }+fn set_wiimote_shake(&mut self, _active: bool) {}fn set_wiimote_accel(&mut self, _accel: Option<[f32; 3]>) {}@@ -116,6 +126,7 @@ pub trait IosDevice: Send {fn tick_input_report(&mut self) {}}+#[derive(Clone, Copy)]pub struct Ipc {pub ppcmsg: PpcMsg,pub ppcctrl: PpcCtrl,diff --git a/crates/gecko/src/hollywood/ipc/di.rs b/crates/gecko/src/hollywood/ipc/di.rsindex d1003cf..df0b6c8 100644--- a/crates/gecko/src/hollywood/ipc/di.rs+++ b/crates/gecko/src/hollywood/ipc/di.rs@@ -36,6 +36,15 @@ impl DiskInterface {}impl IosDevice for DiskInterface {+ fn save_state(&mut self, w: &mut crate::savestate::StateWriter) {+ w.u32(self.last_error);+ }++ fn load_state(&mut self, r: &mut crate::savestate::StateReader<'_>) -> Result<(), crate::savestate::StateError> {+ self.last_error = r.u32()?;+ Ok(())+ }+fn ioctl(&mut self,ctx: &mut DeviceContext<'_>,diff --git a/crates/gecko/src/hollywood/ipc/fs/host.rs b/crates/gecko/src/hollywood/ipc/fs/host.rsindex 214d07b..1822b7b 100644--- a/crates/gecko/src/hollywood/ipc/fs/host.rs+++ b/crates/gecko/src/hollywood/ipc/fs/host.rs@@ -12,6 +12,7 @@ const IOCTL_GET_FILE_STATS: u32 = 0xB;pub struct HostBackedFile {path: PathBuf,file: File,+ mode: u32,}impl HostBackedFile {@@ -35,7 +36,11 @@ impl HostBackedFile {};match opts.open(&host_path) {- Ok(file) => Some(Self { path: host_path, file }),+ Ok(file) => Some(Self {+ path: host_path,+ file,+ mode,+ }),Err(err) => {tracing::warn!(path = format!("{}", host_path.display()),@@ -46,6 +51,16 @@ impl HostBackedFile {}}}++ pub fn reopen(host_root: &Path, nand_path: &str, mode: u32, offset: u64) -> Option<Self> {+ let mut this = Self::try_open(host_root, nand_path, mode)?;++ if let Err(err) = this.file.seek(SeekFrom::Start(offset)) {+ tracing::warn!(path = format!("{}", this.path.display()), %err, "HostBackedFile: reopen seek failed");+ }++ Some(this)+ }}impl IosDevice for HostBackedFile {@@ -121,6 +136,11 @@ impl IosDevice for HostBackedFile {}}}++ fn host_file_state(&mut self) -> Option<(u32, u64)> {+ let offset = self.file.stream_position().unwrap_or(0);+ Some((self.mode, offset))+ }}pub(super) fn nand_to_host(host_root: &Path, nand_path: &str) -> PathBuf {diff --git a/crates/gecko/src/hollywood/ipc/sysconf.rs b/crates/gecko/src/hollywood/ipc/sysconf.rsindex 227ea04..826ae21 100644--- a/crates/gecko/src/hollywood/ipc/sysconf.rs+++ b/crates/gecko/src/hollywood/ipc/sysconf.rs@@ -52,6 +52,17 @@ impl IosDevice for SysConf {0}+ fn save_state(&mut self, w: &mut crate::savestate::StateWriter) {+ w.bytes(&self.blob);+ w.u64(self.pos);+ }++ fn load_state(&mut self, r: &mut crate::savestate::StateReader<'_>) -> Result<(), crate::savestate::StateError> {+ r.bytes_into(&mut self.blob)?;+ self.pos = r.u64()?;+ Ok(())+ }+fn read(&mut self, ctx: &mut super::DeviceContext<'_>, out_ptr: u32, out_len: u32) -> i32 {let start = self.pos as usize;let n = (out_len as usize).min(self.blob.len().saturating_sub(start));diff --git a/crates/gecko/src/hollywood/ipc/usb.rs b/crates/gecko/src/hollywood/ipc/usb.rsindex 40b1aa7..f77acca 100644--- a/crates/gecko/src/hollywood/ipc/usb.rs+++ b/crates/gecko/src/hollywood/ipc/usb.rs@@ -86,6 +86,14 @@ impl IosDevice for Bluetooth {fn tick_input_report(&mut self) {Bluetooth::tick_input_report(self)}++ fn save_state(&mut self, w: &mut crate::savestate::StateWriter) {+ Bluetooth::save_state(self, w)+ }++ fn load_state(&mut self, r: &mut crate::savestate::StateReader<'_>) -> Result<(), crate::savestate::StateError> {+ Bluetooth::load_state(self, r)+ }}impl Bluetooth {@@ -230,6 +238,69 @@ impl Bluetooth {let report = self.wiimote.make_input_report();self.queue_hid_input_report(report);}++ fn save_state(&mut self, w: &mut crate::savestate::StateWriter) {+ w.u32(self.pending_hci.len() as u32);+ for frame in &self.pending_hci {+ w.bytes(frame);+ }++ w.u32(self.pending_acl.len() as u32);+ for frame in &self.pending_acl {+ w.bytes(frame);+ }++ self.wiimote.save_state(w);++ w.bool(self.scanning);+ w.bool(self.connection_requested);+ w.bool(self.connected);++ match self.host_hid_control_cid {+ Some(cid) => {+ w.bool(true);+ w.u16(cid);+ }+ None => w.bool(false),+ }++ match self.host_hid_interrupt_cid {+ Some(cid) => {+ w.bool(true);+ w.u16(cid);+ }+ None => w.bool(false),+ }++ w.u8(self.next_l2cap_ident);+ }++ fn load_state(&mut self, r: &mut crate::savestate::StateReader<'_>) -> Result<(), crate::savestate::StateError> {+ self.pending_hci.clear();+ let hci_count = r.u32()?;+ for _ in 0..hci_count {+ self.pending_hci.push_back(r.bytes()?.to_vec());+ }++ self.pending_acl.clear();+ let acl_count = r.u32()?;+ for _ in 0..acl_count {+ self.pending_acl.push_back(r.bytes()?.to_vec());+ }++ self.wiimote.load_state(r)?;++ self.scanning = r.bool()?;+ self.connection_requested = r.bool()?;+ self.connected = r.bool()?;++ self.host_hid_control_cid = if r.bool()? { Some(r.u16()?) } else { None };+ self.host_hid_interrupt_cid = if r.bool()? { Some(r.u16()?) } else { None };++ self.next_l2cap_ident = r.u8()?;++ Ok(())+ }}#[inline(always)]diff --git a/crates/gecko/src/hollywood/ipc/usb/wiimote.rs b/crates/gecko/src/hollywood/ipc/usb/wiimote.rsindex 79bb202..990440f 100644--- a/crates/gecko/src/hollywood/ipc/usb/wiimote.rs+++ b/crates/gecko/src/hollywood/ipc/usb/wiimote.rs@@ -720,3 +720,81 @@ mod tests {assert_eq!(wiimote.report_mode, ReportMode::CoreAccel);}}++impl WiimoteState {+ pub(super) fn save_state(&self, w: &mut crate::savestate::StateWriter) {+ w.u16(self.buttons);+ w.u8(self.report_mode as u8);+ w.bool(self.continuous);+ w.u8(self.leds);+ w.bool(self.ir_enabled_pin1);+ w.bool(self.ir_enabled_pin2);+ w.bytes(&self.eeprom);+ w.bool(self.nunchuk_attached);+ w.u8(self.nunchuk_buttons);+ w.u8(self.nunchuk_stick_x);+ w.u8(self.nunchuk_stick_y);+ w.pod(&self.nunchuk_calibration);+ w.pod(&self.nunchuk_key_buf);+ w.u16(self.nunchuk_key_valid);+ w.pod(&self.nunchuk_cipher);++ match self.ir_pointer {+ Some((x, y)) => {+ w.bool(true);+ w.u16(x);+ w.u16(y);+ }+ None => w.bool(false),+ }++ w.pod(&self.accel);++ match self.accel_override {+ Some(accel) => {+ w.bool(true);+ w.pod(&accel);+ }+ None => w.bool(false),+ }++ w.bool(self.shake_active);+ w.pod(&self.shake_phase);+ w.bool(self.rumble);+ w.bool(self.dirty);+ }++ pub(super) fn load_state(+ &mut self,+ r: &mut crate::savestate::StateReader<'_>,+ ) -> Result<(), crate::savestate::StateError> {+ self.buttons = r.u16()?;+ self.report_mode = ReportMode::from_u8(r.u8()?).unwrap_or(ReportMode::Core);+ self.continuous = r.bool()?;+ self.leds = r.u8()?;+ self.ir_enabled_pin1 = r.bool()?;+ self.ir_enabled_pin2 = r.bool()?;+ r.bytes_into(&mut self.eeprom)?;+ self.nunchuk_attached = r.bool()?;+ self.nunchuk_buttons = r.u8()?;+ self.nunchuk_stick_x = r.u8()?;+ self.nunchuk_stick_y = r.u8()?;+ self.nunchuk_calibration = r.pod()?;+ self.nunchuk_key_buf = r.pod()?;+ self.nunchuk_key_valid = r.u16()?;+ self.nunchuk_cipher = r.pod()?;++ self.ir_pointer = if r.bool()? { Some((r.u16()?, r.u16()?)) } else { None };++ self.accel = r.pod()?;++ self.accel_override = if r.bool()? { Some(r.pod()?) } else { None };++ self.shake_active = r.bool()?;+ self.shake_phase = r.pod()?;+ self.rumble = r.bool()?;+ self.dirty = r.bool()?;++ Ok(())+ }+}diff --git a/crates/gecko/src/hollywood/irq.rs b/crates/gecko/src/hollywood/irq.rsindex 4fc58e9..a131ae2 100644--- a/crates/gecko/src/hollywood/irq.rs+++ b/crates/gecko/src/hollywood/irq.rs@@ -1,6 +1,7 @@use crate::hollywood::regs::{Cause, Mask};use crate::system::{System, SystemId};+#[derive(Clone, Copy)]pub struct Irq {pub cause: Cause,pub mask: Mask,diff --git a/crates/gecko/src/host.rs b/crates/gecko/src/host.rsindex 96cd375..188c830 100644--- a/crates/gecko/src/host.rs+++ b/crates/gecko/src/host.rs@@ -164,19 +164,24 @@ pub struct XfbPart {pub offset_y: u32,}-/// Per-draw data: primitive type, vertex range, modelview transform,-/// and TEV/lighting configuration (snapshotted at draw time since TEV is-/// built up incrementally via BP writes). Vertices live in the renderer's-/// scratch buffer (see [`RenderSink::vertex_scratch`]); `base_vertex` is-/// the index into that buffer where this draw's vertices start and-/// `vertex_count` is how many of them belong to this draw.+/// Per-draw data: primitive type, vertex range, and an optional snapshot of+/// TEV/lighting state. Vertices live in the renderer's scratch buffer (see+/// [`RenderSink::vertex_scratch`]); `base_vertex` is the index into that+/// buffer where this draw's vertices start and `vertex_count` is how many of+/// them belong to this draw.#[derive(Debug, Default)]pub struct DrawData {pub primitive: Primitive,pub base_vertex: u32,pub vertex_count: u32,+ /// Present only when GX frame state changed since the preceding draw.+ /// Renderers retain the last snapshot across draw-buffer flushes.+ pub state: Option<DrawState>,+}++#[derive(Debug, Clone, Default)]+pub struct DrawState {pub active_texcoords: u8,- pub modelview: [[f32; 4]; 4],// TEV combiner statepub tev_color_env: [u32; 16],pub tev_alpha_env: [u32; 16],@@ -207,7 +212,6 @@ pub struct DrawData {pub ztex_bias: u32,pub ztex_type: u8,pub ztex_op: u8,- pub frame_dirty: bool,}/// Per-vertex data after decode, ready for the renderer. Field orderdiff --git a/crates/gecko/src/lib.rs b/crates/gecko/src/lib.rsindex b527a3e..9593161 100644--- a/crates/gecko/src/lib.rs+++ b/crates/gecko/src/lib.rs@@ -14,6 +14,7 @@ pub mod jit;pub mod mmio;#[cfg(any(feature = "jit-stats", feature = "profile", feature = "gx-stats"))]pub mod profile;+pub mod savestate;pub mod scheduler;pub mod starlet;pub mod system;diff --git a/crates/gecko/src/mmio.rs b/crates/gecko/src/mmio.rsindex 6d721b0..219a74c 100644--- a/crates/gecko/src/mmio.rs+++ b/crates/gecko/src/mmio.rs@@ -611,3 +611,34 @@ unsafe fn write_be_u32_unchecked(ptr: *mut u8, value: u32) {unsafe fn write_be_u64_unchecked(ptr: *mut u8, value: u64) {unsafe { std::ptr::write_unaligned(ptr.cast::<u64>(), value.to_be()) };}++impl<const SYSTEM: SystemId> Mmio<SYSTEM> {+ pub fn save_state(&self, w: &mut crate::savestate::StateWriter) {+ w.bytes(&self.ram);+ w.bytes(&self.mem2);+ w.bytes(&self.efb);+ w.bytes(&self.hwr);+ w.bytes(&self.lcache);+ w.bytes(&self.ipl);+ }++ pub fn load_state(+ &mut self,+ r: &mut crate::savestate::StateReader<'_>,+ ) -> Result<(), crate::savestate::StateError> {+ r.bytes_into(&mut self.ram)?;+ r.bytes_into(&mut self.mem2)?;+ r.bytes_into(&mut self.efb)?;+ r.bytes_into(&mut self.hwr)?;+ r.bytes_into(&mut self.lcache)?;+ r.bytes_into(&mut self.ipl)?;++ #[cfg(feature = "jit")]+ {+ self.pending_icbi.clear();+ self.jit_dirty = 0;+ }++ Ok(())+ }+}diff --git a/crates/gecko/src/savestate.rs b/crates/gecko/src/savestate.rsnew file mode 100644index 0000000..a68b00d--- /dev/null+++ b/crates/gecko/src/savestate.rs@@ -0,0 +1,347 @@+use crate::system::{System, SystemId, WII};+use std::path::PathBuf;++pub const STATE_MAGIC: [u8; 4] = *b"GKST";+pub const STATE_VERSION: u32 = 1;++const COMPRESSION_LEVEL: i32 = 1;++const HEADER_LEN: usize = size_of::<[u8; 4]>() + size_of::<u32>() + size_of::<SystemId>() + size_of::<u64>();++#[derive(Debug)]+pub enum StateError {+ Io(std::io::Error),+ Corrupt(&'static str),+ UnsupportedVersion(u32),+ WrongSystem,+}++impl std::fmt::Display for StateError {+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {+ match self {+ StateError::Io(err) => write!(f, "io error: {err}"),+ StateError::Corrupt(what) => write!(f, "corrupt savestate: {what}"),+ StateError::UnsupportedVersion(v) => write!(f, "unsupported savestate version {v}"),+ StateError::WrongSystem => write!(f, "savestate was taken on a different system type"),+ }+ }+}++impl std::error::Error for StateError {}++impl From<std::io::Error> for StateError {+ fn from(err: std::io::Error) -> Self {+ StateError::Io(err)+ }+}++pub struct StateWriter {+ buf: Vec<u8>,+}++impl StateWriter {+ pub fn new() -> Self {+ Self::with_capacity(1 << 20)+ }++ pub fn with_capacity(capacity: usize) -> Self {+ StateWriter {+ buf: Vec::with_capacity(capacity),+ }+ }++ pub fn into_inner(self) -> Vec<u8> {+ self.buf+ }++ #[inline(always)]+ pub fn pod<T: Copy>(&mut self, value: &T) {+ let bytes = unsafe { std::slice::from_raw_parts((value as *const T).cast::<u8>(), size_of::<T>()) };+ self.buf.extend_from_slice(bytes);+ }++ #[inline(always)]+ pub fn u8(&mut self, v: u8) {+ self.buf.push(v);+ }++ #[inline(always)]+ pub fn u16(&mut self, v: u16) {+ self.buf.extend_from_slice(&v.to_le_bytes());+ }++ #[inline(always)]+ pub fn u32(&mut self, v: u32) {+ self.buf.extend_from_slice(&v.to_le_bytes());+ }++ #[inline(always)]+ pub fn u64(&mut self, v: u64) {+ self.buf.extend_from_slice(&v.to_le_bytes());+ }++ #[inline(always)]+ pub fn i32(&mut self, v: i32) {+ self.buf.extend_from_slice(&v.to_le_bytes());+ }++ #[inline(always)]+ pub fn i64(&mut self, v: i64) {+ self.buf.extend_from_slice(&v.to_le_bytes());+ }++ #[inline(always)]+ pub fn bool(&mut self, v: bool) {+ self.buf.push(v as u8);+ }++ #[inline(always)]+ pub fn bytes(&mut self, b: &[u8]) {+ self.u64(b.len() as u64);+ self.buf.extend_from_slice(b);+ }++ #[inline(always)]+ pub fn str(&mut self, s: &str) {+ self.bytes(s.as_bytes());+ }+}++pub struct StateReader<'a> {+ data: &'a [u8],+ pos: usize,+}++impl<'a> StateReader<'a> {+ pub fn new(data: &'a [u8]) -> Self {+ StateReader { data, pos: 0 }+ }++ pub fn remaining(&self) -> usize {+ self.data.len() - self.pos+ }++ #[inline(always)]+ pub fn take(&mut self, n: usize) -> Result<&'a [u8], StateError> {+ if self.remaining() < n {+ return Err(StateError::Corrupt("unexpected end of data"));+ }++ let slice = &self.data[self.pos..self.pos + n];+ self.pos += n;+ Ok(slice)+ }++ #[inline(always)]+ pub fn pod<T: Copy>(&mut self) -> Result<T, StateError> {+ let bytes = self.take(size_of::<T>())?;+ Ok(unsafe { std::ptr::read_unaligned(bytes.as_ptr().cast::<T>()) })+ }++ #[inline(always)]+ pub fn u8(&mut self) -> Result<u8, StateError> {+ Ok(self.take(1)?[0])+ }++ #[inline(always)]+ pub fn u16(&mut self) -> Result<u16, StateError> {+ Ok(u16::from_le_bytes(self.take(2)?.try_into().unwrap()))+ }++ #[inline(always)]+ pub fn u32(&mut self) -> Result<u32, StateError> {+ Ok(u32::from_le_bytes(self.take(4)?.try_into().unwrap()))+ }++ #[inline(always)]+ pub fn u64(&mut self) -> Result<u64, StateError> {+ Ok(u64::from_le_bytes(self.take(8)?.try_into().unwrap()))+ }++ #[inline(always)]+ pub fn i32(&mut self) -> Result<i32, StateError> {+ Ok(i32::from_le_bytes(self.take(4)?.try_into().unwrap()))+ }++ #[inline(always)]+ pub fn i64(&mut self) -> Result<i64, StateError> {+ Ok(i64::from_le_bytes(self.take(8)?.try_into().unwrap()))+ }++ #[inline(always)]+ pub fn bool(&mut self) -> Result<bool, StateError> {+ Ok(self.u8()? != 0)+ }++ #[inline(always)]+ pub fn bytes(&mut self) -> Result<&'a [u8], StateError> {+ let len = self.u64()? as usize;+ self.take(len)+ }++ pub fn str(&mut self) -> Result<String, StateError> {+ let bytes = self.bytes()?;+ String::from_utf8(bytes.to_vec()).map_err(|_| StateError::Corrupt("invalid utf-8 string"))+ }++ pub fn bytes_into(&mut self, dst: &mut [u8]) -> Result<(), StateError> {+ let bytes = self.bytes()?;+ if bytes.len() != dst.len() {+ return Err(StateError::Corrupt(+ "buffer size mismatch (different boot configuration?)",+ ));+ }++ dst.copy_from_slice(bytes);+ Ok(())+ }+}++pub fn pack(system: SystemId, payload: &[u8]) -> Result<Vec<u8>, StateError> {+ let compressed = zstd::bulk::compress(payload, COMPRESSION_LEVEL)?;++ let mut out = Vec::with_capacity(compressed.len() + HEADER_LEN);+ out.extend_from_slice(&STATE_MAGIC);+ out.extend_from_slice(&STATE_VERSION.to_le_bytes());+ out.push(system);+ out.extend_from_slice(&(payload.len() as u64).to_le_bytes());+ out.extend_from_slice(&compressed);+ Ok(out)+}++pub fn unpack(system: SystemId, data: &[u8]) -> Result<Vec<u8>, StateError> {+ if data.len() < HEADER_LEN {+ return Err(StateError::Corrupt("file too short"));+ }++ if data[0..4] != STATE_MAGIC {+ return Err(StateError::Corrupt("bad magic"));+ }++ let version = u32::from_le_bytes(data[4..8].try_into().unwrap());+ if version != STATE_VERSION {+ return Err(StateError::UnsupportedVersion(version));+ }++ if data[8] != system {+ return Err(StateError::WrongSystem);+ }++ let uncompressed_len = u64::from_le_bytes(data[9..17].try_into().unwrap()) as usize;+ if uncompressed_len > (1usize << 32) {+ return Err(StateError::Corrupt("implausible payload size"));+ }++ let payload = zstd::bulk::decompress(&data[HEADER_LEN..], uncompressed_len)?;+ Ok(payload)+}++impl<const SYSTEM: SystemId> System<SYSTEM> {+ pub fn save_state(&mut self) -> Result<Vec<u8>, StateError> {+ let mut ram = self.mmio.ram_view_mut();+ self.render_sink.flush_efb_copies(&mut ram);++ let mut w = StateWriter::new();++ w.bool(self.vsync_pending);+ w.bool(self.vi_present_seen_this_frame);++ self.scheduler.save_state(&mut w);++ w.pod(&self.gekko);+ self.mmio.save_state(&mut w);++ w.pod(&self.vi);+ w.pod(&self.pe);+ w.pod(&self.pi);+ w.pod(&self.mi);+ w.pod(&self.si);+ w.pod(&self.ai);+ w.pod(&self.cp);++ self.di.save_state(&mut w);+ self.dsp.save_state(&mut w);+ self.gx.save_state(&mut w);+ self.exi.save_state(&mut w);++ if SYSTEM == WII {+ self.starlet.save_state(&mut w);+ w.pod(&self.hollywood);+ }++ self::pack(SYSTEM, &w.into_inner())+ }++ pub fn load_state(&mut self, data: &[u8]) -> Result<(), StateError> {+ let payload = self::unpack(SYSTEM, data)?;+ let mut r = StateReader::new(&payload);++ self.vsync_pending = r.bool()?;+ self.vi_present_seen_this_frame = r.bool()?;++ self.scheduler.load_state(&mut r)?;++ self.gekko = r.pod()?;+ self.mmio.load_state(&mut r)?;++ self.vi = r.pod()?;+ self.pe = r.pod()?;+ self.pi = r.pod()?;+ self.mi = r.pod()?;+ self.si = r.pod()?;+ self.ai = r.pod()?;+ self.cp = r.pod()?;++ self.di.load_state(&mut r)?;+ self.dsp.load_state(&mut r)?;+ self.gx.load_state(&mut r)?;+ self.exi.load_state(&mut r)?;++ if SYSTEM == WII {+ self.starlet.load_state(&mut r)?;+ self.hollywood = r.pod()?;+ }++ if r.remaining() != 0 {+ return Err(StateError::Corrupt("trailing data"));+ }++ #[cfg(feature = "jit")]+ match self.jit.as_mut() {+ Some(jit) => jit.flush_with_refcount(&mut self.mmio),+ None => self.mmio.clear_code_refcount(),+ }++ #[cfg(not(feature = "jit"))]+ self.mmio.clear_code_refcount();++ self.render_sink.exec(crate::host::GxAction::InvalidateCaches);+ self.render_sink.reset_efb();++ Ok(())+ }++ pub fn save_state_to_file(&mut self, path: &std::path::Path) -> Result<(), StateError> {+ let data = self.save_state()?;+ Ok(self::write_state_file(path, &data)?)+ }++ pub fn load_state_from_file(&mut self, path: &std::path::Path) -> Result<(), StateError> {+ let data = std::fs::read(path)?;+ self.load_state(&data)+ }+}++pub fn state_path(game_id: Option<&str>) -> PathBuf {+ crate::jit::cache::cache_dir(game_id.unwrap_or("default")).join("state.gkst")+}++pub fn write_state_file(path: &std::path::Path, data: &[u8]) -> std::io::Result<()> {+ if let Some(parent) = path.parent() {+ std::fs::create_dir_all(parent)?;+ }++ let tmp = path.with_extension("gkst.tmp");+ std::fs::write(&tmp, data)?;+ std::fs::rename(&tmp, path)+}diff --git a/crates/gecko/src/scheduler.rs b/crates/gecko/src/scheduler.rsindex 869d2b3..97182e9 100644--- a/crates/gecko/src/scheduler.rs+++ b/crates/gecko/src/scheduler.rs@@ -33,19 +33,93 @@ pub const fn microseconds_to_cycles(system: SystemId, us: u64) -> u64 {pub type ScheduledFn<const SYSTEM: SystemId> = fn(&mut System<SYSTEM>);+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]+#[repr(u16)]+pub enum Handler {+ Vsync = 1,+ InputPoll = 2,+ DspBatch = 3,+ DecUnderflow = 4,+ CpPump = 5,+ AiAudioDmaBlock = 6,+ DiTransferDone = 7,+ ViHalfLine = 8,+ AramDma = 9,+ IpcDeliver = 10,+ MemcardCmdDone0 = 11,+ MemcardCmdDone1 = 12,+ MemcardCmdDone2 = 13,+ Fps = 14,+}++impl Handler {+ pub const fn memcard_cmd_done(channel: usize) -> Self {+ match channel {+ 0 => Handler::MemcardCmdDone0,+ 1 => Handler::MemcardCmdDone1,+ 2 => Handler::MemcardCmdDone2,+ _ => unreachable!(),+ }+ }++ const ALL: [Handler; 14] = [+ Handler::Vsync,+ Handler::InputPoll,+ Handler::DspBatch,+ Handler::DecUnderflow,+ Handler::CpPump,+ Handler::AiAudioDmaBlock,+ Handler::DiTransferDone,+ Handler::ViHalfLine,+ Handler::AramDma,+ Handler::IpcDeliver,+ Handler::MemcardCmdDone0,+ Handler::MemcardCmdDone1,+ Handler::MemcardCmdDone2,+ Handler::Fps,+ ];++ pub fn from_u16(id: u16) -> Option<Self> {+ Self::ALL.get(id.checked_sub(1)? as usize).copied()+ }++ #[inline(always)]+ pub fn resolve<const SYSTEM: SystemId>(self) -> ScheduledFn<SYSTEM> {+ match self {+ Handler::Vsync => self::vsync_handler::<SYSTEM>,+ Handler::InputPoll => self::input_poll_handler::<SYSTEM>,+ Handler::DspBatch => self::dsp_batch_handler::<SYSTEM>,+ Handler::DecUnderflow => crate::gekko::dec::underflow_handler::<SYSTEM>,+ Handler::CpPump => crate::flipper::cp::pump_handler::<SYSTEM>,+ Handler::AiAudioDmaBlock => crate::flipper::ai::audio_dma_block_handler::<SYSTEM>,+ Handler::DiTransferDone => crate::dvd::transfer_done_handler::<SYSTEM>,+ Handler::ViHalfLine => crate::flipper::vi::half_line_handler::<SYSTEM>,+ Handler::AramDma => crate::flipper::dsp::regs::aram_dma_handler::<SYSTEM>,+ Handler::IpcDeliver => crate::starlet::deliver_pending::<SYSTEM>,+ Handler::MemcardCmdDone0 => crate::flipper::exi::memcard_cmd_done::<0, SYSTEM>,+ Handler::MemcardCmdDone1 => crate::flipper::exi::memcard_cmd_done::<1, SYSTEM>,+ Handler::MemcardCmdDone2 => crate::flipper::exi::memcard_cmd_done::<2, SYSTEM>,+ #[cfg(feature = "fps-counter")]+ Handler::Fps => crate::fps::fps_handler::<SYSTEM>,+ #[cfg(not(feature = "fps-counter"))]+ Handler::Fps => |_| {},+ }+ }+}+#[derive(Clone, Copy)]-struct ScheduledEvent<const SYSTEM: SystemId> {+struct ScheduledEvent {deadline: u64,- f: ScheduledFn<SYSTEM>,+ handler: Handler,}pub struct Scheduler<const SYSTEM: SystemId> {pub cycles: u64,pub(crate) next_deadline: u64,pub(crate) timebase_offset: i64,- events: VecDeque<ScheduledEvent<SYSTEM>>,+ events: VecDeque<ScheduledEvent>,#[cfg(feature = "jit-stats")]- pub(crate) event_fire_counts: rustc_hash::FxHashMap<usize, u64>,+ pub(crate) event_fire_counts: rustc_hash::FxHashMap<Handler, u64>,}impl<const SYSTEM: SystemId> Scheduler<SYSTEM> {@@ -90,33 +164,33 @@ impl<const SYSTEM: SystemId> Scheduler<SYSTEM> {}/// Insert an event keeping the deque sorted by deadline (earliest first).- pub fn schedule_at(&mut self, deadline: u64, f: ScheduledFn<SYSTEM>) {+ pub fn schedule_at(&mut self, deadline: u64, handler: Handler) {let pos = self.events.partition_point(|e| e.deadline <= deadline);- self.events.insert(pos, ScheduledEvent { deadline, f });+ self.events.insert(pos, ScheduledEvent { deadline, handler });self.next_deadline = self.next_deadline.min(deadline);}- pub fn cancel(&mut self, f: ScheduledFn<SYSTEM>) {- self.events.retain(|e| !std::ptr::fn_addr_eq(e.f, f));+ pub fn cancel(&mut self, handler: Handler) {+ self.events.retain(|e| e.handler != handler);self.refresh_deadline();}- pub fn schedule_in(&mut self, delay: u64, f: ScheduledFn<SYSTEM>) {+ pub fn schedule_in(&mut self, delay: u64, handler: Handler) {let deadline = self.cycles + delay;- self.schedule_at(deadline, f);+ self.schedule_at(deadline, handler);}#[inline(always)]- pub fn poll(&mut self) -> Option<ScheduledFn<SYSTEM>> {+ pub fn poll(&mut self) -> Option<Handler> {let front = self.events.front()?;if self.cycles >= front.deadline {- let f = self.events.pop_front().unwrap().f;+ let handler = self.events.pop_front().unwrap().handler;self.refresh_deadline();#[cfg(feature = "jit-stats")]{- *self.event_fire_counts.entry(f as *const () as usize).or_insert(0) += 1;+ *self.event_fire_counts.entry(handler).or_insert(0) += 1;}- Some(f)+ Some(handler)} else {None}@@ -126,6 +200,38 @@ impl<const SYSTEM: SystemId> Scheduler<SYSTEM> {pub fn next_deadline(&self) -> u64 {self.next_deadline}++ pub fn save_state(&self, w: &mut crate::savestate::StateWriter) {+ w.u64(self.cycles);+ w.i64(self.timebase_offset);++ w.u32(self.events.len() as u32);+ for event in &self.events {+ w.u16(event.handler as u16);+ w.u64(event.deadline);+ }+ }++ pub fn load_state(+ &mut self,+ r: &mut crate::savestate::StateReader<'_>,+ ) -> Result<(), crate::savestate::StateError> {+ self.cycles = r.u64()?;+ self.timebase_offset = r.i64()?;++ self.events.clear();+ let count = r.u32()?;+ for _ in 0..count {+ let id = r.u16()?;+ let deadline = r.u64()?;+ let handler =+ Handler::from_u16(id).ok_or(crate::savestate::StateError::Corrupt("unknown scheduler handler id"))?;+ self.events.push_back(ScheduledEvent { deadline, handler });+ }++ self.refresh_deadline();+ Ok(())+ }}impl Scheduler<{ crate::system::GC }> {@@ -144,21 +250,15 @@ impl<const SYSTEM: SystemId> Scheduler<SYSTEM> {fn with_default_events() -> Self {let mut s = Self::empty();let initial_refresh_rate = RefreshRate::Hz60;- s.schedule_at(- initial_refresh_rate.cycles_per_frame(SYSTEM),- self::vsync_handler::<SYSTEM>,- );+ s.schedule_at(initial_refresh_rate.cycles_per_frame(SYSTEM), Handler::Vsync);s.schedule_at(crate::gekko::dec::cycles_until_underflow(u32::MAX),- crate::gekko::dec::underflow_handler::<SYSTEM>,- );- s.schedule_at(- crate::flipper::cp::PUMP_INTERVAL_CYCLES,- crate::flipper::cp::pump_handler::<SYSTEM>,+ Handler::DecUnderflow,);- s.schedule_at(self::input_poll_interval(SYSTEM), self::input_poll_handler::<SYSTEM>);+ s.schedule_at(crate::flipper::cp::PUMP_INTERVAL_CYCLES, Handler::CpPump);+ s.schedule_at(self::input_poll_interval(SYSTEM), Handler::InputPoll);#[cfg(feature = "fps-counter")]- s.schedule_at(self::cpu_clock(SYSTEM), crate::fps::fps_handler::<SYSTEM>);+ s.schedule_at(self::cpu_clock(SYSTEM), Handler::Fps);s}}@@ -176,15 +276,13 @@ pub fn vsync_handler<const SYSTEM: SystemId>(sys: &mut System<SYSTEM>) {sys.vi_present_seen_this_frame = false;let rate = sys.vi.dcr.video_format().refresh_rate();- sys.scheduler- .schedule_in(rate.cycles_per_frame(SYSTEM), self::vsync_handler::<SYSTEM>);+ sys.scheduler.schedule_in(rate.cycles_per_frame(SYSTEM), Handler::Vsync);}pub fn reseed_vsync<const SYSTEM: SystemId>(sys: &mut System<SYSTEM>) {let rate = sys.vi.dcr.video_format().refresh_rate();- sys.scheduler.cancel(self::vsync_handler::<SYSTEM>);- sys.scheduler- .schedule_in(rate.cycles_per_frame(SYSTEM), self::vsync_handler::<SYSTEM>);+ sys.scheduler.cancel(Handler::Vsync);+ sys.scheduler.schedule_in(rate.cycles_per_frame(SYSTEM), Handler::Vsync);}#[inline(always)]@@ -203,7 +301,7 @@ pub fn input_poll_handler<const SYSTEM: SystemId>(sys: &mut System<SYSTEM>) {}sys.scheduler- .schedule_in(self::input_poll_interval(SYSTEM), self::input_poll_handler::<SYSTEM>);+ .schedule_in(self::input_poll_interval(SYSTEM), Handler::InputPoll);}#[inline(always)]@@ -228,5 +326,5 @@ pub fn dsp_batch_handler<const SYSTEM: SystemId>(sys: &mut System<SYSTEM>) {}sys.scheduler- .schedule_in(self::dsp_batch_interval(SYSTEM), self::dsp_batch_handler::<SYSTEM>);+ .schedule_in(self::dsp_batch_interval(SYSTEM), Handler::DspBatch);}diff --git a/crates/gecko/src/starlet.rs b/crates/gecko/src/starlet.rsindex 47d29c0..35ec531 100644--- a/crates/gecko/src/starlet.rs+++ b/crates/gecko/src/starlet.rs@@ -15,6 +15,8 @@ const FINALIZE_DELAY_US: u64 = 20;// would otherwise hammer the IPC handler nonstop and starve the DSP IRQ.const ACK_TO_NEXT_DELAY_US: u64 = 100;+const DEVICE_STATE_CAPACITY: usize = 256;+pub struct PendingResponse {pub cmd_paddr: u32,pub result: i32,@@ -237,7 +239,7 @@ fn ensure_delivery_scheduled<const SYSTEM: SystemId>(sys: &mut System<SYSTEM>, dsys.starlet.delivery_scheduled = true;sys.scheduler.schedule_in(microseconds_to_cycles(SYSTEM, delay_us),- self::deliver_pending::<SYSTEM>,+ crate::scheduler::Handler::IpcDeliver,);}@@ -411,7 +413,7 @@ fn bind_fd_context(starlet: &Starlet, ctx: &mut DeviceContext<'_>, fd: i32) -> Sdevice_path}-fn deliver_pending<const SYSTEM: SystemId>(sys: &mut System<SYSTEM>) {+pub(crate) fn deliver_pending<const SYSTEM: SystemId>(sys: &mut System<SYSTEM>) {sys.starlet.delivery_scheduled = false;if sys.hollywood.ipc.ppcctrl.arm_response() {@@ -445,3 +447,116 @@ fn deliver_pending<const SYSTEM: SystemId>(sys: &mut System<SYSTEM>) {self::ensure_delivery_scheduled::<SYSTEM>(sys, ACK_TO_NEXT_DELAY_US);}}++impl Starlet {+ pub fn save_state(&mut self, w: &mut crate::savestate::StateWriter) {+ w.i32(self.next_fd);+ w.bool(self.delivery_scheduled);++ w.u32(self.pending.len() as u32);+ for response in &self.pending {+ w.u32(response.cmd_paddr);+ w.i32(response.result);+ }++ let mut devices: Vec<_> = self.devices.iter_mut().collect();+ devices.sort_by(|a, b| a.0.cmp(b.0));++ w.u32(devices.len() as u32);+ for (path, dev) in devices {+ w.str(path);++ let mut inner = crate::savestate::StateWriter::with_capacity(DEVICE_STATE_CAPACITY);+ dev.save_state(&mut inner);+ w.bytes(&inner.into_inner());+ }++ let mut handles: Vec<_> = self.handles.iter_mut().collect();+ handles.sort_by_key(|(fd, _)| **fd);++ w.u32(handles.len() as u32);+ for (fd, entry) in handles {+ w.i32(*fd);+ match entry {+ FdEntry::Shared(path) => {+ w.u8(0);+ w.str(path);+ }+ FdEntry::Owned { path, dev } => {+ w.u8(1);+ w.str(path);++ let (mode, offset) = dev.host_file_state().unwrap_or((0, 0));+ w.u32(mode);+ w.u64(offset);+ }+ }+ }+ }++ pub fn load_state(+ &mut self,+ r: &mut crate::savestate::StateReader<'_>,+ ) -> Result<(), crate::savestate::StateError> {+ self.next_fd = r.i32()?;+ self.delivery_scheduled = r.bool()?;++ self.pending.clear();+ let pending_count = r.u32()?;+ for _ in 0..pending_count {+ self.pending.push_back(PendingResponse {+ cmd_paddr: r.u32()?,+ result: r.i32()?,+ });+ }++ let device_count = r.u32()?;+ for _ in 0..device_count {+ let path = r.str()?;+ let payload = r.bytes()?;++ let Some(dev) = self.devices.get_mut(&path) else {+ return Err(crate::savestate::StateError::Corrupt(+ "savestate references an unregistered IOS device",+ ));+ };++ let mut inner = crate::savestate::StateReader::new(payload);+ dev.load_state(&mut inner)?;+ }++ self.handles.clear();+ let handle_count = r.u32()?;+ for _ in 0..handle_count {+ let fd = r.i32()?;+ match r.u8()? {+ 0 => {+ self.handles.insert(fd, FdEntry::Shared(r.str()?));+ }+ 1 => {+ let path = r.str()?;+ let mode = r.u32()?;+ let offset = r.u64()?;++ match HostBackedFile::reopen(&self.host_fs_root, &path, mode, offset) {+ Some(dev) => {+ self.handles.insert(+ fd,+ FdEntry::Owned {+ path,+ dev: Box::new(dev),+ },+ );+ }+ None => {+ tracing::warn!(path, "savestate: failed to reopen NAND file, dropping fd");+ }+ }+ }+ _ => return Err(crate::savestate::StateError::Corrupt("bad fd entry tag")),+ }+ }++ Ok(())+ }+}diff --git a/crates/gecko/src/system.rs b/crates/gecko/src/system.rsindex a5ac7ac..1e64842 100644--- a/crates/gecko/src/system.rs+++ b/crates/gecko/src/system.rs@@ -712,18 +712,13 @@ impl<const SYSTEM: SystemId> System<SYSTEM> {.scheduler.event_fire_counts.iter()- .map(|(&addr, &count)| (Self::resolve_handler_name(addr), count))+ .map(|(&handler, &count)| (format!("{handler:?}"), count)).collect();entries.sort_by(|a, b| b.1.cmp(&a.1));entries.truncate(n);entries}- #[cfg(all(feature = "jit-stats", feature = "jit"))]- fn resolve_handler_name(addr: usize) -> String {- crate::profile::resolve_symbol(addr).unwrap_or_else(|| format!("<unresolved {:#018x}>", addr))- }-#[cfg(feature = "profile")]fn tick_pprof_session(&mut self) {if self.pprof_session.is_none() {@@ -868,8 +863,8 @@ impl<const SYSTEM: SystemId> System<SYSTEM> {#[inline(always)]#[cfg_attr(feature = "hotpath", hotpath::measure)]pub fn drain_events(&mut self) {- while let Some(f) = self.scheduler.poll() {- f(self);+ while let Some(handler) = self.scheduler.poll() {+ handler.resolve::<SYSTEM>()(self);}}diff --git a/crates/tinyapp/src/app.rs b/crates/tinyapp/src/app.rsindex 794a461..c6e183b 100644--- a/crates/tinyapp/src/app.rs+++ b/crates/tinyapp/src/app.rs@@ -335,6 +335,7 @@ pub struct App {pub _audio_stream: Option<cpal::Stream>,pub shutdown_requested: Arc<AtomicBool>,pub start_gate: Arc<AtomicBool>,+ pub savestate_requests: Arc<crate::SavestateRequests>,#[cfg(feature = "fps-counter")]pub fps_shared: FpsShared,}@@ -453,6 +454,12 @@ impl ApplicationHandler<crate::UserEvent> for App {_ => {}}}++ match key {+ KeyCode::F5 => self.savestate_requests.save.store(true, Ordering::Relaxed),+ KeyCode::F7 => self.savestate_requests.load.store(true, Ordering::Relaxed),+ _ => {}+ }}let mut input = self.input.lock().unwrap();diff --git a/crates/tinyapp/src/main.rs b/crates/tinyapp/src/main.rsindex b27b594..7319ff0 100644--- a/crates/tinyapp/src/main.rs+++ b/crates/tinyapp/src/main.rs@@ -194,6 +194,17 @@ struct Args {/// write. The IPL boot uses an in-memory default if this is not given.#[arg(long)]sram: Option<String>,++ /// Load a savestate file right after boot. F5 saves and F7 loads at any+ /// time; the state file lives in the per-game cache directory next to the+ /// JIT caches.+ #[arg(long)]+ load_state: Option<String>,+}++pub struct SavestateRequests {+ pub save: AtomicBool,+ pub load: AtomicBool,}fn main() {@@ -421,6 +432,19 @@ fn run<const SYSTEM: SystemId>(}let emu_input = input.clone();+ let savestate_requests = Arc::new(SavestateRequests {+ save: AtomicBool::new(false),+ load: AtomicBool::new(false),+ });+ let savestate_path = gecko::savestate::state_path(game_id.as_deref());++ if let Some(ref path) = args.load_state {+ match emulator.load_state_from_file(std::path::Path::new(path)) {+ Ok(()) => tracing::info!(path, "savestate loaded"),+ Err(err) => tracing::error!(%err, path, "failed to load savestate, booting normally"),+ }+ }+if let Some(ref id) = game_id {let (ppc_c, ppc_s, dsp_c, dsp_s, vtx_c, vtx_s) = emulator.load_jit_cache(id);if ppc_c > 0 || dsp_c > 0 || vtx_c > 0 || ppc_s > 0 || dsp_s > 0 || vtx_s > 0 {@@ -447,6 +471,7 @@ fn run<const SYSTEM: SystemId>(input_config.wii.pointer = Some(args.pointer.clone());drop(proxy);+ let emu_savestate_requests = savestate_requests.clone();let emu_handle = std::thread::Builder::new().name("emu".into()).spawn(move || {@@ -459,6 +484,8 @@ fn run<const SYSTEM: SystemId>(emu_start_gate,emu_shutdown,fifo_record,+ savestate_path,+ emu_savestate_requests,)}).expect("failed to spawn emulator thread");@@ -479,6 +506,7 @@ fn run<const SYSTEM: SystemId>(_audio_stream: audio_stream,shutdown_requested,start_gate,+ savestate_requests,#[cfg(feature = "fps-counter")]fps_shared,};diff --git a/crates/tinyapp/src/thread.rs b/crates/tinyapp/src/thread.rsindex 0fdbaf6..f4eb1dc 100644--- a/crates/tinyapp/src/thread.rs+++ b/crates/tinyapp/src/thread.rs@@ -15,6 +15,8 @@ pub fn emu_thread<const SYSTEM: SystemId>(start_gate: Arc<AtomicBool>,shutdown: Arc<AtomicBool>,fifo_record: Option<String>,+ savestate_path: std::path::PathBuf,+ savestate_requests: Arc<crate::SavestateRequests>,) {let sleeper = SpinSleeper::default();let throttle_step = Duration::from_micros(5);@@ -46,6 +48,20 @@ pub fn emu_thread<const SYSTEM: SystemId>(}emulator.run_until_vsync();++ if savestate_requests.save.swap(false, Ordering::Relaxed) {+ match emulator.save_state_to_file(&savestate_path) {+ Ok(()) => tracing::info!(path = %savestate_path.display(), "savestate saved"),+ Err(err) => tracing::error!(%err, "savestate save failed"),+ }+ }++ if savestate_requests.load.swap(false, Ordering::Relaxed) {+ match emulator.load_state_from_file(&savestate_path) {+ Ok(()) => tracing::info!(path = %savestate_path.display(), "savestate loaded"),+ Err(err) => tracing::error!(%err, "savestate load failed"),+ }+ }}if let Some(path) = fifo_record