Cargo.lock

@@ -232,9 +232,6 @@ name = "arrayvec"
 version = "0.7.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d3fb67a6e08acf24fdeccbac2cb6ac4305825bd1f117462e0e6f2f193345ad56"
-dependencies = [
- "serde",
-]
 
 [[package]]
 name = "as-raw-xcb-connection"
@@ -1574,8 +1571,6 @@ dependencies = [
  "allocator-api2",
  "equivalent",
  "foldhash 0.2.0",
- "serde",
- "serde_core",
 ]
 
 [[package]]
@@ -2243,22 +2238,6 @@ dependencies = [
  "zerocopy-derive",
 ]
 
-[[package]]
-name = "macro_rules_attribute"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b3ae8f6d608c795738406608304d30a2dfbdc8e58e44f7ba43236da5208ded3c"
-dependencies = [
- "macro_rules_attribute-proc_macro",
- "pastey",
-]
-
-[[package]]
-name = "macro_rules_attribute-proc_macro"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc04a4c58212d57930a24bf47d3fa87485264a3a054e9c10e042eb373573ad3c"
-
 [[package]]
 name = "matchers"
 version = "0.2.0"
@@ -3020,12 +2999,6 @@ dependencies = [
  "windows-link",
 ]
 
-[[package]]
-name = "pastey"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2ee67f1008b1ba2321834326597b8e186293b049a023cdef258527550b9935b4"
-
 [[package]]
 name = "pdb-addr2line"
 version = "0.11.2"
@@ -5121,7 +5094,6 @@ dependencies = [
  "hashbrown 0.16.1",
  "indexmap",
  "log",
- "macro_rules_attribute",
  "naga",
  "once_cell",
  "parking_lot",
@@ -5129,7 +5101,6 @@ dependencies = [
  "profiling",
  "raw-window-handle",
  "rustc-hash 1.1.0",
- "serde",
  "smallvec",
  "thiserror 2.0.18",
  "wgpu-core-deps-apple",
@@ -5252,7 +5223,6 @@ dependencies = [
  "js-sys",
  "log",
  "raw-window-handle",
- "serde",
  "web-sys",
 ]
 

Cargo.toml

@@ -44,9 +44,9 @@ serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 thread-priority = "3"
 tokio = { version = "1", features = ["io-util", "macros", "net", "rt", "sync", "time"] }
-tracing = { version = "0.1", features = ["release_max_level_debug"] }
+tracing = { version = "0.1", features = ["release_max_level_info"] }
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
-wgpu = { version = "29", features = ["serde"] }
+wgpu = "29"
 wholesym = "0.8"
 winit = { version = "0.30", features = ["serde"] }
 

src/app.rs

@@ -14,16 +14,16 @@ use egui::{
 use egui_wgpu::winit::Painter;
 use egui_winit::EventResponse;
 use gilrs::{EventType, Gilrs};
-use tracing::{debug, error, warn};
+use tracing::{error, warn};
 use winit::{
     application::ApplicationHandler,
     event::WindowEvent,
-    event_loop::{ActiveEventLoop, ControlFlow, EventLoopProxy, OwnedDisplayHandle},
+    event_loop::{ActiveEventLoop, ControlFlow, EventLoopProxy},
     window::{Window, WindowId},
 };
 
 use crate::{
-    config::{AppConfig, CliArgs},
+    config::CliArgs,
     controller::ControllerManager,
     emulator::{EmulatorClient, EmulatorCommand, SimId},
     images::ImageTextureLoader,
@@ -48,30 +48,9 @@ fn load_icon() -> anyhow::Result<IconData> {
 
 struct SharedViewportState {
     viewport_info: ViewportIdMap<ViewportInfo>,
-    wgpu: WgpuState,
+    painter: Painter,
-    painter: Option<Painter>,
     resized_viewport: Option<ViewportId>,
 }
-impl SharedViewportState {
-    fn init_painter(&mut self, ctx: &Context, window: &Window) -> &mut Painter {
-        if self.painter.is_none() {
-            let wgpu_config = egui_wgpu::WgpuConfiguration {
-                present_mode: wgpu::PresentMode::AutoVsync,
-                wgpu_setup: egui_wgpu::WgpuSetup::Existing(self.wgpu.init(window)),
-                ..egui_wgpu::WgpuConfiguration::default()
-            };
-
-            let options = egui_wgpu::RendererOptions::default();
-            let painter =
-                pollster::block_on(Painter::new(ctx.clone(), wgpu_config, false, options));
-            self.painter = Some(painter);
-        }
-        self.painter.as_mut().unwrap()
-    }
-    fn get_painter(&mut self) -> &mut Painter {
-        self.painter.as_mut().unwrap()
-    }
-}
 
 pub struct Application {
     client: EmulatorClient,
@@ -91,12 +70,10 @@ impl Application {
     pub fn new(
         client: EmulatorClient,
         proxy: EventLoopProxy<UserEvent>,
-        handle: OwnedDisplayHandle,
         persistence: Persistence,
         args: CliArgs,
-        config: AppConfig,
     ) -> Self {
-        let wgpu = WgpuState::new(handle, config);
+        let wgpu = WgpuState::new();
         let icon = load_icon().ok().map(Arc::new);
         let mappings = MappingProvider::new(persistence.clone(), args.player2_controller);
         let shortcuts = ShortcutProvider::new(persistence.clone());
@@ -154,6 +131,20 @@ impl Application {
             });
         }
 
+        let wgpu_config = egui_wgpu::WgpuConfiguration {
+            present_mode: wgpu::PresentMode::AutoVsync,
+            wgpu_setup: egui_wgpu::WgpuSetup::Existing(egui_wgpu::WgpuSetupExisting {
+                instance: wgpu.instance.clone(),
+                adapter: wgpu.adapter.clone(),
+                device: wgpu.device.clone(),
+                queue: wgpu.queue.clone(),
+            }),
+            ..egui_wgpu::WgpuConfiguration::default()
+        };
+
+        let options = egui_wgpu::RendererOptions::default();
+        let painter = pollster::block_on(Painter::new(ctx.clone(), wgpu_config, false, options));
+
         let mut initial_windows = vec![];
         if let Some(port) = args.debug_port {
             initial_windows.push(ChildWindow::Debugger { port: Some(port) });
@@ -193,8 +184,7 @@ impl Application {
             ctx,
             shared: SharedViewportState {
                 viewport_info: ViewportIdMap::default(),
-                wgpu,
+                painter,
-                painter: None,
                 resized_viewport: None,
             },
             icon,
@@ -299,7 +289,7 @@ impl Application {
             }
             let clipped_primitives = self.ctx.tessellate(output.shapes, output.pixels_per_point);
             viewport.window.pre_present_notify();
-            self.shared.get_painter().paint_and_update_textures(
+            self.shared.painter.paint_and_update_textures(
                 viewport.id,
                 output.pixels_per_point,
                 [0.0, 0.0, 0.0, 0.0],
@@ -335,11 +325,7 @@ impl Application {
                                 id,
                                 InitArgs {
                                     window: &manager.window,
-                                    render_state: &self
+                                    render_state: &self.shared.painter.render_state().unwrap(),
-                                        .shared
-                                        .get_painter()
-                                        .render_state()
-                                        .unwrap(),
                                 },
                             );
                             manager
@@ -355,9 +341,7 @@ impl Application {
         if !active_viewports.contains(&ViewportId::ROOT) {
             event_loop.exit();
         }
-        if let Some(painter) = self.shared.painter.as_mut() {
+        self.shared.painter.gc_viewports(&active_viewports);
-            painter.gc_viewports(&active_viewports);
-        }
     }
 }
 
@@ -375,7 +359,7 @@ impl ApplicationHandler<UserEvent> for Application {
             viewport_builder,
             &mut self.shared,
         );
-        let render_state = self.shared.get_painter().render_state().unwrap();
+        let render_state = self.shared.painter.render_state().unwrap();
         GameScreen::init_pipeline(&render_state);
         self.app.handle_init(
             ViewportId::ROOT,
@@ -496,66 +480,47 @@ impl ApplicationHandler<UserEvent> for Application {
 
 struct WgpuState {
     instance: wgpu::Instance,
-    device_descriptor: Arc<dyn Fn(&wgpu::Adapter) -> wgpu::DeviceDescriptor<'static> + Send + Sync>,
+    adapter: wgpu::Adapter,
-    config: AppConfig,
+    device: wgpu::Device,
+    queue: wgpu::Queue,
 }
 
 impl WgpuState {
-    fn new(handle: OwnedDisplayHandle, config: AppConfig) -> Self {
+    fn new() -> Self {
         #[allow(unused_variables)]
-        let egui_wgpu::WgpuSetupCreateNew {
+        let egui_wgpu::WgpuConfiguration {
+            wgpu_setup:
+                egui_wgpu::WgpuSetup::CreateNew(egui_wgpu::WgpuSetupCreateNew {
                     instance_descriptor: wgpu::InstanceDescriptor { backends, .. },
                     device_descriptor,
                     ..
-        } = egui_wgpu::WgpuSetupCreateNew::without_display_handle();
+                }),
+            ..
+        } = egui_wgpu::WgpuConfiguration::default()
+        else {
+            panic!("required fields not found")
+        };
         #[cfg(windows)]
         let backends = wgpu::Backends::from_env()
             .unwrap_or((wgpu::Backends::PRIMARY | wgpu::Backends::GL) - wgpu::Backends::VULKAN);
         let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
             backends,
-            ..wgpu::InstanceDescriptor::new_with_display_handle_from_env(Box::new(handle))
+            ..wgpu::InstanceDescriptor::new_without_display_handle_from_env()
         });
 
-        Self {
+        let adapter = pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions {
-            instance,
+            power_preference:
-            device_descriptor,
+                wgpu::PowerPreference::from_env().unwrap_or(wgpu::PowerPreference::LowPower),
-            config,
+            compatible_surface: None,
-        }
+            force_fallback_adapter: false,
-    }
-
-    fn init(&mut self, window: &Window) -> egui_wgpu::WgpuSetupExisting {
-        let power_preference =
-            wgpu::PowerPreference::from_env().unwrap_or(self.config.power_preference);
-        debug!("power preference: {power_preference:?}");
-
-        let force_fallback_adapter = std::env::var("WGPU_FORCE_FALLBACK")
-            .map_or(self.config.force_fallback, |f| {
-                f.eq_ignore_ascii_case("true") || f.eq_ignore_ascii_case("1")
-            });
-        debug!("force fallback: {force_fallback_adapter}");
-
-        let surface = self
-            .instance
-            .create_surface(window)
-            .expect("could not create surface");
-
-        let adapter =
-            pollster::block_on(self.instance.request_adapter(&wgpu::RequestAdapterOptions {
-                power_preference,
-                compatible_surface: Some(&surface),
-                force_fallback_adapter,
         }))
         .expect("could not create adapter");
-        debug!("selected adapter: {:?}", adapter.get_info());
-
-        drop(surface);
 
         let (device, queue) =
-            pollster::block_on(adapter.request_device(&(*self.device_descriptor)(&adapter)))
+            pollster::block_on(adapter.request_device(&(*device_descriptor)(&adapter)))
                 .expect("could not request device");
-
+        Self {
-        egui_wgpu::WgpuSetupExisting {
+            instance,
-            instance: self.instance.clone(),
             adapter,
             device,
             queue,
@@ -579,15 +544,14 @@ impl ViewportManager {
         shared: &mut SharedViewportState,
     ) -> Self {
         let window = Arc::new(egui_winit::create_window(ctx, event_loop, &builder).unwrap());
-        let painter = shared.init_painter(ctx, &window);
+        pollster::block_on(shared.painter.set_window(viewport_id, Some(window.clone()))).unwrap();
-        pollster::block_on(painter.set_window(viewport_id, Some(window.clone()))).unwrap();
         let state = egui_winit::State::new(
             ctx.clone(),
             viewport_id,
             event_loop,
             Some(window.scale_factor() as f32),
             event_loop.system_theme(),
-            painter.max_texture_side(),
+            shared.painter.max_texture_side(),
         );
 
         let mut info = ViewportInfo {
@@ -624,13 +588,9 @@ impl ViewportManager {
         {
             if shared.resized_viewport != Some(self.id) {
                 shared.resized_viewport = Some(self.id);
-                shared
+                shared.painter.on_window_resize_state_change(self.id, true);
-                    .get_painter()
-                    .on_window_resize_state_change(self.id, true);
             }
-            shared
+            shared.painter.on_window_resized(self.id, width, height);
-                .get_painter()
-                .on_window_resized(self.id, width, height);
         }
         let response = self.state.on_window_event(&self.window, event);
         let info = shared.viewport_info.get_mut(&self.id).unwrap();

src/audio.rs

@@ -29,7 +29,7 @@ impl Audio {
         }) else {
             bail!("No suitable output config available");
         };
-        let mut config = config.with_sample_rate(default_rate).config();
+        let mut config = config.with_max_sample_rate().config();
         let resample_ratio = config.sample_rate as f64 / VB_FREQUENCY as f64;
         let chunk_size = (834.0 * resample_ratio) as usize;
         let sampler = rubato::Async::new_poly(

src/config.rs

@@ -1,5 +1,5 @@
 use anyhow::Result;
-use clap::{Parser, ValueEnum};
+use clap::Parser;
 use egui::{Color32, Pos2, Vec2};
 use serde::{Deserialize, Serialize};
 
@@ -47,28 +47,6 @@ pub struct CliArgs {
     /// Map the first connected controller to Player 2
     #[arg(long)]
     pub player2_controller: bool,
-    /// Force the application to render with CPU, rather than GPU.
-    #[arg(long)]
-    pub wgpu_force_fallback: Option<bool>,
-    /// Set a preference for whether to use a low-power or high-performance GPU adapter
-    #[arg(long)]
-    pub wgpu_power_preference: Option<PowerPreferenceWrapper>,
-}
-
-#[derive(ValueEnum, Clone, Copy)]
-pub enum PowerPreferenceWrapper {
-    Low,
-    High,
-    None,
-}
-impl From<PowerPreferenceWrapper> for wgpu::PowerPreference {
-    fn from(value: PowerPreferenceWrapper) -> Self {
-        match value {
-            PowerPreferenceWrapper::Low => wgpu::PowerPreference::LowPower,
-            PowerPreferenceWrapper::High => wgpu::PowerPreference::HighPerformance,
-            PowerPreferenceWrapper::None => wgpu::PowerPreference::None,
-        }
-    }
 }
 
 pub const COLOR_PRESETS: [[Color32; 2]; 3] = [
@@ -86,49 +64,6 @@ pub const COLOR_PRESETS: [[Color32; 2]; 3] = [
     ],
 ];
 
-const fn default_power_preference() -> wgpu::PowerPreference {
-    wgpu::PowerPreference::LowPower
-}
-
-#[derive(Serialize, Deserialize, Clone, PartialEq, Eq)]
-pub struct AppConfig {
-    #[serde(default = "default_power_preference")]
-    pub power_preference: wgpu::PowerPreference,
-    #[serde(default)]
-    pub force_fallback: bool,
-}
-
-impl AppConfig {
-    pub fn load(persistence: &Persistence) -> Self {
-        if let Ok(config) = persistence.load_config(APP_CONFIG_FILENAME) {
-            return config;
-        }
-        Self {
-            power_preference: default_power_preference(),
-            force_fallback: false,
-        }
-    }
-
-    pub fn save(&self, persistence: &Persistence) -> Result<()> {
-        persistence.save_config(APP_CONFIG_FILENAME, &self)
-    }
-
-    pub fn update(&mut self, args: &CliArgs) -> bool {
-        let mut updated = false;
-        if let Some(pref) = args.wgpu_power_preference {
-            self.power_preference = pref.into();
-            updated = true;
-        }
-        if let Some(force_fallback) = args.wgpu_force_fallback {
-            self.force_fallback = force_fallback;
-            updated = true;
-        }
-        updated
-    }
-}
-
-const APP_CONFIG_FILENAME: &str = "config";
-
 const fn default_audio_enabled() -> bool {
     true
 }
@@ -146,7 +81,7 @@ pub struct SimConfig {
 
 impl SimConfig {
     pub fn load(persistence: &Persistence, sim_id: SimId) -> Self {
-        if let Ok(config) = persistence.load_config(sim_config_filename(sim_id)) {
+        if let Ok(config) = persistence.load_config(config_filename(sim_id)) {
             return config;
         }
         Self {
@@ -159,11 +94,11 @@ impl SimConfig {
     }
 
     pub fn save(&self, persistence: &Persistence, sim_id: SimId) -> Result<()> {
-        persistence.save_config(sim_config_filename(sim_id), self)
+        persistence.save_config(config_filename(sim_id), self)
     }
 }
 
-fn sim_config_filename(sim_id: SimId) -> &'static str {
+fn config_filename(sim_id: SimId) -> &'static str {
     match sim_id {
         SimId::Player1 => "config_p1",
         SimId::Player2 => "config_p2",

src/main.rs

@@ -13,7 +13,7 @@ use tracing_subscriber::{EnvFilter, Layer, layer::SubscriberExt, util::Subscribe
 use winit::event_loop::{ControlFlow, EventLoop};
 
 use crate::{
-    config::{AppConfig, CliArgs, SimConfig},
+    config::{CliArgs, SimConfig},
     emulator::SimId,
     persistence::Persistence,
 };
@@ -110,10 +110,6 @@ fn main() -> Result<()> {
     if args.profile {
         builder = builder.start_paused(true)
     }
-    let mut config = AppConfig::load(&persistence);
-    if config.update(&args) {
-        let _ = config.save(&persistence);
-    }
     let p1 = SimConfig::load(&persistence, SimId::Player1);
     let p2 = SimConfig::load(&persistence, SimId::Player2);
 
@@ -140,14 +136,6 @@ fn main() -> Result<()> {
     let event_loop = EventLoop::with_user_event().build().unwrap();
     event_loop.set_control_flow(ControlFlow::Poll);
     let proxy = event_loop.create_proxy();
-    let handle = event_loop.owned_display_handle();
+    event_loop.run_app(&mut Application::new(client, proxy, persistence, args))?;
-    event_loop.run_app(&mut Application::new(
-        client,
-        proxy,
-        handle,
-        persistence,
-        args,
-        config,
-    ))?;
     Ok(())
 }

src/window/game.rs

@@ -180,9 +180,7 @@ impl GameWindow {
         let mut viewport = child.initial_viewport();
         let title = viewport.title.clone().unwrap();
         let sim_id = child.sim_id();
-        if let Some(sim_id) = sim_id
+        if let Some(sim_id) = sim_id && self.show_player_name {
-            && self.show_player_name
-        {
             viewport.title = Some(format!("{title} ({sim_id})"));
         }
         if let Some(state) = self.child_states.get(&viewport_id) {