Out with dear imgui, in with egui

src/app.rs

@@ -1,164 +0,0 @@
-use std::{collections::HashMap, fmt::Debug, thread};
-
-use game::GameWindow;
-use gilrs::{EventType, Gilrs};
-use input::InputWindow;
-use winit::{
-    application::ApplicationHandler,
-    event::{Event, WindowEvent},
-    event_loop::{ActiveEventLoop, EventLoopProxy},
-    window::WindowId,
-};
-
-use crate::{
-    controller::ControllerManager,
-    emulator::{EmulatorClient, SimId},
-    input::MappingProvider,
-};
-
-mod common;
-mod game;
-mod input;
-
-pub struct App {
-    windows: HashMap<WindowId, Box<dyn AppWindow>>,
-    client: EmulatorClient,
-    mappings: MappingProvider,
-    controllers: ControllerManager,
-    proxy: EventLoopProxy<UserEvent>,
-    player_2_window: Option<WindowId>,
-}
-
-impl App {
-    pub fn new(client: EmulatorClient, proxy: EventLoopProxy<UserEvent>) -> Self {
-        let mappings = MappingProvider::new();
-        let controllers = ControllerManager::new(client.clone(), &mappings);
-        {
-            let mappings = mappings.clone();
-            let proxy = proxy.clone();
-            thread::spawn(|| process_gamepad_input(mappings, proxy));
-        }
-        Self {
-            windows: HashMap::new(),
-            client,
-            mappings,
-            controllers,
-            proxy,
-            player_2_window: None,
-        }
-    }
-}
-
-impl ApplicationHandler<UserEvent> for App {
-    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
-        let window = GameWindow::new(
-            event_loop,
-            SimId::Player1,
-            self.client.clone(),
-            self.proxy.clone(),
-        );
-        self.windows.insert(window.id(), Box::new(window));
-    }
-
-    fn window_event(
-        &mut self,
-        event_loop: &ActiveEventLoop,
-        window_id: WindowId,
-        event: WindowEvent,
-    ) {
-        if let WindowEvent::KeyboardInput { event, .. } = &event {
-            self.controllers.handle_key_event(event);
-        }
-        let Some(window) = self.windows.get_mut(&window_id) else {
-            return;
-        };
-        window.handle_event(event_loop, &Event::WindowEvent { window_id, event });
-    }
-
-    fn user_event(&mut self, event_loop: &ActiveEventLoop, event: UserEvent) {
-        match event {
-            UserEvent::OpenInputWindow => {
-                let window =
-                    InputWindow::new(event_loop, self.mappings.clone(), self.proxy.clone());
-                self.windows.insert(window.id(), Box::new(window));
-            }
-            UserEvent::OpenPlayer2Window => {
-                if self.player_2_window.is_some() {
-                    return;
-                }
-                let window = GameWindow::new(
-                    event_loop,
-                    SimId::Player2,
-                    self.client.clone(),
-                    self.proxy.clone(),
-                );
-                self.player_2_window = Some(window.id());
-                self.windows.insert(window.id(), Box::new(window));
-            }
-            UserEvent::Close(window_id) => {
-                if self.player_2_window == Some(window_id) {
-                    self.player_2_window.take();
-                }
-                self.windows.remove(&window_id);
-            }
-            UserEvent::GamepadEvent(event) => {
-                self.controllers.handle_gamepad_event(&event);
-            }
-        }
-    }
-
-    fn device_event(
-        &mut self,
-        event_loop: &ActiveEventLoop,
-        device_id: winit::event::DeviceId,
-        event: winit::event::DeviceEvent,
-    ) {
-        for window in self.windows.values_mut() {
-            window.handle_event(
-                event_loop,
-                &Event::DeviceEvent {
-                    device_id,
-                    event: event.clone(),
-                },
-            );
-        }
-    }
-
-    fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
-        for window in self.windows.values_mut() {
-            window.handle_event(event_loop, &Event::AboutToWait);
-        }
-    }
-}
-
-pub trait AppWindow {
-    fn id(&self) -> WindowId;
-    fn handle_event(&mut self, event_loop: &ActiveEventLoop, event: &Event<UserEvent>);
-}
-
-#[derive(Debug)]
-pub enum UserEvent {
-    OpenInputWindow,
-    OpenPlayer2Window,
-    Close(WindowId),
-    GamepadEvent(gilrs::Event),
-}
-
-fn process_gamepad_input(mappings: MappingProvider, proxy: EventLoopProxy<UserEvent>) {
-    let Ok(mut gilrs) = Gilrs::new() else {
-        eprintln!("could not connect gamepad listener");
-        return;
-    };
-    while let Some(event) = gilrs.next_event_blocking(None) {
-        if event.event == EventType::Connected {
-            let Some(gamepad) = gilrs.connected_gamepad(event.id) else {
-                continue;
-            };
-            mappings.map_gamepad(SimId::Player1, &gamepad);
-        }
-        if proxy.send_event(UserEvent::GamepadEvent(event)).is_err() {
-            // main thread has closed! we done
-            return;
-        }
-    }
-}