Skip to content

armgit / gecko

Public Imported from GitHub
0

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.lock
index 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.rs
index 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.rs
index 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<Stri
KeyTarget::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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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_hit
diff --git a/crates/debugger/src/debugger.rs b/crates/debugger/src/debugger.rs
index 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.rs
index 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.rs
index 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.toml
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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 0
pub 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<SY
sys.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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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(&reg);
+ dirty.viewport |= (XF_VIEWPORT_BASE..=XF_VIEWPORT_END).contains(&reg);
+ dirty.lighting |= (XF_LIGHT_BASE..XF_LIGHT_END).contains(&reg)
+ || (XF_CHAN_CFG_BEGIN..XF_CHAN_CFG_END).contains(&reg);
+ }
+ 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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<SYSTE
let 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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>, inst
let 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.rs
index 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: u3
let 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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 state
pub 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 order
diff --git a/crates/gecko/src/lib.rs b/crates/gecko/src/lib.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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>, d
sys.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) -> S
device_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.rs
index 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.rs
index 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.rs
index 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.rs
index 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