Stop using nested viewports
This commit is contained in:
+329
@@ -0,0 +1,329 @@
|
||||
use std::{collections::HashSet, num::NonZero, sync::Arc, thread};
|
||||
|
||||
use egui::{
|
||||
ahash::{HashMap, HashMapExt},
|
||||
Context, TextWrapMode, ViewportBuilder, ViewportCommand, ViewportId, ViewportInfo,
|
||||
};
|
||||
use gilrs::{EventType, Gilrs};
|
||||
use winit::{
|
||||
application::ApplicationHandler,
|
||||
event::{KeyEvent, WindowEvent},
|
||||
event_loop::{ActiveEventLoop, EventLoopProxy},
|
||||
window::Window,
|
||||
};
|
||||
|
||||
use crate::{
|
||||
controller::ControllerManager,
|
||||
emulator::{EmulatorClient, SimId},
|
||||
input::MappingProvider,
|
||||
window::{AppWindow, GameWindow, InputWindow},
|
||||
};
|
||||
|
||||
pub struct Application {
|
||||
client: EmulatorClient,
|
||||
proxy: EventLoopProxy<UserEvent>,
|
||||
mappings: MappingProvider,
|
||||
controllers: ControllerManager,
|
||||
viewports: HashMap<ViewportId, Viewport>,
|
||||
focused: Option<ViewportId>,
|
||||
}
|
||||
|
||||
impl Application {
|
||||
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 {
|
||||
client,
|
||||
proxy,
|
||||
mappings,
|
||||
controllers,
|
||||
viewports: HashMap::new(),
|
||||
focused: None,
|
||||
}
|
||||
}
|
||||
|
||||
fn open(&mut self, event_loop: &ActiveEventLoop, window: Box<dyn AppWindow>) {
|
||||
let viewport_id = window.viewport_id();
|
||||
if self.viewports.contains_key(&viewport_id) {
|
||||
return;
|
||||
}
|
||||
self.viewports
|
||||
.insert(viewport_id, Viewport::new(event_loop, window));
|
||||
}
|
||||
}
|
||||
|
||||
impl ApplicationHandler<UserEvent> for Application {
|
||||
fn resumed(&mut self, event_loop: &ActiveEventLoop) {
|
||||
let app = GameWindow::new(self.client.clone(), self.proxy.clone(), SimId::Player1);
|
||||
let wrapper = Viewport::new(event_loop, Box::new(app));
|
||||
self.focused = Some(wrapper.id());
|
||||
self.viewports.insert(wrapper.id(), wrapper);
|
||||
}
|
||||
|
||||
fn window_event(
|
||||
&mut self,
|
||||
event_loop: &ActiveEventLoop,
|
||||
window_id: winit::window::WindowId,
|
||||
event: WindowEvent,
|
||||
) {
|
||||
let Some(viewport) = self
|
||||
.viewports
|
||||
.values_mut()
|
||||
.find(|v| v.window.id() == window_id)
|
||||
else {
|
||||
return;
|
||||
};
|
||||
let viewport_id = viewport.id();
|
||||
match &event {
|
||||
WindowEvent::KeyboardInput { event, .. } => {
|
||||
self.controllers.handle_key_event(event);
|
||||
viewport.handle_key_event(event);
|
||||
}
|
||||
WindowEvent::Focused(new_focused) => {
|
||||
self.focused = new_focused.then_some(viewport_id);
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
match viewport.on_window_event(event) {
|
||||
Some(Action::Redraw) => {
|
||||
for viewport in self.viewports.values_mut() {
|
||||
viewport.redraw(event_loop);
|
||||
}
|
||||
}
|
||||
Some(Action::Close) => {
|
||||
self.viewports.remove(&viewport_id);
|
||||
if viewport_id == ViewportId::ROOT {
|
||||
event_loop.exit();
|
||||
}
|
||||
}
|
||||
None => {}
|
||||
}
|
||||
}
|
||||
|
||||
fn device_event(
|
||||
&mut self,
|
||||
_event_loop: &ActiveEventLoop,
|
||||
_device_id: winit::event::DeviceId,
|
||||
event: winit::event::DeviceEvent,
|
||||
) {
|
||||
if let winit::event::DeviceEvent::MouseMotion { delta } = event {
|
||||
let Some(viewport) = self
|
||||
.focused
|
||||
.as_ref()
|
||||
.and_then(|id| self.viewports.get_mut(id))
|
||||
else {
|
||||
return;
|
||||
};
|
||||
viewport.state.on_mouse_motion(delta);
|
||||
}
|
||||
}
|
||||
|
||||
fn user_event(&mut self, event_loop: &ActiveEventLoop, event: UserEvent) {
|
||||
match event {
|
||||
UserEvent::GamepadEvent(event) => self.controllers.handle_gamepad_event(&event),
|
||||
UserEvent::OpenInput => {
|
||||
let input = InputWindow::new(self.mappings.clone());
|
||||
self.open(event_loop, Box::new(input));
|
||||
}
|
||||
UserEvent::OpenPlayer2 => {
|
||||
let p2 = GameWindow::new(self.client.clone(), self.proxy.clone(), SimId::Player2);
|
||||
self.open(event_loop, Box::new(p2));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn about_to_wait(&mut self, _event_loop: &ActiveEventLoop) {
|
||||
if let Some(viewport) = self.viewports.get(&ViewportId::ROOT) {
|
||||
viewport.window.request_redraw();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
struct Viewport {
|
||||
painter: egui_wgpu::winit::Painter,
|
||||
ctx: Context,
|
||||
info: ViewportInfo,
|
||||
commands: Vec<ViewportCommand>,
|
||||
builder: ViewportBuilder,
|
||||
window: Arc<Window>,
|
||||
state: egui_winit::State,
|
||||
app: Box<dyn AppWindow>,
|
||||
}
|
||||
impl Viewport {
|
||||
pub fn new(event_loop: &ActiveEventLoop, mut app: Box<dyn AppWindow>) -> Self {
|
||||
let mut painter = egui_wgpu::winit::Painter::new(
|
||||
egui_wgpu::WgpuConfiguration::default(),
|
||||
1,
|
||||
None,
|
||||
false,
|
||||
true,
|
||||
);
|
||||
|
||||
let ctx = Context::default();
|
||||
ctx.style_mut(|s| {
|
||||
s.wrap_mode = Some(TextWrapMode::Extend);
|
||||
s.visuals.menu_rounding = Default::default();
|
||||
});
|
||||
|
||||
let mut info = ViewportInfo::default();
|
||||
let builder = app.initial_viewport();
|
||||
let (window, state) = create_window_and_state(&ctx, event_loop, &builder, &mut painter);
|
||||
egui_winit::update_viewport_info(&mut info, &ctx, &window, true);
|
||||
|
||||
app.on_init(painter.render_state().as_ref().unwrap());
|
||||
Self {
|
||||
painter,
|
||||
ctx,
|
||||
info,
|
||||
commands: vec![],
|
||||
builder,
|
||||
window,
|
||||
state,
|
||||
app,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn id(&self) -> ViewportId {
|
||||
self.app.viewport_id()
|
||||
}
|
||||
|
||||
pub fn on_window_event(&mut self, event: WindowEvent) -> Option<Action> {
|
||||
let response = self.state.on_window_event(&self.window, &event);
|
||||
egui_winit::update_viewport_info(
|
||||
&mut self.info,
|
||||
self.state.egui_ctx(),
|
||||
&self.window,
|
||||
false,
|
||||
);
|
||||
|
||||
match event {
|
||||
WindowEvent::RedrawRequested => Some(Action::Redraw),
|
||||
WindowEvent::CloseRequested => Some(Action::Close),
|
||||
WindowEvent::Resized(size) => {
|
||||
let (Some(width), Some(height)) =
|
||||
(NonZero::new(size.width), NonZero::new(size.height))
|
||||
else {
|
||||
return None;
|
||||
};
|
||||
self.painter
|
||||
.on_window_resized(ViewportId::ROOT, width, height);
|
||||
None
|
||||
}
|
||||
_ if response.repaint => Some(Action::Redraw),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn handle_key_event(&mut self, event: &KeyEvent) {
|
||||
self.app.handle_key_event(event);
|
||||
}
|
||||
|
||||
fn redraw(&mut self, event_loop: &ActiveEventLoop) -> Option<Action> {
|
||||
let mut input = self.state.take_egui_input(&self.window);
|
||||
input.viewports = std::iter::once((ViewportId::ROOT, self.info.clone())).collect();
|
||||
let mut output = self.ctx.run(input, |ctx| {
|
||||
self.app.show(ctx);
|
||||
});
|
||||
let clipped_primitives = self.ctx.tessellate(output.shapes, output.pixels_per_point);
|
||||
self.painter.paint_and_update_textures(
|
||||
ViewportId::ROOT,
|
||||
output.pixels_per_point,
|
||||
[0.0, 0.0, 0.0, 0.0],
|
||||
&clipped_primitives,
|
||||
&output.textures_delta,
|
||||
false,
|
||||
);
|
||||
|
||||
self.state
|
||||
.handle_platform_output(&self.window, output.platform_output);
|
||||
|
||||
let Some(viewport_output) = output.viewport_output.remove(&ViewportId::ROOT) else {
|
||||
return Some(Action::Close);
|
||||
};
|
||||
|
||||
let (mut deferred_commands, recreate) = self.builder.patch(viewport_output.builder);
|
||||
if recreate {
|
||||
let (window, state) =
|
||||
create_window_and_state(&self.ctx, event_loop, &self.builder, &mut self.painter);
|
||||
egui_winit::update_viewport_info(&mut self.info, &self.ctx, &window, true);
|
||||
self.window = window;
|
||||
self.state = state;
|
||||
}
|
||||
self.commands.append(&mut deferred_commands);
|
||||
egui_winit::process_viewport_commands(
|
||||
&self.ctx,
|
||||
&mut self.info,
|
||||
std::mem::take(&mut self.commands),
|
||||
&self.window,
|
||||
&mut HashSet::default(),
|
||||
);
|
||||
|
||||
if self.info.close_requested() {
|
||||
Some(Action::Close)
|
||||
} else {
|
||||
Some(Action::Redraw)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for Viewport {
|
||||
fn drop(&mut self) {
|
||||
self.app.on_destroy();
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum UserEvent {
|
||||
GamepadEvent(gilrs::Event),
|
||||
OpenInput,
|
||||
OpenPlayer2,
|
||||
}
|
||||
|
||||
pub enum Action {
|
||||
Redraw,
|
||||
Close,
|
||||
}
|
||||
|
||||
fn create_window_and_state(
|
||||
ctx: &Context,
|
||||
event_loop: &ActiveEventLoop,
|
||||
builder: &ViewportBuilder,
|
||||
painter: &mut egui_wgpu::winit::Painter,
|
||||
) -> (Arc<Window>, egui_winit::State) {
|
||||
pollster::block_on(painter.set_window(ViewportId::ROOT, None)).unwrap();
|
||||
let window = Arc::new(egui_winit::create_window(ctx, event_loop, builder).unwrap());
|
||||
pollster::block_on(painter.set_window(ViewportId::ROOT, Some(window.clone()))).unwrap();
|
||||
let state = egui_winit::State::new(
|
||||
ctx.clone(),
|
||||
ViewportId::ROOT,
|
||||
event_loop,
|
||||
Some(window.scale_factor() as f32),
|
||||
event_loop.system_theme(),
|
||||
painter.max_texture_side(),
|
||||
);
|
||||
(window, state)
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user