Skip to content

armgit / gecko

Public Imported from GitHub
0

A GameCube/Wii emulator and debugger written in Rust.

I AM SPEEEEEEEEEEEEEEEED

Layle4c727b6eafc0
diff --git a/Cargo.lock b/Cargo.lock
index 23394da..aa0c656 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -691,6 +691,15 @@ dependencies = [
"cfg-if",
]
+[[package]]
+name = "crossbeam-channel"
+version = "0.5.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2"
+dependencies = [
+ "crossbeam-utils",
+]
+
[[package]]
name = "crossbeam-utils"
version = "0.8.21"
@@ -3324,6 +3333,7 @@ version = "0.1.0"
dependencies = [
"backend-wgpu",
"clap",
+ "crossbeam-channel",
"egui",
"egui-wgpu",
"egui-winit",
diff --git a/crates/backend-wgpu/src/render.rs b/crates/backend-wgpu/src/render.rs
index 5192d71..3a9848b 100644
--- a/crates/backend-wgpu/src/render.rs
+++ b/crates/backend-wgpu/src/render.rs
@@ -194,7 +194,7 @@ impl GxRenderer {
let dc = &commands.commands[dc_idx];
let mut tex_keys: [Option<_>; 8] = [None; 8];
let mut sampler_keys: [Option<_>; 8] = [None; 8];
-
+
for slot in 0..8 {
if let Some(desc) = &dc.textures[slot] {
tex_keys[slot] = Some((desc.ram_addr, desc.width, desc.height, desc.format));
@@ -206,14 +206,14 @@ impl GxRenderer {
self.bind_group_cache.entry(bg_key).or_insert_with(|| {
let mut tex_views: [&wgpu::TextureView; 8] = [&self.fallback_view; 8];
let mut tex_samplers: [&wgpu::Sampler; 8] = [&self.sampler_cache[&fallback_sampler_key]; 8];
-
+
for slot in 0..8 {
if let Some(tk) = &tex_keys[slot] {
tex_views[slot] = &self.texture_cache[tk].1;
tex_samplers[slot] = &self.sampler_cache[&sampler_keys[slot].unwrap()];
}
}
-
+
let entries: [wgpu::BindGroupEntry; 18] = std::array::from_fn(|i| match i {
0 => wgpu::BindGroupEntry {
binding: 0,
@@ -290,7 +290,7 @@ impl GxRenderer {
sampler_keys[slot] = Some((desc.wrap_s, desc.wrap_t, desc.mag_filter, desc.min_filter));
}
}
-
+
let bg_key = BindGroupCacheKey { tex_keys, sampler_keys };
let bind_group = &self.bind_group_cache[&bg_key];
diff --git a/crates/gecko/src/flipper/exi/device.rs b/crates/gecko/src/flipper/exi/device.rs
index 7f62ad5..07303d4 100644
--- a/crates/gecko/src/flipper/exi/device.rs
+++ b/crates/gecko/src/flipper/exi/device.rs
@@ -1,4 +1,4 @@
-pub trait ExiDevice {
+pub trait ExiDevice: Send {
fn on_select(&mut self) {}
fn transfer_byte(&mut self, byte: &mut u8);
diff --git a/crates/tinyapp/Cargo.toml b/crates/tinyapp/Cargo.toml
index 6c2081f..0b59b21 100644
--- a/crates/tinyapp/Cargo.toml
+++ b/crates/tinyapp/Cargo.toml
@@ -22,3 +22,4 @@ egui-winit = { version = "0.33.3", features = ["wayland", "x11"] }
egui_plot = "0.34.1"
tracing-subscriber = { version = "0.3.23", features = ["env-filter"] }
clap = { version = "4.6.0", features = ["derive"] }
+crossbeam-channel = "0.5.15"
diff --git a/crates/tinyapp/src/app.rs b/crates/tinyapp/src/app.rs
new file mode 100644
index 0000000..806e01e
--- /dev/null
+++ b/crates/tinyapp/src/app.rs
@@ -0,0 +1,492 @@
+use std::collections::VecDeque;
+use std::sync::{Arc, Mutex};
+use std::time::Instant;
+
+use crossbeam_channel::Receiver;
+use egui::ViewportId;
+use egui_plot::{Line, Plot, PlotPoints};
+use gecko::flipper::gx::draw::DrawCommands;
+use gecko::flipper::si::pad::PadStatus;
+use winit::application::ApplicationHandler;
+use winit::event::WindowEvent;
+use winit::event_loop::ActiveEventLoop;
+use winit::keyboard::PhysicalKey;
+use winit::window::{Window, WindowId};
+
+use crate::thread::{FrameData, FrameMessage};
+use crate::update_pad;
+
+const SHADER: &str = include_str!("xfb.wgsl");
+
+pub struct State {
+ surface: wgpu::Surface<'static>,
+ surface_config: wgpu::SurfaceConfiguration,
+ device: wgpu::Device,
+ queue: wgpu::Queue,
+ pipeline: wgpu::RenderPipeline,
+ bind_group_layout: wgpu::BindGroupLayout,
+ texture: wgpu::Texture,
+ bind_group: wgpu::BindGroup,
+ tex_width: u32,
+ tex_height: u32,
+ gx_renderer: backend_wgpu::GxRenderer,
+ // egui overlay
+ egui_ctx: egui::Context,
+ egui_renderer: egui_wgpu::Renderer,
+ egui_winit: egui_winit::State,
+ fps_history: VecDeque<[f64; 2]>,
+ start_time: Instant,
+ last_frame: Instant,
+ last_native_hz: f64,
+}
+
+impl State {
+ pub fn new(window: Arc<Window>, frame_size: (u32, u32), present_mode: wgpu::PresentMode) -> Self {
+ let (w, h) = frame_size;
+
+ let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor {
+ backends: wgpu::Backends::all(),
+ ..Default::default()
+ });
+
+ let surface = instance.create_surface(window.clone()).unwrap();
+
+ let adapter = pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions {
+ power_preference: wgpu::PowerPreference::default(),
+ compatible_surface: Some(&surface),
+ force_fallback_adapter: false,
+ }))
+ .unwrap();
+
+ let (device, queue) = pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor::default())).unwrap();
+
+ let size = window.inner_size();
+ let surface_caps = surface.get_capabilities(&adapter);
+
+ let surface_format = surface_caps
+ .formats
+ .iter()
+ .find(|f| f.is_srgb())
+ .copied()
+ .unwrap_or(surface_caps.formats[0]);
+
+ let surface_config = wgpu::SurfaceConfiguration {
+ usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
+ format: surface_format,
+ width: size.width.max(1),
+ height: size.height.max(1),
+ present_mode,
+ alpha_mode: surface_caps.alpha_modes[0],
+ view_formats: vec![],
+ desired_maximum_frame_latency: 2,
+ };
+ surface.configure(&device, &surface_config);
+
+ let bind_group_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+ label: None,
+ entries: &[
+ wgpu::BindGroupLayoutEntry {
+ binding: 0,
+ visibility: wgpu::ShaderStages::FRAGMENT,
+ ty: wgpu::BindingType::Texture {
+ multisampled: false,
+ view_dimension: wgpu::TextureViewDimension::D2,
+ sample_type: wgpu::TextureSampleType::Float { filterable: true },
+ },
+ count: None,
+ },
+ wgpu::BindGroupLayoutEntry {
+ binding: 1,
+ visibility: wgpu::ShaderStages::FRAGMENT,
+ ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
+ count: None,
+ },
+ ],
+ });
+
+ let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+ label: None,
+ source: wgpu::ShaderSource::Wgsl(SHADER.into()),
+ });
+
+ let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+ label: None,
+ bind_group_layouts: &[&bind_group_layout],
+ immediate_size: 0,
+ });
+
+ let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+ label: None,
+ layout: Some(&pipeline_layout),
+ vertex: wgpu::VertexState {
+ module: &shader,
+ entry_point: Some("vs_main"),
+ buffers: &[],
+ compilation_options: Default::default(),
+ },
+ fragment: Some(wgpu::FragmentState {
+ module: &shader,
+ entry_point: Some("fs_main"),
+ targets: &[Some(wgpu::ColorTargetState {
+ format: surface_format,
+ blend: None,
+ write_mask: wgpu::ColorWrites::ALL,
+ })],
+ compilation_options: Default::default(),
+ }),
+ primitive: wgpu::PrimitiveState::default(),
+ depth_stencil: None,
+ multisample: wgpu::MultisampleState::default(),
+ multiview_mask: None,
+ cache: None,
+ });
+
+ let (texture, bind_group) = create_xfb_texture(&device, &bind_group_layout, w, h);
+ let gx_renderer = backend_wgpu::GxRenderer::new(
+ &device,
+ &queue,
+ surface_format,
+ surface_config.width,
+ surface_config.height,
+ );
+
+ let egui_ctx = egui::Context::default();
+ let egui_renderer = egui_wgpu::Renderer::new(&device, surface_format, egui_wgpu::RendererOptions::default());
+ let egui_winit = egui_winit::State::new(egui_ctx.clone(), ViewportId::ROOT, window.as_ref(), None, None, None);
+
+ State {
+ surface,
+ surface_config,
+ device,
+ queue,
+ pipeline,
+ bind_group_layout,
+ texture,
+ bind_group,
+ tex_width: w,
+ tex_height: h,
+ gx_renderer,
+ egui_ctx,
+ egui_renderer,
+ egui_winit,
+ fps_history: VecDeque::new(),
+ start_time: Instant::now(),
+ last_frame: Instant::now(),
+ last_native_hz: 60.0,
+ }
+ }
+
+ fn resize(&mut self, width: u32, height: u32) {
+ if width == 0 || height == 0 {
+ return;
+ }
+ self.surface_config.width = width;
+ self.surface_config.height = height;
+ self.surface.configure(&self.device, &self.surface_config);
+ self.gx_renderer.resize(&self.device, width, height);
+ }
+
+ fn render(&mut self, frame_rx: &Receiver<FrameMessage>, window: &Window) {
+ let mut msg: Option<FrameMessage> = None;
+ while let Ok(newer) = frame_rx.try_recv() {
+ msg = Some(newer); // drain
+ }
+
+ let msg = match msg {
+ Some(m) => m,
+ None => return,
+ };
+
+ // FPS bookkeeping
+ let delta = self.last_frame.elapsed().as_secs_f64();
+ self.last_frame = Instant::now();
+ let fps = if delta > 0.0 { 1.0 / delta } else { 0.0 };
+ let elapsed = self.start_time.elapsed().as_secs_f64();
+ self.fps_history.push_back([elapsed, fps]);
+ while self.fps_history.front().is_some_and(|e| elapsed - e[0] > 5.0) {
+ self.fps_history.pop_front();
+ }
+ self.last_native_hz = msg.native_hz;
+ let native_pct = (fps / self.last_native_hz) * 100.0;
+
+ let frame = match self.surface.get_current_texture() {
+ Ok(f) => f,
+ Err(e) => {
+ eprintln!("surface error: {e}");
+ return;
+ }
+ };
+ let view = frame.texture.create_view(&Default::default());
+
+ // Render emulator output
+ match &msg.data {
+ FrameData::Gx { commands, ram } => {
+ self.render_gx(commands, ram, &view);
+ }
+ FrameData::Xfb { pixels } => {
+ self.render_xfb(pixels, msg.width, msg.height, &view);
+ }
+ }
+
+ // egui overlay
+ let raw_input = self.egui_winit.take_egui_input(window);
+ let fps_points: Vec<[f64; 2]> = self.fps_history.iter().copied().collect();
+ let full_output = self.egui_ctx.run_ui(raw_input, |ui| {
+ let ctx = ui.ctx().clone();
+ let frame =
+ egui::Frame::window(&ctx.global_style()).fill(egui::Color32::from_rgba_unmultiplied(20, 20, 20, 180));
+ egui::Window::new("perf_hud")
+ .title_bar(false)
+ .resizable(false)
+ .movable(false)
+ .anchor(egui::Align2::RIGHT_TOP, [-8.0, 8.0])
+ .frame(frame)
+ .show(&ctx, |ui| {
+ ui.label(egui::RichText::new(format!("{fps:.1} FPS {native_pct:.1}%")).monospace());
+ Plot::new("fps_plot")
+ .height(60.0)
+ .width(180.0)
+ .show_axes(false)
+ .show_grid(false)
+ .allow_zoom(false)
+ .allow_drag(false)
+ .allow_scroll(false)
+ .show(ui, |plot_ui| {
+ plot_ui.line(
+ Line::new("fps", PlotPoints::from(fps_points.clone()))
+ .color(egui::Color32::from_rgb(100, 200, 100)),
+ );
+ });
+ });
+ });
+
+ self.egui_winit
+ .handle_platform_output(window, full_output.platform_output);
+
+ let screen_desc = egui_wgpu::ScreenDescriptor {
+ size_in_pixels: [self.surface_config.width, self.surface_config.height],
+ pixels_per_point: window.scale_factor() as f32,
+ };
+ let tris = self
+ .egui_ctx
+ .tessellate(full_output.shapes, screen_desc.pixels_per_point);
+
+ for (id, delta) in full_output.textures_delta.set {
+ self.egui_renderer.update_texture(&self.device, &self.queue, id, &delta);
+ }
+
+ let mut encoder = self
+ .device
+ .create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
+ self.egui_renderer
+ .update_buffers(&self.device, &self.queue, &mut encoder, &tris, &screen_desc);
+ {
+ let rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+ label: Some("egui"),
+ color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+ view: &view,
+ resolve_target: None,
+ ops: wgpu::Operations {
+ load: wgpu::LoadOp::Load,
+ store: wgpu::StoreOp::Store,
+ },
+ depth_slice: None,
+ })],
+ depth_stencil_attachment: None,
+ timestamp_writes: None,
+ occlusion_query_set: None,
+ multiview_mask: None,
+ });
+ self.egui_renderer
+ .render(&mut rpass.forget_lifetime(), &tris, &screen_desc);
+ }
+ self.queue.submit([encoder.finish()]);
+
+ for id in full_output.textures_delta.free {
+ self.egui_renderer.free_texture(&id);
+ }
+
+ frame.present();
+ }
+
+ fn render_gx(&mut self, commands: &DrawCommands, ram: &[u8], view: &wgpu::TextureView) {
+ self.gx_renderer.render(
+ &self.device,
+ &self.queue,
+ commands,
+ ram,
+ view,
+ self.surface_config.width,
+ self.surface_config.height,
+ );
+ }
+
+ fn render_xfb(&mut self, pixels: &[u32], w: u32, h: u32, view: &wgpu::TextureView) {
+ if (w, h) != (self.tex_width, self.tex_height) {
+ let (texture, bind_group) = create_xfb_texture(&self.device, &self.bind_group_layout, w, h);
+ self.texture = texture;
+ self.bind_group = bind_group;
+ self.tex_width = w;
+ self.tex_height = h;
+ }
+
+ let rgba: Vec<u8> = pixels
+ .iter()
+ .flat_map(|&p| [(p >> 16) as u8, (p >> 8) as u8, p as u8, 0xFF])
+ .collect();
+
+ self.queue.write_texture(
+ wgpu::TexelCopyTextureInfo {
+ texture: &self.texture,
+ mip_level: 0,
+ origin: wgpu::Origin3d::ZERO,
+ aspect: wgpu::TextureAspect::All,
+ },
+ &rgba,
+ wgpu::TexelCopyBufferLayout {
+ offset: 0,
+ bytes_per_row: Some(w * 4),
+ rows_per_image: Some(h),
+ },
+ wgpu::Extent3d {
+ width: w,
+ height: h,
+ depth_or_array_layers: 1,
+ },
+ );
+
+ let mut encoder = self.device.create_command_encoder(&Default::default());
+ {
+ let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+ label: None,
+ color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+ view,
+ resolve_target: None,
+ ops: wgpu::Operations {
+ load: wgpu::LoadOp::Clear(wgpu::Color::BLACK),
+ store: wgpu::StoreOp::Store,
+ },
+ depth_slice: None,
+ })],
+ depth_stencil_attachment: None,
+ occlusion_query_set: None,
+ timestamp_writes: None,
+ multiview_mask: None,
+ });
+ rpass.set_pipeline(&self.pipeline);
+ rpass.set_bind_group(0, &self.bind_group, &[]);
+ rpass.draw(0..3, 0..1);
+ }
+
+ self.queue.submit([encoder.finish()]);
+ }
+}
+
+fn create_xfb_texture(
+ device: &wgpu::Device,
+ layout: &wgpu::BindGroupLayout,
+ w: u32,
+ h: u32,
+) -> (wgpu::Texture, wgpu::BindGroup) {
+ let texture = device.create_texture(&wgpu::TextureDescriptor {
+ label: None,
+ size: wgpu::Extent3d {
+ width: w.max(1),
+ height: h.max(1),
+ depth_or_array_layers: 1,
+ },
+ mip_level_count: 1,
+ sample_count: 1,
+ dimension: wgpu::TextureDimension::D2,
+ format: wgpu::TextureFormat::Rgba8Unorm,
+ usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
+ view_formats: &[],
+ });
+
+ let view = texture.create_view(&Default::default());
+ let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
+ mag_filter: wgpu::FilterMode::Nearest,
+ min_filter: wgpu::FilterMode::Nearest,
+ ..Default::default()
+ });
+
+ let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+ label: None,
+ layout,
+ entries: &[
+ wgpu::BindGroupEntry {
+ binding: 0,
+ resource: wgpu::BindingResource::TextureView(&view),
+ },
+ wgpu::BindGroupEntry {
+ binding: 1,
+ resource: wgpu::BindingResource::Sampler(&sampler),
+ },
+ ],
+ });
+
+ (texture, bind_group)
+}
+
+// ---------------------------------------------------------------------------
+// Winit application handler
+// ---------------------------------------------------------------------------
+
+pub struct App {
+ pub frame_rx: Receiver<FrameMessage>,
+ pub input: Arc<Mutex<PadStatus>>,
+ pub window: Option<Arc<Window>>,
+ pub state: Option<State>,
+ pub present_mode: wgpu::PresentMode,
+ pub initial_frame_size: (u32, u32),
+}
+
+impl ApplicationHandler for App {
+ fn resumed(&mut self, event_loop: &ActiveEventLoop) {
+ let window = Arc::new(
+ event_loop
+ .create_window(Window::default_attributes().with_title("Gecko"))
+ .unwrap(),
+ );
+
+ let state = State::new(window.clone(), self.initial_frame_size, self.present_mode);
+ window.request_redraw();
+ self.window = Some(window);
+ self.state = Some(state);
+ }
+
+ fn window_event(&mut self, event_loop: &ActiveEventLoop, _id: WindowId, event: WindowEvent) {
+ // Forward events to egui first
+ if let (Some(state), Some(window)) = (&mut self.state, &self.window) {
+ let _ = state.egui_winit.on_window_event(window, &event);
+ }
+
+ match event {
+ WindowEvent::CloseRequested => event_loop.exit(),
+ WindowEvent::Resized(size) => {
+ if let Some(state) = &mut self.state {
+ state.resize(size.width, size.height);
+ }
+ }
+ WindowEvent::KeyboardInput { event, .. } => {
+ let pressed = event.state.is_pressed();
+ if let PhysicalKey::Code(key) = event.physical_key {
+ let mut pad = self.input.lock().unwrap();
+ update_pad(&mut pad, key, pressed);
+ }
+ }
+ WindowEvent::RedrawRequested => {
+ if let (Some(state), Some(window)) = (&mut self.state, &self.window) {
+ state.render(&self.frame_rx, window);
+ }
+ }
+ _ => {}
+ }
+ }
+
+ fn user_event(&mut self, _event_loop: &ActiveEventLoop, _event: ()) {
+ if let Some(window) = &self.window {
+ window.request_redraw();
+ }
+ }
+}
diff --git a/crates/tinyapp/src/main.rs b/crates/tinyapp/src/main.rs
index e85646c..e33e76e 100644
--- a/crates/tinyapp/src/main.rs
+++ b/crates/tinyapp/src/main.rs
@@ -1,477 +1,15 @@
+mod app;
+mod thread;
+
use clap::Parser;
-use egui::ViewportId;
-use egui_plot::{Line, Plot, PlotPoints};
+use crossbeam_channel::bounded;
use gecko::flipper::si::pad::{self, PadStatus, STICK_CENTER};
-use gecko::flipper::vi::regs::RefreshRate;
use gecko::gamecube::GameCube;
use image::Dol;
use image::dvd::Dvd;
-use std::collections::VecDeque;
-use std::sync::Arc;
-use std::time::Instant;
-use winit::application::ApplicationHandler;
-use winit::event::WindowEvent;
-use winit::event_loop::{ActiveEventLoop, EventLoop};
-use winit::keyboard::{KeyCode, PhysicalKey};
-use winit::window::{Window, WindowId};
-
-const SHADER: &str = include_str!("xfb.wgsl");
-
-struct State {
- surface: wgpu::Surface<'static>,
- surface_config: wgpu::SurfaceConfiguration,
- device: wgpu::Device,
- queue: wgpu::Queue,
- pipeline: wgpu::RenderPipeline,
- bind_group_layout: wgpu::BindGroupLayout,
- texture: wgpu::Texture,
- bind_group: wgpu::BindGroup,
- tex_width: u32,
- tex_height: u32,
- gx_renderer: backend_wgpu::GxRenderer,
- // egui overlay
- egui_ctx: egui::Context,
- egui_renderer: egui_wgpu::Renderer,
- egui_winit: egui_winit::State,
- fps_history: VecDeque<[f64; 2]>,
- start_time: Instant,
- last_frame: Instant,
-}
-
-impl State {
- fn new(window: Arc<Window>, emulator: &GameCube, present_mode: wgpu::PresentMode) -> Self {
- let (w, h) = emulator.frame_size();
- let (w, h) = (w as u32, h as u32);
-
- let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor {
- backends: wgpu::Backends::all(),
- ..Default::default()
- });
-
- let surface = instance.create_surface(window.clone()).unwrap();
-
- let adapter = pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions {
- power_preference: wgpu::PowerPreference::default(),
- compatible_surface: Some(&surface),
- force_fallback_adapter: false,
- }))
- .unwrap();
-
- let (device, queue) = pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor::default())).unwrap();
-
- let size = window.inner_size();
- let surface_caps = surface.get_capabilities(&adapter);
-
- let surface_format = surface_caps
- .formats
- .iter()
- .find(|f| f.is_srgb())
- .copied()
- .unwrap_or(surface_caps.formats[0]);
-
- let surface_config = wgpu::SurfaceConfiguration {
- usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
- format: surface_format,
- width: size.width.max(1),
- height: size.height.max(1),
- present_mode,
- alpha_mode: surface_caps.alpha_modes[0],
- view_formats: vec![],
- desired_maximum_frame_latency: 2,
- };
- surface.configure(&device, &surface_config);
-
- let bind_group_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
- label: None,
- entries: &[
- wgpu::BindGroupLayoutEntry {
- binding: 0,
- visibility: wgpu::ShaderStages::FRAGMENT,
- ty: wgpu::BindingType::Texture {
- multisampled: false,
- view_dimension: wgpu::TextureViewDimension::D2,
- sample_type: wgpu::TextureSampleType::Float { filterable: true },
- },
- count: None,
- },
- wgpu::BindGroupLayoutEntry {
- binding: 1,
- visibility: wgpu::ShaderStages::FRAGMENT,
- ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
- count: None,
- },
- ],
- });
-
- let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
- label: None,
- source: wgpu::ShaderSource::Wgsl(SHADER.into()),
- });
-
- let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
- label: None,
- bind_group_layouts: &[&bind_group_layout],
- immediate_size: 0,
- });
-
- let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
- label: None,
- layout: Some(&pipeline_layout),
- vertex: wgpu::VertexState {
- module: &shader,
- entry_point: Some("vs_main"),
- buffers: &[],
- compilation_options: Default::default(),
- },
- fragment: Some(wgpu::FragmentState {
- module: &shader,
- entry_point: Some("fs_main"),
- targets: &[Some(wgpu::ColorTargetState {
- format: surface_format,
- blend: None,
- write_mask: wgpu::ColorWrites::ALL,
- })],
- compilation_options: Default::default(),
- }),
- primitive: wgpu::PrimitiveState::default(),
- depth_stencil: None,
- multisample: wgpu::MultisampleState::default(),
- multiview_mask: None,
- cache: None,
- });
-
- let (texture, bind_group) = create_xfb_texture(&device, &bind_group_layout, w, h);
- let gx_renderer = backend_wgpu::GxRenderer::new(
- &device,
- &queue,
- surface_format,
- surface_config.width,
- surface_config.height,
- );
-
- let egui_ctx = egui::Context::default();
- let egui_renderer = egui_wgpu::Renderer::new(&device, surface_format, egui_wgpu::RendererOptions::default());
- let egui_winit = egui_winit::State::new(egui_ctx.clone(), ViewportId::ROOT, window.as_ref(), None, None, None);
-
- State {
- surface,
- surface_config,
- device,
- queue,
- pipeline,
- bind_group_layout,
- texture,
- bind_group,
- tex_width: w,
- tex_height: h,
- gx_renderer,
- egui_ctx,
- egui_renderer,
- egui_winit,
- fps_history: VecDeque::new(),
- start_time: Instant::now(),
- last_frame: Instant::now(),
- }
- }
-
- fn resize(&mut self, width: u32, height: u32) {
- if width == 0 || height == 0 {
- return;
- }
- self.surface_config.width = width;
- self.surface_config.height = height;
- self.surface.configure(&self.device, &self.surface_config);
- self.gx_renderer.resize(&self.device, width, height);
- }
-
- fn render(&mut self, emulator: &mut GameCube, window: &Window) {
- // update FPS history
- let delta = self.last_frame.elapsed().as_secs_f64();
- self.last_frame = Instant::now();
- let fps = if delta > 0.0 { 1.0 / delta } else { 0.0 };
- let elapsed = self.start_time.elapsed().as_secs_f64();
- self.fps_history.push_back([elapsed, fps]);
- while self.fps_history.front().is_some_and(|e| elapsed - e[0] > 5.0) {
- self.fps_history.pop_front();
- }
- let native_hz = match emulator.vi.dcr.video_format().refresh_rate() {
- RefreshRate::Hz60 => 60.0_f64,
- RefreshRate::Hz50 => 50.0_f64,
- };
- let native_pct = (fps / native_hz) * 100.0;
-
- emulator.run_until_vsync();
-
- let frame = match self.surface.get_current_texture() {
- Ok(f) => f,
- Err(e) => {
- eprintln!("surface error: {e}");
- return;
- }
- };
- let view = frame.texture.create_view(&Default::default());
-
- if !emulator.gx.draw_commands.commands.is_empty() {
- self.render_gx(emulator, &view);
- } else {
- self.render_xfb(emulator, &view);
- }
-
- // egui overlay
- let raw_input = self.egui_winit.take_egui_input(window);
- let fps_points: Vec<[f64; 2]> = self.fps_history.iter().copied().collect();
- let full_output = self.egui_ctx.run_ui(raw_input, |ui| {
- let ctx = ui.ctx().clone();
- let frame =
- egui::Frame::window(&ctx.global_style()).fill(egui::Color32::from_rgba_unmultiplied(20, 20, 20, 180));
- egui::Window::new("perf_hud")
- .title_bar(false)
- .resizable(false)
- .movable(false)
- .anchor(egui::Align2::RIGHT_TOP, [-8.0, 8.0])
- .frame(frame)
- .show(&ctx, |ui| {
- ui.label(egui::RichText::new(format!("{fps:.1} FPS {native_pct:.1}%")).monospace());
- Plot::new("fps_plot")
- .height(60.0)
- .width(180.0)
- .show_axes(false)
- .show_grid(false)
- .allow_zoom(false)
- .allow_drag(false)
- .allow_scroll(false)
- .show(ui, |plot_ui| {
- plot_ui.line(
- Line::new("fps", PlotPoints::from(fps_points.clone()))
- .color(egui::Color32::from_rgb(100, 200, 100)),
- );
- });
- });
- });
-
- self.egui_winit
- .handle_platform_output(window, full_output.platform_output);
-
- let screen_desc = egui_wgpu::ScreenDescriptor {
- size_in_pixels: [self.surface_config.width, self.surface_config.height],
- pixels_per_point: window.scale_factor() as f32,
- };
- let tris = self
- .egui_ctx
- .tessellate(full_output.shapes, screen_desc.pixels_per_point);
-
- for (id, delta) in full_output.textures_delta.set {
- self.egui_renderer.update_texture(&self.device, &self.queue, id, &delta);
- }
-
- let mut encoder = self
- .device
- .create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
- self.egui_renderer
- .update_buffers(&self.device, &self.queue, &mut encoder, &tris, &screen_desc);
- {
- let rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
- label: Some("egui"),
- color_attachments: &[Some(wgpu::RenderPassColorAttachment {
- view: &view,
- resolve_target: None,
- ops: wgpu::Operations {
- load: wgpu::LoadOp::Load,
- store: wgpu::StoreOp::Store,
- },
- depth_slice: None,
- })],
- depth_stencil_attachment: None,
- timestamp_writes: None,
- occlusion_query_set: None,
- multiview_mask: None,
- });
- self.egui_renderer
- .render(&mut rpass.forget_lifetime(), &tris, &screen_desc);
- }
- self.queue.submit([encoder.finish()]);
-
- for id in full_output.textures_delta.free {
- self.egui_renderer.free_texture(&id);
- }
-
- frame.present();
- }
-
- fn render_gx(&mut self, emulator: &mut GameCube, view: &wgpu::TextureView) {
- self.gx_renderer.render(
- &self.device,
- &self.queue,
- &emulator.gx.draw_commands,
- &emulator.mmio.ram,
- view,
- self.surface_config.width,
- self.surface_config.height,
- );
- emulator.gx.draw_commands.recycle();
- }
-
- fn render_xfb(&mut self, emulator: &GameCube, view: &wgpu::TextureView) {
- let pixels = emulator.render_xfb();
- let (w, h) = emulator.frame_size();
- let (w, h) = (w as u32, h as u32);
-
- if (w, h) != (self.tex_width, self.tex_height) {
- let (texture, bind_group) = create_xfb_texture(&self.device, &self.bind_group_layout, w, h);
- self.texture = texture;
- self.bind_group = bind_group;
- self.tex_width = w;
- self.tex_height = h;
- }
-
- let rgba: Vec<u8> = pixels
- .iter()
- .flat_map(|&p| [(p >> 16) as u8, (p >> 8) as u8, p as u8, 0xFF])
- .collect();
-
- self.queue.write_texture(
- wgpu::TexelCopyTextureInfo {
- texture: &self.texture,
- mip_level: 0,
- origin: wgpu::Origin3d::ZERO,
- aspect: wgpu::TextureAspect::All,
- },
- &rgba,
- wgpu::TexelCopyBufferLayout {
- offset: 0,
- bytes_per_row: Some(w * 4),
- rows_per_image: Some(h),
- },
- wgpu::Extent3d {
- width: w,
- height: h,
- depth_or_array_layers: 1,
- },
- );
-
- let mut encoder = self.device.create_command_encoder(&Default::default());
- {
- let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
- label: None,
- color_attachments: &[Some(wgpu::RenderPassColorAttachment {
- view,
- resolve_target: None,
- ops: wgpu::Operations {
- load: wgpu::LoadOp::Clear(wgpu::Color::BLACK),
- store: wgpu::StoreOp::Store,
- },
- depth_slice: None,
- })],
- depth_stencil_attachment: None,
- occlusion_query_set: None,
- timestamp_writes: None,
- multiview_mask: None,
- });
- rpass.set_pipeline(&self.pipeline);
- rpass.set_bind_group(0, &self.bind_group, &[]);
- rpass.draw(0..3, 0..1);
- }
-
- self.queue.submit([encoder.finish()]);
- }
-}
-
-fn create_xfb_texture(
- device: &wgpu::Device,
- layout: &wgpu::BindGroupLayout,
- w: u32,
- h: u32,
-) -> (wgpu::Texture, wgpu::BindGroup) {
- let texture = device.create_texture(&wgpu::TextureDescriptor {
- label: None,
- size: wgpu::Extent3d {
- width: w.max(1),
- height: h.max(1),
- depth_or_array_layers: 1,
- },
- mip_level_count: 1,
- sample_count: 1,
- dimension: wgpu::TextureDimension::D2,
- format: wgpu::TextureFormat::Rgba8Unorm,
- usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
- view_formats: &[],
- });
-
- let view = texture.create_view(&Default::default());
- let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
- mag_filter: wgpu::FilterMode::Nearest,
- min_filter: wgpu::FilterMode::Nearest,
- ..Default::default()
- });
-
- let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
- label: None,
- layout,
- entries: &[
- wgpu::BindGroupEntry {
- binding: 0,
- resource: wgpu::BindingResource::TextureView(&view),
- },
- wgpu::BindGroupEntry {
- binding: 1,
- resource: wgpu::BindingResource::Sampler(&sampler),
- },
- ],
- });
-
- (texture, bind_group)
-}
-
-struct App {
- emulator: GameCube,
- window: Option<Arc<Window>>,
- state: Option<State>,
- present_mode: wgpu::PresentMode,
-}
-
-impl ApplicationHandler for App {
- fn resumed(&mut self, event_loop: &ActiveEventLoop) {
- let window = Arc::new(
- event_loop
- .create_window(Window::default_attributes().with_title("Gecko"))
- .unwrap(),
- );
-
- let state = State::new(window.clone(), &self.emulator, self.present_mode);
- window.request_redraw();
- self.window = Some(window);
- self.state = Some(state);
- }
-
- fn window_event(&mut self, event_loop: &ActiveEventLoop, _id: WindowId, event: WindowEvent) {
- // Forward events to egui first
- if let (Some(state), Some(window)) = (&mut self.state, &self.window) {
- let _ = state.egui_winit.on_window_event(window, &event);
- }
-
- match event {
- WindowEvent::CloseRequested => event_loop.exit(),
- WindowEvent::Resized(size) => {
- if let Some(state) = &mut self.state {
- state.resize(size.width, size.height);
- }
- }
- WindowEvent::KeyboardInput { event, .. } => {
- let pressed = event.state.is_pressed();
- if let PhysicalKey::Code(key) = event.physical_key {
- update_pad(self.emulator.primary_controller_mut(), key, pressed);
- }
- }
- WindowEvent::RedrawRequested => {
- if let (Some(state), Some(window)) = (&mut self.state, &self.window) {
- state.render(&mut self.emulator, window);
- window.request_redraw();
- }
- }
- _ => {}
- }
- }
-}
+use std::sync::{Arc, Mutex};
+use winit::event_loop::EventLoop;
+use winit::keyboard::KeyCode;
#[derive(Parser)]
#[command(about = "GameCube emulator")]
@@ -563,12 +101,30 @@ fn main() {
..PadStatus::default()
});
+ let initial_frame_size = {
+ let (w, h) = emulator.frame_size();
+ (w as u32, h as u32)
+ };
+
+ let input = Arc::new(Mutex::new(*emulator.primary_controller_mut()));
+
+ let (frame_tx, frame_rx) = bounded::<thread::FrameMessage>(2);
+
let event_loop = EventLoop::new().unwrap();
- let mut app = App {
- emulator,
+ let proxy = event_loop.create_proxy();
+
+ let emu_input = input.clone();
+ std::thread::Builder::new()
+ .name("emu".into())
+ .spawn(move || thread::emu_thread(emulator, frame_tx, emu_input, proxy))
+ .expect("failed to spawn emulator thread");
+ let mut app = app::App {
+ frame_rx,
+ input,
window: None,
state: None,
present_mode,
+ initial_frame_size,
};
event_loop.run_app(&mut app).unwrap();
}
diff --git a/crates/tinyapp/src/thread.rs b/crates/tinyapp/src/thread.rs
new file mode 100644
index 0000000..47bd3d3
--- /dev/null
+++ b/crates/tinyapp/src/thread.rs
@@ -0,0 +1,63 @@
+use crossbeam_channel::Sender;
+use gecko::{
+ flipper::{gx::draw::DrawCommands, si::pad::PadStatus, vi::regs::RefreshRate},
+ gamecube::GameCube,
+};
+use std::sync::{Arc, Mutex};
+use winit::event_loop::EventLoopProxy;
+
+pub enum FrameData {
+ Gx { commands: DrawCommands, ram: Vec<u8> },
+ Xfb { pixels: Vec<u32> },
+}
+
+pub struct FrameMessage {
+ pub data: FrameData,
+ pub width: u32,
+ pub height: u32,
+ pub native_hz: f64,
+}
+
+pub fn emu_thread(
+ mut emulator: GameCube,
+ frame_tx: Sender<FrameMessage>,
+ input: Arc<Mutex<PadStatus>>,
+ proxy: EventLoopProxy<()>,
+) {
+ loop {
+ *emulator.primary_controller_mut() = *input.lock().unwrap();
+ emulator.run_until_vsync();
+
+ let native_hz = match emulator.vi.dcr.video_format().refresh_rate() {
+ RefreshRate::Hz60 => 60.0,
+ RefreshRate::Hz50 => 50.0,
+ };
+
+ let (w, h) = emulator.frame_size();
+ let (width, height) = (w as u32, h as u32);
+
+ let data = if !emulator.gx.draw_commands.commands.is_empty() {
+ FrameData::Gx {
+ commands: std::mem::take(&mut emulator.gx.draw_commands),
+ ram: emulator.mmio.ram.clone(),
+ }
+ } else {
+ FrameData::Xfb {
+ pixels: emulator.render_xfb(),
+ }
+ };
+
+ if frame_tx
+ .send(FrameMessage {
+ data,
+ width,
+ height,
+ native_hz,
+ })
+ .is_err()
+ {
+ break;
+ }
+ let _ = proxy.send_event(());
+ }
+}