A GameCube/Wii emulator and debugger written in Rust.
I AM SPEEEEEEEEEEEEEEEED
Layle4c727b6eafc0
diff --git a/Cargo.lock b/Cargo.lockindex 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.rsindex 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.rsindex 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.tomlindex 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.rsnew file mode 100644index 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.rsindex 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.rsnew file mode 100644index 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(());+ }+}