Implement multiplayer #2
File diff suppressed because it is too large
Load Diff
11
Cargo.toml
11
Cargo.toml
|
|
@ -9,19 +9,20 @@ bitflags = "2"
|
||||||
bytemuck = { version = "1", features = ["derive"] }
|
bytemuck = { version = "1", features = ["derive"] }
|
||||||
clap = { version = "4", features = ["derive"] }
|
clap = { version = "4", features = ["derive"] }
|
||||||
cpal = { git = "https://github.com/sidit77/cpal.git", rev = "66ed6be" }
|
cpal = { git = "https://github.com/sidit77/cpal.git", rev = "66ed6be" }
|
||||||
|
egui = "0.29"
|
||||||
|
egui_extras = "0.29"
|
||||||
|
egui-winit = "0.29"
|
||||||
|
egui-wgpu = { version = "0.29", features = ["winit"] }
|
||||||
gilrs = "0.11"
|
gilrs = "0.11"
|
||||||
imgui = { version = "0.12", features = ["tables-api"] }
|
|
||||||
imgui-wgpu = { git = "https://github.com/SupernaviX/imgui-wgpu-rs", rev = "5bb8673" }
|
|
||||||
imgui-winit-support = "0.13"
|
|
||||||
itertools = "0.13"
|
itertools = "0.13"
|
||||||
native-dialog = "0.7"
|
|
||||||
num-derive = "0.4"
|
num-derive = "0.4"
|
||||||
num-traits = "0.2"
|
num-traits = "0.2"
|
||||||
pollster = "0.4"
|
pollster = "0.4"
|
||||||
|
rfd = "0.15"
|
||||||
rtrb = "0.3"
|
rtrb = "0.3"
|
||||||
rubato = "0.16"
|
rubato = "0.16"
|
||||||
thread-priority = "1"
|
thread-priority = "1"
|
||||||
wgpu = "23.0"
|
wgpu = "22.1"
|
||||||
winit = "0.30"
|
winit = "0.30"
|
||||||
|
|
||||||
[target.'cfg(windows)'.dependencies]
|
[target.'cfg(windows)'.dependencies]
|
||||||
|
|
|
||||||
164
src/app.rs
164
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;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -1,264 +0,0 @@
|
||||||
use std::{
|
|
||||||
ops::{Deref, DerefMut},
|
|
||||||
sync::Arc,
|
|
||||||
time::Instant,
|
|
||||||
};
|
|
||||||
|
|
||||||
use imgui::{FontSource, MouseCursor, SuspendedContext, WindowToken};
|
|
||||||
use imgui_wgpu::{Renderer, RendererConfig};
|
|
||||||
use imgui_winit_support::WinitPlatform;
|
|
||||||
use pollster::block_on;
|
|
||||||
#[cfg(target_os = "windows")]
|
|
||||||
use winit::platform::windows::{CornerPreference, WindowAttributesExtWindows as _};
|
|
||||||
use winit::{
|
|
||||||
dpi::{LogicalSize, PhysicalSize, Size},
|
|
||||||
event_loop::ActiveEventLoop,
|
|
||||||
window::{Window, WindowAttributes},
|
|
||||||
};
|
|
||||||
|
|
||||||
pub struct WindowStateBuilder<'a> {
|
|
||||||
event_loop: &'a ActiveEventLoop,
|
|
||||||
attributes: WindowAttributes,
|
|
||||||
}
|
|
||||||
impl<'a> WindowStateBuilder<'a> {
|
|
||||||
pub fn new(event_loop: &'a ActiveEventLoop) -> Self {
|
|
||||||
let attributes = Window::default_attributes();
|
|
||||||
#[cfg(target_os = "windows")]
|
|
||||||
let attributes = attributes.with_corner_preference(CornerPreference::DoNotRound);
|
|
||||||
Self {
|
|
||||||
event_loop,
|
|
||||||
attributes,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn with_title<T: Into<String>>(self, title: T) -> Self {
|
|
||||||
Self {
|
|
||||||
attributes: self.attributes.with_title(title),
|
|
||||||
..self
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn with_inner_size<S: Into<Size>>(self, size: S) -> Self {
|
|
||||||
Self {
|
|
||||||
attributes: self.attributes.with_inner_size(size),
|
|
||||||
..self
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn build(self) -> WindowState {
|
|
||||||
WindowState::new(self.event_loop, self.attributes)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[derive(Debug)]
|
|
||||||
pub struct WindowState {
|
|
||||||
pub device: wgpu::Device,
|
|
||||||
pub queue: Arc<wgpu::Queue>,
|
|
||||||
pub window: Arc<Window>,
|
|
||||||
pub surface_desc: wgpu::SurfaceConfiguration,
|
|
||||||
pub surface: wgpu::Surface<'static>,
|
|
||||||
pub hidpi_factor: f64,
|
|
||||||
pub minimized: bool,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl WindowState {
|
|
||||||
fn new(event_loop: &ActiveEventLoop, attributes: WindowAttributes) -> Self {
|
|
||||||
let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
|
|
||||||
backends: wgpu::Backends::PRIMARY,
|
|
||||||
..Default::default()
|
|
||||||
});
|
|
||||||
|
|
||||||
let window = Arc::new(event_loop.create_window(attributes).unwrap());
|
|
||||||
|
|
||||||
let size = window.inner_size();
|
|
||||||
let hidpi_factor = window.scale_factor();
|
|
||||||
let surface = instance.create_surface(window.clone()).unwrap();
|
|
||||||
|
|
||||||
let adapter = block_on(instance.request_adapter(&wgpu::RequestAdapterOptions {
|
|
||||||
power_preference: wgpu::PowerPreference::HighPerformance,
|
|
||||||
compatible_surface: Some(&surface),
|
|
||||||
force_fallback_adapter: false,
|
|
||||||
}))
|
|
||||||
.unwrap();
|
|
||||||
|
|
||||||
let (device, queue) =
|
|
||||||
block_on(adapter.request_device(&wgpu::DeviceDescriptor::default(), None)).unwrap();
|
|
||||||
let queue = Arc::new(queue);
|
|
||||||
|
|
||||||
// Set up swap chain
|
|
||||||
let surface_desc = wgpu::SurfaceConfiguration {
|
|
||||||
usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
|
|
||||||
format: wgpu::TextureFormat::Bgra8UnormSrgb,
|
|
||||||
width: size.width,
|
|
||||||
height: size.height,
|
|
||||||
present_mode: wgpu::PresentMode::Fifo,
|
|
||||||
desired_maximum_frame_latency: 2,
|
|
||||||
alpha_mode: wgpu::CompositeAlphaMode::Auto,
|
|
||||||
view_formats: vec![wgpu::TextureFormat::Bgra8Unorm],
|
|
||||||
};
|
|
||||||
|
|
||||||
surface.configure(&device, &surface_desc);
|
|
||||||
|
|
||||||
Self {
|
|
||||||
device,
|
|
||||||
queue,
|
|
||||||
window,
|
|
||||||
surface_desc,
|
|
||||||
surface,
|
|
||||||
hidpi_factor,
|
|
||||||
minimized: false,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn logical_size(&self) -> LogicalSize<u32> {
|
|
||||||
PhysicalSize::new(self.surface_desc.width, self.surface_desc.height)
|
|
||||||
.to_logical(self.hidpi_factor)
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn handle_resize(&mut self, size: &PhysicalSize<u32>) {
|
|
||||||
if size.width > 0 && size.height > 0 {
|
|
||||||
self.minimized = false;
|
|
||||||
self.surface_desc.width = size.width;
|
|
||||||
self.surface_desc.height = size.height;
|
|
||||||
self.surface.configure(&self.device, &self.surface_desc);
|
|
||||||
} else {
|
|
||||||
self.minimized = true;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub struct ImguiState {
|
|
||||||
pub context: ContextGuard,
|
|
||||||
pub platform: WinitPlatform,
|
|
||||||
pub renderer: Renderer,
|
|
||||||
pub clear_color: wgpu::Color,
|
|
||||||
pub last_frame: Instant,
|
|
||||||
pub last_cursor: Option<MouseCursor>,
|
|
||||||
}
|
|
||||||
impl ImguiState {
|
|
||||||
pub fn new(window: &WindowState) -> Self {
|
|
||||||
let mut context_guard = ContextGuard::new();
|
|
||||||
let mut context = context_guard.lock().unwrap();
|
|
||||||
|
|
||||||
let mut platform = imgui_winit_support::WinitPlatform::new(&mut context);
|
|
||||||
platform.attach_window(
|
|
||||||
context.io_mut(),
|
|
||||||
&window.window,
|
|
||||||
imgui_winit_support::HiDpiMode::Default,
|
|
||||||
);
|
|
||||||
context.set_ini_filename(None);
|
|
||||||
|
|
||||||
let font_size = (16.0 * window.hidpi_factor) as f32;
|
|
||||||
context.io_mut().font_global_scale = (1.0 / window.hidpi_factor) as f32;
|
|
||||||
|
|
||||||
context.fonts().add_font(&[FontSource::TtfData {
|
|
||||||
data: include_bytes!("../../assets/selawk.ttf"),
|
|
||||||
size_pixels: font_size,
|
|
||||||
config: Some(imgui::FontConfig {
|
|
||||||
oversample_h: 1,
|
|
||||||
pixel_snap_h: true,
|
|
||||||
size_pixels: font_size,
|
|
||||||
..Default::default()
|
|
||||||
}),
|
|
||||||
}]);
|
|
||||||
|
|
||||||
let style = context.style_mut();
|
|
||||||
style.use_light_colors();
|
|
||||||
|
|
||||||
//
|
|
||||||
// Set up dear imgui wgpu renderer
|
|
||||||
//
|
|
||||||
let renderer_config = RendererConfig {
|
|
||||||
texture_format: window.surface_desc.format,
|
|
||||||
..Default::default()
|
|
||||||
};
|
|
||||||
|
|
||||||
let renderer = Renderer::new(&mut context, &window.device, &window.queue, renderer_config);
|
|
||||||
|
|
||||||
let last_frame = Instant::now();
|
|
||||||
let last_cursor = None;
|
|
||||||
|
|
||||||
drop(context);
|
|
||||||
Self {
|
|
||||||
context: context_guard,
|
|
||||||
platform,
|
|
||||||
renderer,
|
|
||||||
clear_color: wgpu::Color::BLACK,
|
|
||||||
last_frame,
|
|
||||||
last_cursor,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub struct ContextGuard {
|
|
||||||
value: Option<SuspendedContext>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl ContextGuard {
|
|
||||||
fn new() -> Self {
|
|
||||||
Self {
|
|
||||||
value: Some(SuspendedContext::create()),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn lock(&mut self) -> Option<ContextLock<'_>> {
|
|
||||||
let sus = self.value.take()?;
|
|
||||||
match sus.activate() {
|
|
||||||
Ok(ctx) => Some(ContextLock {
|
|
||||||
ctx: Some(ctx),
|
|
||||||
holder: self,
|
|
||||||
}),
|
|
||||||
Err(sus) => {
|
|
||||||
self.value = Some(sus);
|
|
||||||
None
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub struct ContextLock<'a> {
|
|
||||||
ctx: Option<imgui::Context>,
|
|
||||||
holder: &'a mut ContextGuard,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<'a> Deref for ContextLock<'a> {
|
|
||||||
type Target = imgui::Context;
|
|
||||||
fn deref(&self) -> &Self::Target {
|
|
||||||
self.ctx.as_ref().unwrap()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<'a> DerefMut for ContextLock<'a> {
|
|
||||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
|
||||||
self.ctx.as_mut().unwrap()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<'a> Drop for ContextLock<'a> {
|
|
||||||
fn drop(&mut self) {
|
|
||||||
self.holder.value = self.ctx.take().map(|c| c.suspend())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub trait UiExt {
|
|
||||||
fn fullscreen_window(&self) -> Option<WindowToken<'_>>;
|
|
||||||
fn right_align_text<T: AsRef<str>>(&self, text: T, space: f32);
|
|
||||||
}
|
|
||||||
|
|
||||||
impl UiExt for imgui::Ui {
|
|
||||||
fn fullscreen_window(&self) -> Option<WindowToken<'_>> {
|
|
||||||
self.window("fullscreen")
|
|
||||||
.position([0.0, 0.0], imgui::Condition::Always)
|
|
||||||
.size(self.io().display_size, imgui::Condition::Always)
|
|
||||||
.flags(imgui::WindowFlags::NO_DECORATION)
|
|
||||||
.begin()
|
|
||||||
}
|
|
||||||
|
|
||||||
fn right_align_text<T: AsRef<str>>(&self, text: T, space: f32) {
|
|
||||||
let width = self.calc_text_size(text.as_ref())[0];
|
|
||||||
let [left, y] = self.cursor_pos();
|
|
||||||
let right = left + space;
|
|
||||||
self.set_cursor_pos([right - width, y]);
|
|
||||||
self.text(text);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
408
src/app/game.rs
408
src/app/game.rs
|
|
@ -1,408 +0,0 @@
|
||||||
use std::time::Instant;
|
|
||||||
use wgpu::util::DeviceExt as _;
|
|
||||||
use winit::{
|
|
||||||
dpi::LogicalSize,
|
|
||||||
event::{Event, WindowEvent},
|
|
||||||
event_loop::{ActiveEventLoop, EventLoopProxy},
|
|
||||||
window::WindowId,
|
|
||||||
};
|
|
||||||
|
|
||||||
use crate::{
|
|
||||||
emulator::{EmulatorClient, EmulatorCommand, SimId},
|
|
||||||
graphics::TextureSink,
|
|
||||||
};
|
|
||||||
|
|
||||||
use super::{
|
|
||||||
common::{ImguiState, WindowState, WindowStateBuilder},
|
|
||||||
AppWindow, UserEvent,
|
|
||||||
};
|
|
||||||
|
|
||||||
pub struct GameWindow {
|
|
||||||
window: WindowState,
|
|
||||||
imgui: ImguiState,
|
|
||||||
pipeline: wgpu::RenderPipeline,
|
|
||||||
bind_group: wgpu::BindGroup,
|
|
||||||
sim_id: SimId,
|
|
||||||
client: EmulatorClient,
|
|
||||||
proxy: EventLoopProxy<UserEvent>,
|
|
||||||
paused_due_to_minimize: bool,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl GameWindow {
|
|
||||||
pub fn new(
|
|
||||||
event_loop: &ActiveEventLoop,
|
|
||||||
sim_id: SimId,
|
|
||||||
client: EmulatorClient,
|
|
||||||
proxy: EventLoopProxy<UserEvent>,
|
|
||||||
) -> Self {
|
|
||||||
let title = if sim_id == SimId::Player2 {
|
|
||||||
"Shrooms VB (Player 2)"
|
|
||||||
} else {
|
|
||||||
"Shrooms VB"
|
|
||||||
};
|
|
||||||
let window = WindowStateBuilder::new(event_loop)
|
|
||||||
.with_title(title)
|
|
||||||
.with_inner_size(LogicalSize::new(384, 244))
|
|
||||||
.build();
|
|
||||||
let device = &window.device;
|
|
||||||
|
|
||||||
let (sink, texture_view) = TextureSink::new(device, window.queue.clone());
|
|
||||||
client.send_command(EmulatorCommand::SetRenderer(sim_id, sink));
|
|
||||||
let sampler = device.create_sampler(&wgpu::SamplerDescriptor::default());
|
|
||||||
let colors = Colors {
|
|
||||||
left: [1.0, 0.0, 0.0, 1.0],
|
|
||||||
right: [0.0, 0.7734375, 0.9375, 1.0],
|
|
||||||
};
|
|
||||||
let color_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
|
|
||||||
label: Some("colors"),
|
|
||||||
contents: bytemuck::bytes_of(&colors),
|
|
||||||
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
|
|
||||||
});
|
|
||||||
let texture_bind_group_layout =
|
|
||||||
device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
|
|
||||||
label: Some("texture bind group layout"),
|
|
||||||
entries: &[
|
|
||||||
wgpu::BindGroupLayoutEntry {
|
|
||||||
binding: 0,
|
|
||||||
visibility: wgpu::ShaderStages::FRAGMENT,
|
|
||||||
ty: wgpu::BindingType::Texture {
|
|
||||||
sample_type: wgpu::TextureSampleType::Float { filterable: true },
|
|
||||||
view_dimension: wgpu::TextureViewDimension::D2,
|
|
||||||
multisampled: false,
|
|
||||||
},
|
|
||||||
count: None,
|
|
||||||
},
|
|
||||||
wgpu::BindGroupLayoutEntry {
|
|
||||||
binding: 1,
|
|
||||||
visibility: wgpu::ShaderStages::FRAGMENT,
|
|
||||||
ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
|
|
||||||
count: None,
|
|
||||||
},
|
|
||||||
wgpu::BindGroupLayoutEntry {
|
|
||||||
binding: 2,
|
|
||||||
visibility: wgpu::ShaderStages::FRAGMENT,
|
|
||||||
ty: wgpu::BindingType::Buffer {
|
|
||||||
ty: wgpu::BufferBindingType::Uniform,
|
|
||||||
has_dynamic_offset: false,
|
|
||||||
min_binding_size: None,
|
|
||||||
},
|
|
||||||
count: None,
|
|
||||||
},
|
|
||||||
],
|
|
||||||
});
|
|
||||||
let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
|
|
||||||
label: Some("bind group"),
|
|
||||||
layout: &texture_bind_group_layout,
|
|
||||||
entries: &[
|
|
||||||
wgpu::BindGroupEntry {
|
|
||||||
binding: 0,
|
|
||||||
resource: wgpu::BindingResource::TextureView(&texture_view),
|
|
||||||
},
|
|
||||||
wgpu::BindGroupEntry {
|
|
||||||
binding: 1,
|
|
||||||
resource: wgpu::BindingResource::Sampler(&sampler),
|
|
||||||
},
|
|
||||||
wgpu::BindGroupEntry {
|
|
||||||
binding: 2,
|
|
||||||
resource: color_buf.as_entire_binding(),
|
|
||||||
},
|
|
||||||
],
|
|
||||||
});
|
|
||||||
|
|
||||||
let shader = device.create_shader_module(wgpu::include_wgsl!("../anaglyph.wgsl"));
|
|
||||||
let render_pipeline_layout =
|
|
||||||
device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
|
|
||||||
label: Some("render pipeline layout"),
|
|
||||||
bind_group_layouts: &[&texture_bind_group_layout],
|
|
||||||
push_constant_ranges: &[],
|
|
||||||
});
|
|
||||||
let render_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
|
|
||||||
label: Some("render pipeline"),
|
|
||||||
layout: Some(&render_pipeline_layout),
|
|
||||||
vertex: wgpu::VertexState {
|
|
||||||
module: &shader,
|
|
||||||
entry_point: Some("vs_main"),
|
|
||||||
buffers: &[],
|
|
||||||
compilation_options: wgpu::PipelineCompilationOptions::default(),
|
|
||||||
},
|
|
||||||
fragment: Some(wgpu::FragmentState {
|
|
||||||
module: &shader,
|
|
||||||
entry_point: Some("fs_main"),
|
|
||||||
targets: &[Some(wgpu::ColorTargetState {
|
|
||||||
format: wgpu::TextureFormat::Bgra8UnormSrgb,
|
|
||||||
blend: Some(wgpu::BlendState::REPLACE),
|
|
||||||
write_mask: wgpu::ColorWrites::ALL,
|
|
||||||
})],
|
|
||||||
compilation_options: wgpu::PipelineCompilationOptions::default(),
|
|
||||||
}),
|
|
||||||
primitive: wgpu::PrimitiveState {
|
|
||||||
topology: wgpu::PrimitiveTopology::TriangleList,
|
|
||||||
strip_index_format: None,
|
|
||||||
front_face: wgpu::FrontFace::Ccw,
|
|
||||||
cull_mode: Some(wgpu::Face::Back),
|
|
||||||
polygon_mode: wgpu::PolygonMode::Fill,
|
|
||||||
unclipped_depth: false,
|
|
||||||
conservative: false,
|
|
||||||
},
|
|
||||||
depth_stencil: None,
|
|
||||||
multisample: wgpu::MultisampleState {
|
|
||||||
count: 1,
|
|
||||||
mask: !0,
|
|
||||||
alpha_to_coverage_enabled: false,
|
|
||||||
},
|
|
||||||
multiview: None,
|
|
||||||
cache: None,
|
|
||||||
});
|
|
||||||
|
|
||||||
let imgui = ImguiState::new(&window);
|
|
||||||
|
|
||||||
Self {
|
|
||||||
window,
|
|
||||||
imgui,
|
|
||||||
pipeline: render_pipeline,
|
|
||||||
bind_group,
|
|
||||||
sim_id,
|
|
||||||
client,
|
|
||||||
proxy,
|
|
||||||
paused_due_to_minimize: false,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fn draw(&mut self, event_loop: &ActiveEventLoop) {
|
|
||||||
let window = &mut self.window;
|
|
||||||
let imgui = &mut self.imgui;
|
|
||||||
let mut context = imgui.context.lock().unwrap();
|
|
||||||
let mut new_size = None;
|
|
||||||
|
|
||||||
let now = Instant::now();
|
|
||||||
context.io_mut().update_delta_time(now - imgui.last_frame);
|
|
||||||
imgui.last_frame = now;
|
|
||||||
|
|
||||||
let frame = match window.surface.get_current_texture() {
|
|
||||||
Ok(frame) => frame,
|
|
||||||
Err(e) => {
|
|
||||||
if !self.window.minimized {
|
|
||||||
eprintln!("dropped frame: {e:?}");
|
|
||||||
}
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
};
|
|
||||||
imgui
|
|
||||||
.platform
|
|
||||||
.prepare_frame(context.io_mut(), &window.window)
|
|
||||||
.expect("Failed to prepare frame");
|
|
||||||
let ui = context.new_frame();
|
|
||||||
let mut menu_height = 0.0;
|
|
||||||
ui.main_menu_bar(|| {
|
|
||||||
menu_height = ui.window_size()[1];
|
|
||||||
ui.menu("ROM", || {
|
|
||||||
if ui.menu_item("Open ROM") {
|
|
||||||
let rom = native_dialog::FileDialog::new()
|
|
||||||
.add_filter("Virtual Boy ROMs", &["vb", "vbrom"])
|
|
||||||
.show_open_single_file()
|
|
||||||
.unwrap();
|
|
||||||
if let Some(path) = rom {
|
|
||||||
self.client
|
|
||||||
.send_command(EmulatorCommand::LoadGame(self.sim_id, path));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if ui.menu_item("Quit") {
|
|
||||||
event_loop.exit();
|
|
||||||
}
|
|
||||||
});
|
|
||||||
ui.menu("Emulation", || {
|
|
||||||
let has_game = self.client.has_game(self.sim_id);
|
|
||||||
if self.client.is_running(self.sim_id) {
|
|
||||||
if ui.menu_item_config("Pause").enabled(has_game).build() {
|
|
||||||
self.client.send_command(EmulatorCommand::Pause);
|
|
||||||
}
|
|
||||||
} else if ui.menu_item_config("Resume").enabled(has_game).build() {
|
|
||||||
self.client.send_command(EmulatorCommand::Resume);
|
|
||||||
}
|
|
||||||
if ui.menu_item_config("Reset").enabled(has_game).build() {
|
|
||||||
self.client
|
|
||||||
.send_command(EmulatorCommand::Reset(self.sim_id));
|
|
||||||
}
|
|
||||||
});
|
|
||||||
ui.menu("Video", || {
|
|
||||||
let current_dims = window.logical_size();
|
|
||||||
for scale in 1..=4 {
|
|
||||||
let label = format!("x{scale}");
|
|
||||||
let dims = LogicalSize::new(384 * scale, 224 * scale + 20);
|
|
||||||
let selected = dims == current_dims;
|
|
||||||
if ui.menu_item_config(label).selected(selected).build() {
|
|
||||||
if let Some(size) = window.window.request_inner_size(dims) {
|
|
||||||
window.handle_resize(&size);
|
|
||||||
new_size = Some(size);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
});
|
|
||||||
ui.menu("Audio", || {
|
|
||||||
let p1_enabled = self.client.is_audio_enabled(SimId::Player1);
|
|
||||||
let p2_enabled = self.client.is_audio_enabled(SimId::Player2);
|
|
||||||
if ui.menu_item_config("Player 1").selected(p1_enabled).build() {
|
|
||||||
self.client
|
|
||||||
.send_command(EmulatorCommand::SetAudioEnabled(!p1_enabled, p2_enabled));
|
|
||||||
}
|
|
||||||
if ui.menu_item_config("Player 2").selected(p2_enabled).build() {
|
|
||||||
self.client
|
|
||||||
.send_command(EmulatorCommand::SetAudioEnabled(p1_enabled, !p2_enabled));
|
|
||||||
}
|
|
||||||
});
|
|
||||||
ui.menu("Input", || {
|
|
||||||
if ui.menu_item("Bind Inputs") {
|
|
||||||
self.proxy.send_event(UserEvent::OpenInputWindow).unwrap();
|
|
||||||
}
|
|
||||||
});
|
|
||||||
ui.menu("Multiplayer", || {
|
|
||||||
if self.sim_id == SimId::Player1
|
|
||||||
&& !self.client.has_player_2()
|
|
||||||
&& ui.menu_item("Open Player 2")
|
|
||||||
{
|
|
||||||
self.client
|
|
||||||
.send_command(EmulatorCommand::StartSecondSim(None));
|
|
||||||
self.proxy.send_event(UserEvent::OpenPlayer2Window).unwrap();
|
|
||||||
}
|
|
||||||
if self.client.has_player_2() {
|
|
||||||
let linked = self.client.are_sims_linked();
|
|
||||||
if linked && ui.menu_item("Unlink") {
|
|
||||||
self.client.send_command(EmulatorCommand::Unlink);
|
|
||||||
}
|
|
||||||
if !linked && ui.menu_item("Link") {
|
|
||||||
self.client.send_command(EmulatorCommand::Link);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
});
|
|
||||||
});
|
|
||||||
|
|
||||||
let mut encoder: wgpu::CommandEncoder = window
|
|
||||||
.device
|
|
||||||
.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
|
|
||||||
|
|
||||||
if imgui.last_cursor != ui.mouse_cursor() {
|
|
||||||
imgui.last_cursor = ui.mouse_cursor();
|
|
||||||
imgui.platform.prepare_render(ui, &window.window);
|
|
||||||
}
|
|
||||||
|
|
||||||
let view = frame
|
|
||||||
.texture
|
|
||||||
.create_view(&wgpu::TextureViewDescriptor::default());
|
|
||||||
let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
|
|
||||||
label: None,
|
|
||||||
color_attachments: &[Some(wgpu::RenderPassColorAttachment {
|
|
||||||
view: &view,
|
|
||||||
resolve_target: None,
|
|
||||||
ops: wgpu::Operations {
|
|
||||||
load: wgpu::LoadOp::Clear(imgui.clear_color),
|
|
||||||
store: wgpu::StoreOp::Store,
|
|
||||||
},
|
|
||||||
})],
|
|
||||||
depth_stencil_attachment: None,
|
|
||||||
timestamp_writes: None,
|
|
||||||
occlusion_query_set: None,
|
|
||||||
});
|
|
||||||
|
|
||||||
// Draw the game
|
|
||||||
rpass.set_pipeline(&self.pipeline);
|
|
||||||
let window_width = window.surface_desc.width as f32;
|
|
||||||
let window_height = window.surface_desc.height as f32;
|
|
||||||
let menu_height = menu_height * window.hidpi_factor as f32;
|
|
||||||
let ((x, y), (width, height)) =
|
|
||||||
compute_game_bounds(window_width, window_height, menu_height);
|
|
||||||
rpass.set_viewport(x, y, width, height, 0.0, 1.0);
|
|
||||||
rpass.set_bind_group(0, &self.bind_group, &[]);
|
|
||||||
rpass.draw(0..6, 0..1);
|
|
||||||
|
|
||||||
// Draw the menu on top of the game
|
|
||||||
rpass.set_viewport(0.0, 0.0, window_width, window_height, 0.0, 1.0);
|
|
||||||
imgui
|
|
||||||
.renderer
|
|
||||||
.render(context.render(), &window.queue, &window.device, &mut rpass)
|
|
||||||
.expect("Rendering failed");
|
|
||||||
|
|
||||||
drop(rpass);
|
|
||||||
|
|
||||||
if let Some(size) = new_size {
|
|
||||||
imgui.platform.handle_event::<UserEvent>(
|
|
||||||
context.io_mut(),
|
|
||||||
&window.window,
|
|
||||||
&Event::WindowEvent {
|
|
||||||
window_id: window.window.id(),
|
|
||||||
event: WindowEvent::Resized(size),
|
|
||||||
},
|
|
||||||
);
|
|
||||||
}
|
|
||||||
|
|
||||||
window.queue.submit(Some(encoder.finish()));
|
|
||||||
|
|
||||||
frame.present();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl AppWindow for GameWindow {
|
|
||||||
fn id(&self) -> WindowId {
|
|
||||||
self.window.window.id()
|
|
||||||
}
|
|
||||||
|
|
||||||
fn handle_event(&mut self, event_loop: &ActiveEventLoop, event: &Event<UserEvent>) {
|
|
||||||
match event {
|
|
||||||
Event::WindowEvent { event, .. } => match event {
|
|
||||||
WindowEvent::Resized(size) => {
|
|
||||||
self.window.handle_resize(size);
|
|
||||||
if self.window.minimized {
|
|
||||||
if self.client.is_running(self.sim_id) {
|
|
||||||
self.client.send_command(EmulatorCommand::Pause);
|
|
||||||
self.paused_due_to_minimize = true;
|
|
||||||
}
|
|
||||||
} else if self.paused_due_to_minimize {
|
|
||||||
self.client.send_command(EmulatorCommand::Resume);
|
|
||||||
self.paused_due_to_minimize = false;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
WindowEvent::CloseRequested => {
|
|
||||||
if self.sim_id == SimId::Player2 {
|
|
||||||
self.client.send_command(EmulatorCommand::StopSecondSim);
|
|
||||||
self.proxy.send_event(UserEvent::Close(self.id())).unwrap();
|
|
||||||
} else {
|
|
||||||
event_loop.exit();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
WindowEvent::RedrawRequested => self.draw(event_loop),
|
|
||||||
_ => (),
|
|
||||||
},
|
|
||||||
Event::AboutToWait => {
|
|
||||||
self.window.window.request_redraw();
|
|
||||||
}
|
|
||||||
_ => (),
|
|
||||||
}
|
|
||||||
let window = &self.window;
|
|
||||||
let imgui = &mut self.imgui;
|
|
||||||
let mut context = imgui.context.lock().unwrap();
|
|
||||||
imgui
|
|
||||||
.platform
|
|
||||||
.handle_event(context.io_mut(), &window.window, event);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fn compute_game_bounds(
|
|
||||||
window_width: f32,
|
|
||||||
window_height: f32,
|
|
||||||
menu_height: f32,
|
|
||||||
) -> ((f32, f32), (f32, f32)) {
|
|
||||||
let available_width = window_width;
|
|
||||||
let available_height = window_height - menu_height;
|
|
||||||
|
|
||||||
let width = available_width.min(available_height * 384.0 / 224.0);
|
|
||||||
let height = available_height.min(available_width * 224.0 / 384.0);
|
|
||||||
let x = (available_width - width) / 2.0;
|
|
||||||
let y = menu_height + (available_height - height) / 2.0;
|
|
||||||
((x, y), (width, height))
|
|
||||||
}
|
|
||||||
|
|
||||||
#[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
|
|
||||||
#[repr(C)]
|
|
||||||
struct Colors {
|
|
||||||
left: [f32; 4],
|
|
||||||
right: [f32; 4],
|
|
||||||
}
|
|
||||||
220
src/app/input.rs
220
src/app/input.rs
|
|
@ -1,220 +0,0 @@
|
||||||
use std::time::Instant;
|
|
||||||
|
|
||||||
use winit::{
|
|
||||||
dpi::LogicalSize,
|
|
||||||
event::{Event, KeyEvent, WindowEvent},
|
|
||||||
event_loop::{ActiveEventLoop, EventLoopProxy},
|
|
||||||
};
|
|
||||||
|
|
||||||
use crate::{
|
|
||||||
emulator::{SimId, VBKey},
|
|
||||||
input::MappingProvider,
|
|
||||||
};
|
|
||||||
|
|
||||||
use super::{
|
|
||||||
common::{ImguiState, UiExt, WindowState, WindowStateBuilder},
|
|
||||||
AppWindow, UserEvent,
|
|
||||||
};
|
|
||||||
|
|
||||||
pub struct InputWindow {
|
|
||||||
window: WindowState,
|
|
||||||
imgui: ImguiState,
|
|
||||||
mappings: MappingProvider,
|
|
||||||
proxy: EventLoopProxy<UserEvent>,
|
|
||||||
now_binding: Option<(SimId, VBKey)>,
|
|
||||||
}
|
|
||||||
|
|
||||||
const KEY_NAMES: [(VBKey, &str); 14] = [
|
|
||||||
(VBKey::LU, "Up"),
|
|
||||||
(VBKey::LD, "Down"),
|
|
||||||
(VBKey::LL, "Left"),
|
|
||||||
(VBKey::LR, "Right"),
|
|
||||||
(VBKey::SEL, "Select"),
|
|
||||||
(VBKey::STA, "Start"),
|
|
||||||
(VBKey::B, "B"),
|
|
||||||
(VBKey::A, "A"),
|
|
||||||
(VBKey::LT, "L-Trigger"),
|
|
||||||
(VBKey::RT, "R-Trigger"),
|
|
||||||
(VBKey::RU, "R-Up"),
|
|
||||||
(VBKey::RD, "R-Down"),
|
|
||||||
(VBKey::RL, "R-Left"),
|
|
||||||
(VBKey::RR, "R-Right"),
|
|
||||||
];
|
|
||||||
|
|
||||||
impl InputWindow {
|
|
||||||
pub fn new(
|
|
||||||
event_loop: &ActiveEventLoop,
|
|
||||||
mappings: MappingProvider,
|
|
||||||
proxy: EventLoopProxy<UserEvent>,
|
|
||||||
) -> Self {
|
|
||||||
let window = WindowStateBuilder::new(event_loop)
|
|
||||||
.with_title("Bind Inputs")
|
|
||||||
.with_inner_size(LogicalSize::new(600, 400))
|
|
||||||
.build();
|
|
||||||
let imgui = ImguiState::new(&window);
|
|
||||||
Self {
|
|
||||||
window,
|
|
||||||
imgui,
|
|
||||||
mappings,
|
|
||||||
now_binding: None,
|
|
||||||
proxy,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fn draw(&mut self) {
|
|
||||||
let window = &mut self.window;
|
|
||||||
let imgui = &mut self.imgui;
|
|
||||||
let mut context = imgui.context.lock().unwrap();
|
|
||||||
|
|
||||||
let now = Instant::now();
|
|
||||||
context.io_mut().update_delta_time(now - imgui.last_frame);
|
|
||||||
imgui.last_frame = now;
|
|
||||||
|
|
||||||
let frame = match window.surface.get_current_texture() {
|
|
||||||
Ok(frame) => frame,
|
|
||||||
Err(e) => {
|
|
||||||
if !self.window.minimized {
|
|
||||||
eprintln!("dropped frame: {e:?}");
|
|
||||||
}
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
};
|
|
||||||
imgui
|
|
||||||
.platform
|
|
||||||
.prepare_frame(context.io_mut(), &window.window)
|
|
||||||
.expect("Failed to prepare frame");
|
|
||||||
let ui = context.new_frame();
|
|
||||||
|
|
||||||
let mut render_key_bindings = |sim_id: SimId| {
|
|
||||||
let mappings = self.mappings.for_sim(sim_id);
|
|
||||||
if let Some(table) = ui.begin_table("controls", 2) {
|
|
||||||
let binding_names = {
|
|
||||||
let mapping = mappings.read().unwrap();
|
|
||||||
mapping.keyboard_mapping_names()
|
|
||||||
};
|
|
||||||
ui.table_next_row();
|
|
||||||
|
|
||||||
for (key, name) in KEY_NAMES {
|
|
||||||
let binding = binding_names.get(&key).map(|s| s.as_str());
|
|
||||||
ui.table_next_column();
|
|
||||||
let [space, _] = ui.content_region_avail();
|
|
||||||
ui.group(|| {
|
|
||||||
ui.right_align_text(name, space * 0.20);
|
|
||||||
ui.same_line();
|
|
||||||
let label_text = if self.now_binding == Some((sim_id, key)) {
|
|
||||||
"Press any input"
|
|
||||||
} else {
|
|
||||||
binding.unwrap_or("")
|
|
||||||
};
|
|
||||||
let label = format!("{}##{}", label_text, name);
|
|
||||||
if ui.button_with_size(label, [space * 0.60, 0.0]) {
|
|
||||||
self.now_binding = Some((sim_id, key));
|
|
||||||
}
|
|
||||||
});
|
|
||||||
ui.same_line();
|
|
||||||
if ui.button(format!("Clear##{name}")) {
|
|
||||||
let mut mapping = mappings.write().unwrap();
|
|
||||||
mapping.clear_keyboard_mappings(key);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
table.end();
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
if let Some(window) = ui.fullscreen_window() {
|
|
||||||
if let Some(tabs) = ui.tab_bar("tabs") {
|
|
||||||
if let Some(tab) = ui.tab_item("Player 1") {
|
|
||||||
render_key_bindings(SimId::Player1);
|
|
||||||
tab.end();
|
|
||||||
}
|
|
||||||
if let Some(tab) = ui.tab_item("Player 2") {
|
|
||||||
render_key_bindings(SimId::Player2);
|
|
||||||
tab.end();
|
|
||||||
}
|
|
||||||
tabs.end();
|
|
||||||
}
|
|
||||||
window.end();
|
|
||||||
}
|
|
||||||
let mut encoder: wgpu::CommandEncoder = window
|
|
||||||
.device
|
|
||||||
.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
|
|
||||||
|
|
||||||
if imgui.last_cursor != ui.mouse_cursor() {
|
|
||||||
imgui.last_cursor = ui.mouse_cursor();
|
|
||||||
imgui.platform.prepare_render(ui, &window.window);
|
|
||||||
}
|
|
||||||
|
|
||||||
let view = frame
|
|
||||||
.texture
|
|
||||||
.create_view(&wgpu::TextureViewDescriptor::default());
|
|
||||||
let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
|
|
||||||
label: None,
|
|
||||||
color_attachments: &[Some(wgpu::RenderPassColorAttachment {
|
|
||||||
view: &view,
|
|
||||||
resolve_target: None,
|
|
||||||
ops: wgpu::Operations {
|
|
||||||
load: wgpu::LoadOp::Clear(imgui.clear_color),
|
|
||||||
store: wgpu::StoreOp::Store,
|
|
||||||
},
|
|
||||||
})],
|
|
||||||
depth_stencil_attachment: None,
|
|
||||||
timestamp_writes: None,
|
|
||||||
occlusion_query_set: None,
|
|
||||||
});
|
|
||||||
|
|
||||||
// Draw the game
|
|
||||||
imgui
|
|
||||||
.renderer
|
|
||||||
.render(context.render(), &window.queue, &window.device, &mut rpass)
|
|
||||||
.expect("Rendering failed");
|
|
||||||
|
|
||||||
drop(rpass);
|
|
||||||
|
|
||||||
window.queue.submit(Some(encoder.finish()));
|
|
||||||
|
|
||||||
frame.present();
|
|
||||||
}
|
|
||||||
|
|
||||||
fn try_bind_key(&mut self, event: &KeyEvent) {
|
|
||||||
if !event.state.is_pressed() {
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
let Some((sim_id, vb)) = self.now_binding.take() else {
|
|
||||||
return;
|
|
||||||
};
|
|
||||||
let mut mappings = self.mappings.for_sim(sim_id).write().unwrap();
|
|
||||||
mappings.add_keyboard_mapping(vb, event.physical_key);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl AppWindow for InputWindow {
|
|
||||||
fn id(&self) -> winit::window::WindowId {
|
|
||||||
self.window.window.id()
|
|
||||||
}
|
|
||||||
|
|
||||||
fn handle_event(&mut self, _: &ActiveEventLoop, event: &Event<UserEvent>) {
|
|
||||||
match event {
|
|
||||||
Event::WindowEvent { event, .. } => match event {
|
|
||||||
WindowEvent::Resized(size) => self.window.handle_resize(size),
|
|
||||||
WindowEvent::CloseRequested => {
|
|
||||||
self.proxy.send_event(UserEvent::Close(self.id())).unwrap()
|
|
||||||
}
|
|
||||||
WindowEvent::KeyboardInput { event, .. } => self.try_bind_key(event),
|
|
||||||
WindowEvent::RedrawRequested => self.draw(),
|
|
||||||
_ => (),
|
|
||||||
},
|
|
||||||
Event::AboutToWait => {
|
|
||||||
self.window.window.request_redraw();
|
|
||||||
}
|
|
||||||
_ => (),
|
|
||||||
}
|
|
||||||
|
|
||||||
let window = &self.window;
|
|
||||||
let imgui = &mut self.imgui;
|
|
||||||
let mut context = imgui.context.lock().unwrap();
|
|
||||||
imgui
|
|
||||||
.platform
|
|
||||||
.handle_event(context.io_mut(), &window.window, event);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -0,0 +1,315 @@
|
||||||
|
use std::{
|
||||||
|
collections::{hash_map::Entry, HashMap, HashSet},
|
||||||
|
num::NonZero,
|
||||||
|
sync::Arc,
|
||||||
|
};
|
||||||
|
|
||||||
|
use winit::event_loop::EventLoopProxy;
|
||||||
|
|
||||||
|
use crate::{emulator::EmulatorClient, window::WindowManager};
|
||||||
|
|
||||||
|
pub struct Application {
|
||||||
|
client: EmulatorClient,
|
||||||
|
proxy: EventLoopProxy<UserEvent>,
|
||||||
|
state: Option<AppState>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Application {
|
||||||
|
pub fn new(client: EmulatorClient, proxy: EventLoopProxy<UserEvent>) -> Self {
|
||||||
|
Self {
|
||||||
|
client,
|
||||||
|
proxy,
|
||||||
|
state: None,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl winit::application::ApplicationHandler<UserEvent> for Application {
|
||||||
|
fn resumed(&mut self, event_loop: &winit::event_loop::ActiveEventLoop) {
|
||||||
|
self.state = Some(AppState::new(
|
||||||
|
self.client.clone(),
|
||||||
|
self.proxy.clone(),
|
||||||
|
event_loop,
|
||||||
|
));
|
||||||
|
}
|
||||||
|
|
||||||
|
fn window_event(
|
||||||
|
&mut self,
|
||||||
|
event_loop: &winit::event_loop::ActiveEventLoop,
|
||||||
|
window_id: winit::window::WindowId,
|
||||||
|
event: winit::event::WindowEvent,
|
||||||
|
) {
|
||||||
|
self.state
|
||||||
|
.as_mut()
|
||||||
|
.unwrap()
|
||||||
|
.window_event(event_loop, window_id, event);
|
||||||
|
}
|
||||||
|
|
||||||
|
fn device_event(
|
||||||
|
&mut self,
|
||||||
|
_event_loop: &winit::event_loop::ActiveEventLoop,
|
||||||
|
_device_id: winit::event::DeviceId,
|
||||||
|
event: winit::event::DeviceEvent,
|
||||||
|
) {
|
||||||
|
self.state.as_mut().unwrap().device_event(event)
|
||||||
|
}
|
||||||
|
|
||||||
|
fn user_event(&mut self, _event_loop: &winit::event_loop::ActiveEventLoop, event: UserEvent) {
|
||||||
|
self.state.as_mut().unwrap().user_event(event);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
struct AppState {
|
||||||
|
painter: egui_wgpu::winit::Painter,
|
||||||
|
ctx: egui::Context,
|
||||||
|
viewports: HashMap<egui::ViewportId, ViewportState>,
|
||||||
|
viewports_by_window: HashMap<winit::window::WindowId, egui::ViewportId>,
|
||||||
|
focused: Option<egui::ViewportId>,
|
||||||
|
screen: WindowManager,
|
||||||
|
}
|
||||||
|
impl AppState {
|
||||||
|
fn new(
|
||||||
|
client: EmulatorClient,
|
||||||
|
proxy: EventLoopProxy<UserEvent>,
|
||||||
|
event_loop: &winit::event_loop::ActiveEventLoop,
|
||||||
|
) -> Self {
|
||||||
|
let mut painter = egui_wgpu::winit::Painter::new(
|
||||||
|
egui_wgpu::WgpuConfiguration::default(),
|
||||||
|
1,
|
||||||
|
None,
|
||||||
|
false,
|
||||||
|
true,
|
||||||
|
);
|
||||||
|
let ctx = egui::Context::default();
|
||||||
|
ctx.style_mut(|s| {
|
||||||
|
s.wrap_mode = Some(egui::TextWrapMode::Extend);
|
||||||
|
s.visuals.menu_rounding = Default::default();
|
||||||
|
});
|
||||||
|
ctx.set_embed_viewports(false);
|
||||||
|
{
|
||||||
|
let proxy = proxy.clone();
|
||||||
|
ctx.set_request_repaint_callback(move |info| {
|
||||||
|
proxy.send_event(UserEvent::RepaintRequested(info)).unwrap();
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
let mut screen = WindowManager::new(client, proxy);
|
||||||
|
let root_viewport = ViewportState::new(
|
||||||
|
egui::ViewportId::ROOT,
|
||||||
|
&ctx,
|
||||||
|
event_loop,
|
||||||
|
screen.initial_viewport(),
|
||||||
|
&mut painter,
|
||||||
|
);
|
||||||
|
screen.init_renderer(painter.render_state().as_ref().unwrap());
|
||||||
|
|
||||||
|
let mut viewports_by_window = HashMap::new();
|
||||||
|
viewports_by_window.insert(root_viewport.window.id(), egui::ViewportId::ROOT);
|
||||||
|
let mut viewports = HashMap::new();
|
||||||
|
viewports.insert(egui::ViewportId::ROOT, root_viewport);
|
||||||
|
|
||||||
|
Self {
|
||||||
|
painter,
|
||||||
|
ctx,
|
||||||
|
viewports,
|
||||||
|
viewports_by_window,
|
||||||
|
focused: Some(egui::ViewportId::ROOT),
|
||||||
|
screen,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn window_event(
|
||||||
|
&mut self,
|
||||||
|
event_loop: &winit::event_loop::ActiveEventLoop,
|
||||||
|
window_id: winit::window::WindowId,
|
||||||
|
event: winit::event::WindowEvent,
|
||||||
|
) {
|
||||||
|
let Some(&viewport_id) = self.viewports_by_window.get(&window_id) else {
|
||||||
|
return;
|
||||||
|
};
|
||||||
|
let Some(viewport) = self.viewports.get_mut(&viewport_id) else {
|
||||||
|
panic!("Unrecognized viewport");
|
||||||
|
};
|
||||||
|
viewport.on_window_event(&event);
|
||||||
|
|
||||||
|
match event {
|
||||||
|
winit::event::WindowEvent::KeyboardInput { event, .. } => {
|
||||||
|
self.screen.handle_key_event(event);
|
||||||
|
}
|
||||||
|
winit::event::WindowEvent::RedrawRequested => {
|
||||||
|
pollster::block_on(
|
||||||
|
self.painter
|
||||||
|
.set_window(viewport_id, Some(viewport.window.clone())),
|
||||||
|
)
|
||||||
|
.unwrap();
|
||||||
|
let cb = viewport.viewport_ui_cb.clone();
|
||||||
|
let mut input = viewport.state.take_egui_input(&viewport.window);
|
||||||
|
input.viewports = self
|
||||||
|
.viewports
|
||||||
|
.iter()
|
||||||
|
.map(|(k, v)| (*k, v.info.clone()))
|
||||||
|
.collect();
|
||||||
|
let output = self.ctx.run(input, |ctx| {
|
||||||
|
if let Some(cb) = cb.as_deref() {
|
||||||
|
cb(ctx)
|
||||||
|
} else {
|
||||||
|
self.screen.show(ctx)
|
||||||
|
}
|
||||||
|
});
|
||||||
|
let clipped_primitives =
|
||||||
|
self.ctx.tessellate(output.shapes, output.pixels_per_point);
|
||||||
|
self.painter.paint_and_update_textures(
|
||||||
|
viewport_id,
|
||||||
|
output.pixels_per_point,
|
||||||
|
[0.0, 0.0, 0.0, 0.0],
|
||||||
|
&clipped_primitives,
|
||||||
|
&output.textures_delta,
|
||||||
|
false,
|
||||||
|
);
|
||||||
|
|
||||||
|
let mut live_viewports = HashSet::default();
|
||||||
|
for (id, output) in output.viewport_output {
|
||||||
|
live_viewports.insert(id);
|
||||||
|
let viewport = match self.viewports.entry(id) {
|
||||||
|
Entry::Occupied(e) => e.into_mut(),
|
||||||
|
Entry::Vacant(e) => {
|
||||||
|
let mut v = ViewportState::new(
|
||||||
|
id,
|
||||||
|
&self.ctx,
|
||||||
|
event_loop,
|
||||||
|
output.builder,
|
||||||
|
&mut self.painter,
|
||||||
|
);
|
||||||
|
v.viewport_ui_cb = output.viewport_ui_cb;
|
||||||
|
self.viewports_by_window.insert(v.window.id(), id);
|
||||||
|
e.insert(v)
|
||||||
|
}
|
||||||
|
};
|
||||||
|
egui_winit::process_viewport_commands(
|
||||||
|
&self.ctx,
|
||||||
|
&mut viewport.info,
|
||||||
|
output.commands,
|
||||||
|
&viewport.window,
|
||||||
|
&mut HashSet::default(),
|
||||||
|
);
|
||||||
|
if viewport.info.close_requested() {
|
||||||
|
live_viewports.remove(&id);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
self.viewports.retain(|k, v| {
|
||||||
|
if live_viewports.contains(k) {
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
self.viewports_by_window.remove(&v.window.id());
|
||||||
|
false
|
||||||
|
});
|
||||||
|
self.painter.gc_viewports(&live_viewports);
|
||||||
|
if !self.viewports.contains_key(&egui::ViewportId::ROOT) {
|
||||||
|
event_loop.exit();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
winit::event::WindowEvent::Resized(size) => {
|
||||||
|
let (Some(width), Some(height)) =
|
||||||
|
(NonZero::new(size.width), NonZero::new(size.height))
|
||||||
|
else {
|
||||||
|
return;
|
||||||
|
};
|
||||||
|
self.painter.on_window_resized(viewport_id, width, height);
|
||||||
|
}
|
||||||
|
winit::event::WindowEvent::Focused(new_focused) => {
|
||||||
|
self.focused = new_focused.then_some(viewport_id);
|
||||||
|
}
|
||||||
|
winit::event::WindowEvent::CloseRequested => {
|
||||||
|
if viewport_id == egui::ViewportId::ROOT {
|
||||||
|
event_loop.exit();
|
||||||
|
} else if let Some(viewport) = self.viewports.get_mut(&viewport_id) {
|
||||||
|
viewport.info.events.push(egui::ViewportEvent::Close);
|
||||||
|
self.ctx.request_repaint_of(viewport_id);
|
||||||
|
self.ctx.request_repaint_of(egui::ViewportId::ROOT);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
_ => {}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn device_event(&mut self, 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: UserEvent) {
|
||||||
|
match event {
|
||||||
|
UserEvent::GamepadEvent(event) => self.screen.handle_gamepad_event(event),
|
||||||
|
UserEvent::RepaintRequested(info) => {
|
||||||
|
let Some(viewport) = self.viewports.get(&info.viewport_id) else {
|
||||||
|
return;
|
||||||
|
};
|
||||||
|
viewport.window.request_redraw();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
struct ViewportState {
|
||||||
|
info: egui::ViewportInfo,
|
||||||
|
state: egui_winit::State,
|
||||||
|
viewport_ui_cb: Option<Arc<egui::DeferredViewportUiCallback>>,
|
||||||
|
window: Arc<winit::window::Window>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl ViewportState {
|
||||||
|
fn new(
|
||||||
|
id: egui::ViewportId,
|
||||||
|
ctx: &egui::Context,
|
||||||
|
event_loop: &winit::event_loop::ActiveEventLoop,
|
||||||
|
viewport: egui::ViewportBuilder,
|
||||||
|
painter: &mut egui_wgpu::winit::Painter,
|
||||||
|
) -> Self {
|
||||||
|
let mut info = egui::ViewportInfo::default();
|
||||||
|
let window = Arc::new(egui_winit::create_window(ctx, event_loop, &viewport).unwrap());
|
||||||
|
egui_winit::update_viewport_info(&mut info, ctx, &window, true);
|
||||||
|
|
||||||
|
pollster::block_on(painter.set_window(id, Some(window.clone()))).unwrap();
|
||||||
|
let state = egui_winit::State::new(
|
||||||
|
ctx.clone(),
|
||||||
|
id,
|
||||||
|
event_loop,
|
||||||
|
Some(window.scale_factor() as f32),
|
||||||
|
event_loop.system_theme(),
|
||||||
|
painter.max_texture_side(),
|
||||||
|
);
|
||||||
|
Self {
|
||||||
|
info,
|
||||||
|
state,
|
||||||
|
viewport_ui_cb: None,
|
||||||
|
window,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn on_window_event(&mut self, event: &winit::event::WindowEvent) {
|
||||||
|
let response = self.state.on_window_event(&self.window, event);
|
||||||
|
if response.repaint {
|
||||||
|
self.window.request_redraw();
|
||||||
|
}
|
||||||
|
egui_winit::update_viewport_info(
|
||||||
|
&mut self.info,
|
||||||
|
self.state.egui_ctx(),
|
||||||
|
&self.window,
|
||||||
|
false,
|
||||||
|
);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub enum UserEvent {
|
||||||
|
GamepadEvent(gilrs::Event),
|
||||||
|
RepaintRequested(egui::RequestRepaintInfo),
|
||||||
|
}
|
||||||
|
|
@ -1,18 +1,19 @@
|
||||||
use std::{path::PathBuf, process};
|
use std::{path::PathBuf, process};
|
||||||
|
|
||||||
use anyhow::Result;
|
use anyhow::Result;
|
||||||
use app::App;
|
use application::Application;
|
||||||
use clap::Parser;
|
use clap::Parser;
|
||||||
use emulator::EmulatorBuilder;
|
use emulator::EmulatorBuilder;
|
||||||
use thread_priority::{ThreadBuilder, ThreadPriority};
|
use thread_priority::{ThreadBuilder, ThreadPriority};
|
||||||
use winit::event_loop::{ControlFlow, EventLoop};
|
use winit::event_loop::{ControlFlow, EventLoop};
|
||||||
|
|
||||||
mod app;
|
mod application;
|
||||||
mod audio;
|
mod audio;
|
||||||
mod controller;
|
mod controller;
|
||||||
mod emulator;
|
mod emulator;
|
||||||
mod graphics;
|
mod graphics;
|
||||||
mod input;
|
mod input;
|
||||||
|
mod window;
|
||||||
|
|
||||||
#[derive(Parser)]
|
#[derive(Parser)]
|
||||||
struct Args {
|
struct Args {
|
||||||
|
|
@ -56,6 +57,6 @@ fn main() -> Result<()> {
|
||||||
let event_loop = EventLoop::with_user_event().build().unwrap();
|
let event_loop = EventLoop::with_user_event().build().unwrap();
|
||||||
event_loop.set_control_flow(ControlFlow::Poll);
|
event_loop.set_control_flow(ControlFlow::Poll);
|
||||||
let proxy = event_loop.create_proxy();
|
let proxy = event_loop.create_proxy();
|
||||||
event_loop.run_app(&mut App::new(client, proxy))?;
|
event_loop.run_app(&mut Application::new(client, proxy))?;
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -0,0 +1,157 @@
|
||||||
|
use std::{
|
||||||
|
sync::{
|
||||||
|
atomic::{AtomicBool, Ordering},
|
||||||
|
Arc, Mutex,
|
||||||
|
},
|
||||||
|
thread,
|
||||||
|
};
|
||||||
|
|
||||||
|
use egui::{Context, ViewportBuilder, ViewportId};
|
||||||
|
use game::GameWindow;
|
||||||
|
use game_screen::GameScreen;
|
||||||
|
use gilrs::{EventType, Gilrs};
|
||||||
|
use input::InputWindow;
|
||||||
|
use winit::{event::KeyEvent, event_loop::EventLoopProxy};
|
||||||
|
|
||||||
|
use crate::{
|
||||||
|
application::UserEvent,
|
||||||
|
controller::ControllerManager,
|
||||||
|
emulator::{EmulatorClient, EmulatorCommand, SimId},
|
||||||
|
input::MappingProvider,
|
||||||
|
};
|
||||||
|
|
||||||
|
mod game;
|
||||||
|
mod game_screen;
|
||||||
|
mod input;
|
||||||
|
|
||||||
|
pub struct WindowManager {
|
||||||
|
p1: GameWindow,
|
||||||
|
p2: Arc<Mutex<GameWindow>>,
|
||||||
|
client: EmulatorClient,
|
||||||
|
input: ChildWindow<InputWindow>,
|
||||||
|
controllers: ControllerManager,
|
||||||
|
}
|
||||||
|
impl WindowManager {
|
||||||
|
pub fn new(client: EmulatorClient, proxy: EventLoopProxy<UserEvent>) -> Self {
|
||||||
|
let mappings = MappingProvider::new();
|
||||||
|
let controllers = ControllerManager::new(client.clone(), &mappings);
|
||||||
|
{
|
||||||
|
let mappings = mappings.clone();
|
||||||
|
thread::spawn(|| process_gamepad_input(mappings, proxy));
|
||||||
|
}
|
||||||
|
let input = ChildWindow::new(InputWindow::new(mappings));
|
||||||
|
let p1 = GameWindow::new(client.clone(), SimId::Player1, input.open.clone());
|
||||||
|
let p2 = GameWindow::new(client.clone(), SimId::Player2, input.open.clone());
|
||||||
|
Self {
|
||||||
|
p1,
|
||||||
|
p2: Arc::new(Mutex::new(p2)),
|
||||||
|
client,
|
||||||
|
input,
|
||||||
|
controllers,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn init_renderer(&mut self, render_state: &egui_wgpu::RenderState) {
|
||||||
|
GameScreen::init_pipeline(render_state);
|
||||||
|
self.p2.lock().unwrap().init_renderer(render_state);
|
||||||
|
self.p1.init_renderer(render_state);
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn initial_viewport(&self) -> ViewportBuilder {
|
||||||
|
self.p1.initial_viewport()
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn show(&mut self, ctx: &Context) {
|
||||||
|
self.p1.show(ctx);
|
||||||
|
self.input.show(ctx);
|
||||||
|
if self.client.has_player_2() {
|
||||||
|
let (viewport_id, viewport) = {
|
||||||
|
let p2 = self.p2.lock().unwrap();
|
||||||
|
(p2.viewport_id(), p2.initial_viewport())
|
||||||
|
};
|
||||||
|
let client = self.client.clone();
|
||||||
|
let p2 = self.p2.clone();
|
||||||
|
ctx.show_viewport_deferred(viewport_id, viewport, move |ctx, _| {
|
||||||
|
p2.lock().unwrap().show(ctx);
|
||||||
|
if ctx.input(|i| i.viewport().close_requested()) {
|
||||||
|
client.send_command(EmulatorCommand::StopSecondSim);
|
||||||
|
}
|
||||||
|
});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn handle_key_event(&mut self, event: winit::event::KeyEvent) {
|
||||||
|
self.controllers.handle_key_event(&event);
|
||||||
|
self.input.handle_key_event(&event);
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn handle_gamepad_event(&mut self, event: gilrs::Event) {
|
||||||
|
self.controllers.handle_gamepad_event(&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;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
trait AppWindow {
|
||||||
|
fn viewport_id(&self) -> ViewportId;
|
||||||
|
fn initial_viewport(&self) -> ViewportBuilder;
|
||||||
|
fn show(&mut self, ctx: &Context);
|
||||||
|
fn handle_key_event(&mut self, event: &KeyEvent) {
|
||||||
|
let _ = event;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
struct ChildWindow<T: AppWindow> {
|
||||||
|
pub open: Arc<AtomicBool>,
|
||||||
|
window: Arc<Mutex<T>>,
|
||||||
|
}
|
||||||
|
impl<T: AppWindow + Send + 'static> ChildWindow<T> {
|
||||||
|
fn new(window: T) -> Self {
|
||||||
|
Self {
|
||||||
|
open: Arc::new(AtomicBool::new(false)),
|
||||||
|
window: Arc::new(Mutex::new(window)),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn show(&self, ctx: &Context) {
|
||||||
|
if !self.open.load(Ordering::Relaxed) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
let (viewport_id, viewport) = {
|
||||||
|
let window = self.window.lock().unwrap();
|
||||||
|
(window.viewport_id(), window.initial_viewport())
|
||||||
|
};
|
||||||
|
let open = self.open.clone();
|
||||||
|
let window = self.window.clone();
|
||||||
|
ctx.show_viewport_deferred(viewport_id, viewport, move |ctx, _| {
|
||||||
|
window.lock().unwrap().show(ctx);
|
||||||
|
if ctx.input(|i| i.viewport().close_requested()) {
|
||||||
|
open.store(false, Ordering::Relaxed);
|
||||||
|
ctx.request_repaint();
|
||||||
|
}
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
fn handle_key_event(&self, event: &KeyEvent) {
|
||||||
|
if self.open.load(Ordering::Relaxed) {
|
||||||
|
self.window.lock().unwrap().handle_key_event(event);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,174 @@
|
||||||
|
use std::sync::{
|
||||||
|
atomic::{AtomicBool, Ordering},
|
||||||
|
Arc,
|
||||||
|
};
|
||||||
|
|
||||||
|
use crate::emulator::{EmulatorClient, EmulatorCommand, SimId};
|
||||||
|
use egui::{
|
||||||
|
menu, Button, CentralPanel, Color32, Context, Response, TopBottomPanel, Ui, ViewportBuilder,
|
||||||
|
ViewportCommand, ViewportId, WidgetText,
|
||||||
|
};
|
||||||
|
|
||||||
|
use super::{game_screen::GameScreen, AppWindow};
|
||||||
|
|
||||||
|
pub struct GameWindow {
|
||||||
|
client: EmulatorClient,
|
||||||
|
sim_id: SimId,
|
||||||
|
input_window_open: Arc<AtomicBool>,
|
||||||
|
screen: Option<GameScreen>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl GameWindow {
|
||||||
|
pub fn new(client: EmulatorClient, sim_id: SimId, input_window_open: Arc<AtomicBool>) -> Self {
|
||||||
|
Self {
|
||||||
|
client,
|
||||||
|
sim_id,
|
||||||
|
input_window_open,
|
||||||
|
screen: None,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn init_renderer(&mut self, render_state: &egui_wgpu::RenderState) {
|
||||||
|
let (screen, sink) = GameScreen::init(render_state);
|
||||||
|
self.client
|
||||||
|
.send_command(EmulatorCommand::SetRenderer(self.sim_id, sink));
|
||||||
|
self.screen = Some(screen)
|
||||||
|
}
|
||||||
|
|
||||||
|
fn show_menu(&mut self, ctx: &Context, ui: &mut Ui) {
|
||||||
|
ui.menu_button("ROM", |ui| {
|
||||||
|
if ui.button("Open ROM").clicked() {
|
||||||
|
let rom = rfd::FileDialog::new()
|
||||||
|
.add_filter("Virtual Boy ROMs", &["vb", "vbrom"])
|
||||||
|
.pick_file();
|
||||||
|
if let Some(path) = rom {
|
||||||
|
self.client
|
||||||
|
.send_command(EmulatorCommand::LoadGame(SimId::Player1, path));
|
||||||
|
}
|
||||||
|
ui.close_menu();
|
||||||
|
}
|
||||||
|
if ui.button("Quit").clicked() {
|
||||||
|
ctx.send_viewport_cmd(ViewportCommand::Close);
|
||||||
|
}
|
||||||
|
});
|
||||||
|
ui.menu_button("Emulation", |ui| {
|
||||||
|
let has_game = self.client.has_game(self.sim_id);
|
||||||
|
if self.client.is_running(self.sim_id) {
|
||||||
|
if ui.add_enabled(has_game, Button::new("Pause")).clicked() {
|
||||||
|
self.client.send_command(EmulatorCommand::Pause);
|
||||||
|
ui.close_menu();
|
||||||
|
}
|
||||||
|
} else if ui.add_enabled(has_game, Button::new("Resume")).clicked() {
|
||||||
|
self.client.send_command(EmulatorCommand::Resume);
|
||||||
|
ui.close_menu();
|
||||||
|
}
|
||||||
|
if ui.add_enabled(has_game, Button::new("Reset")).clicked() {
|
||||||
|
self.client
|
||||||
|
.send_command(EmulatorCommand::Reset(self.sim_id));
|
||||||
|
ui.close_menu();
|
||||||
|
}
|
||||||
|
});
|
||||||
|
ui.menu_button("Video", |ui| {
|
||||||
|
let current_dims = ctx.input(|i| i.viewport().inner_rect.unwrap());
|
||||||
|
let current_dims = current_dims.max - current_dims.min;
|
||||||
|
|
||||||
|
for scale in 1..=4 {
|
||||||
|
let label = format!("x{scale}");
|
||||||
|
let scale = scale as f32;
|
||||||
|
let dims = (384.0 * scale, 224.0 * scale + 20.0).into();
|
||||||
|
if ui
|
||||||
|
.selectable_button((current_dims - dims).length() < 1.0, label)
|
||||||
|
.clicked()
|
||||||
|
{
|
||||||
|
ctx.send_viewport_cmd(ViewportCommand::InnerSize(dims));
|
||||||
|
ui.close_menu();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
});
|
||||||
|
ui.menu_button("Audio", |ui| {
|
||||||
|
let p1_enabled = self.client.is_audio_enabled(SimId::Player1);
|
||||||
|
let p2_enabled = self.client.is_audio_enabled(SimId::Player2);
|
||||||
|
if ui.selectable_button(p1_enabled, "Player 1").clicked() {
|
||||||
|
self.client
|
||||||
|
.send_command(EmulatorCommand::SetAudioEnabled(!p1_enabled, p2_enabled));
|
||||||
|
ui.close_menu();
|
||||||
|
}
|
||||||
|
if ui.selectable_button(p2_enabled, "Player 2").clicked() {
|
||||||
|
self.client
|
||||||
|
.send_command(EmulatorCommand::SetAudioEnabled(p1_enabled, !p2_enabled));
|
||||||
|
ui.close_menu();
|
||||||
|
}
|
||||||
|
});
|
||||||
|
ui.menu_button("Input", |ui| {
|
||||||
|
if ui.button("Bind Inputs").clicked() {
|
||||||
|
self.input_window_open.store(true, Ordering::Relaxed);
|
||||||
|
ui.close_menu();
|
||||||
|
}
|
||||||
|
});
|
||||||
|
ui.menu_button("Multiplayer", |ui| {
|
||||||
|
if self.sim_id == SimId::Player1
|
||||||
|
&& !self.client.has_player_2()
|
||||||
|
&& ui.button("Open Player 2").clicked()
|
||||||
|
{
|
||||||
|
self.client
|
||||||
|
.send_command(EmulatorCommand::StartSecondSim(None));
|
||||||
|
ui.close_menu();
|
||||||
|
}
|
||||||
|
if self.client.has_player_2() {
|
||||||
|
let linked = self.client.are_sims_linked();
|
||||||
|
if linked && ui.button("Unlink").clicked() {
|
||||||
|
self.client.send_command(EmulatorCommand::Unlink);
|
||||||
|
ui.close_menu();
|
||||||
|
}
|
||||||
|
if !linked && ui.button("Link").clicked() {
|
||||||
|
self.client.send_command(EmulatorCommand::Link);
|
||||||
|
ui.close_menu();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl AppWindow for GameWindow {
|
||||||
|
fn viewport_id(&self) -> ViewportId {
|
||||||
|
match self.sim_id {
|
||||||
|
SimId::Player1 => ViewportId::ROOT,
|
||||||
|
SimId::Player2 => ViewportId::from_hash_of("Player2"),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn initial_viewport(&self) -> ViewportBuilder {
|
||||||
|
ViewportBuilder::default()
|
||||||
|
.with_title("Shrooms VB")
|
||||||
|
.with_inner_size((384.0, 244.0))
|
||||||
|
}
|
||||||
|
|
||||||
|
fn show(&mut self, ctx: &Context) {
|
||||||
|
TopBottomPanel::top("menubar")
|
||||||
|
.exact_height(20.0)
|
||||||
|
.show(ctx, |ui| {
|
||||||
|
menu::bar(ui, |ui| {
|
||||||
|
self.show_menu(ctx, ui);
|
||||||
|
});
|
||||||
|
});
|
||||||
|
CentralPanel::default().show(ctx, |ui| {
|
||||||
|
if let Some(screen) = self.screen.as_ref() {
|
||||||
|
ui.add(screen);
|
||||||
|
}
|
||||||
|
});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
trait UiExt {
|
||||||
|
fn selectable_button(&mut self, selected: bool, text: impl Into<WidgetText>) -> Response;
|
||||||
|
}
|
||||||
|
|
||||||
|
impl UiExt for Ui {
|
||||||
|
fn selectable_button(&mut self, selected: bool, text: impl Into<WidgetText>) -> Response {
|
||||||
|
self.style_mut().visuals.widgets.inactive.bg_fill = Color32::TRANSPARENT;
|
||||||
|
self.style_mut().visuals.widgets.hovered.bg_fill = Color32::TRANSPARENT;
|
||||||
|
self.style_mut().visuals.widgets.active.bg_fill = Color32::TRANSPARENT;
|
||||||
|
let mut selected = selected;
|
||||||
|
self.checkbox(&mut selected, text)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,194 @@
|
||||||
|
use std::sync::Arc;
|
||||||
|
|
||||||
|
use egui::Widget;
|
||||||
|
use wgpu::{util::DeviceExt as _, BindGroup, BindGroupLayout, RenderPipeline};
|
||||||
|
|
||||||
|
use crate::graphics::TextureSink;
|
||||||
|
|
||||||
|
pub struct GameScreen {
|
||||||
|
bind_group: Arc<BindGroup>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl GameScreen {
|
||||||
|
pub fn init_pipeline(render_state: &egui_wgpu::RenderState) {
|
||||||
|
let device = &render_state.device;
|
||||||
|
|
||||||
|
let bind_group_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
|
||||||
|
label: Some("texture bind group layout"),
|
||||||
|
entries: &[
|
||||||
|
wgpu::BindGroupLayoutEntry {
|
||||||
|
binding: 0,
|
||||||
|
visibility: wgpu::ShaderStages::FRAGMENT,
|
||||||
|
ty: wgpu::BindingType::Texture {
|
||||||
|
sample_type: wgpu::TextureSampleType::Float { filterable: true },
|
||||||
|
view_dimension: wgpu::TextureViewDimension::D2,
|
||||||
|
multisampled: false,
|
||||||
|
},
|
||||||
|
count: None,
|
||||||
|
},
|
||||||
|
wgpu::BindGroupLayoutEntry {
|
||||||
|
binding: 1,
|
||||||
|
visibility: wgpu::ShaderStages::FRAGMENT,
|
||||||
|
ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
|
||||||
|
count: None,
|
||||||
|
},
|
||||||
|
wgpu::BindGroupLayoutEntry {
|
||||||
|
binding: 2,
|
||||||
|
visibility: wgpu::ShaderStages::FRAGMENT,
|
||||||
|
ty: wgpu::BindingType::Buffer {
|
||||||
|
ty: wgpu::BufferBindingType::Uniform,
|
||||||
|
has_dynamic_offset: false,
|
||||||
|
min_binding_size: None,
|
||||||
|
},
|
||||||
|
count: None,
|
||||||
|
},
|
||||||
|
],
|
||||||
|
});
|
||||||
|
|
||||||
|
let shader = device.create_shader_module(wgpu::include_wgsl!("../anaglyph.wgsl"));
|
||||||
|
let render_pipeline_layout =
|
||||||
|
device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
|
||||||
|
label: Some("render pipeline layout"),
|
||||||
|
bind_group_layouts: &[&bind_group_layout],
|
||||||
|
push_constant_ranges: &[],
|
||||||
|
});
|
||||||
|
let render_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
|
||||||
|
label: Some("render pipeline"),
|
||||||
|
layout: Some(&render_pipeline_layout),
|
||||||
|
vertex: wgpu::VertexState {
|
||||||
|
module: &shader,
|
||||||
|
entry_point: "vs_main",
|
||||||
|
buffers: &[],
|
||||||
|
compilation_options: wgpu::PipelineCompilationOptions::default(),
|
||||||
|
},
|
||||||
|
fragment: Some(wgpu::FragmentState {
|
||||||
|
module: &shader,
|
||||||
|
entry_point: "fs_main",
|
||||||
|
targets: &[Some(wgpu::ColorTargetState {
|
||||||
|
format: wgpu::TextureFormat::Bgra8Unorm,
|
||||||
|
blend: Some(wgpu::BlendState::REPLACE),
|
||||||
|
write_mask: wgpu::ColorWrites::ALL,
|
||||||
|
})],
|
||||||
|
compilation_options: wgpu::PipelineCompilationOptions::default(),
|
||||||
|
}),
|
||||||
|
primitive: wgpu::PrimitiveState {
|
||||||
|
topology: wgpu::PrimitiveTopology::TriangleList,
|
||||||
|
strip_index_format: None,
|
||||||
|
front_face: wgpu::FrontFace::Ccw,
|
||||||
|
cull_mode: Some(wgpu::Face::Back),
|
||||||
|
polygon_mode: wgpu::PolygonMode::Fill,
|
||||||
|
unclipped_depth: false,
|
||||||
|
conservative: false,
|
||||||
|
},
|
||||||
|
depth_stencil: None,
|
||||||
|
multisample: wgpu::MultisampleState {
|
||||||
|
count: 1,
|
||||||
|
mask: !0,
|
||||||
|
alpha_to_coverage_enabled: false,
|
||||||
|
},
|
||||||
|
multiview: None,
|
||||||
|
cache: None,
|
||||||
|
});
|
||||||
|
|
||||||
|
render_state
|
||||||
|
.renderer
|
||||||
|
.write()
|
||||||
|
.callback_resources
|
||||||
|
.insert(SharedGameScreenResources {
|
||||||
|
pipeline: render_pipeline,
|
||||||
|
bind_group_layout,
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn init(render_state: &egui_wgpu::RenderState) -> (Self, TextureSink) {
|
||||||
|
let device = &render_state.device;
|
||||||
|
let queue = &render_state.queue;
|
||||||
|
|
||||||
|
let (sink, texture_view) = TextureSink::new(device, queue.clone());
|
||||||
|
let sampler = device.create_sampler(&wgpu::SamplerDescriptor::default());
|
||||||
|
let colors = Colors {
|
||||||
|
left: [1.0, 0.0, 0.0, 1.0],
|
||||||
|
right: [0.0, 0.7734375, 0.9375, 1.0],
|
||||||
|
};
|
||||||
|
|
||||||
|
let color_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
|
||||||
|
label: Some("colors"),
|
||||||
|
contents: bytemuck::bytes_of(&colors),
|
||||||
|
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
|
||||||
|
});
|
||||||
|
|
||||||
|
let renderer = render_state.renderer.read();
|
||||||
|
let resources: &SharedGameScreenResources = renderer.callback_resources.get().unwrap();
|
||||||
|
|
||||||
|
let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
|
||||||
|
label: Some("bind group"),
|
||||||
|
layout: &resources.bind_group_layout,
|
||||||
|
entries: &[
|
||||||
|
wgpu::BindGroupEntry {
|
||||||
|
binding: 0,
|
||||||
|
resource: wgpu::BindingResource::TextureView(&texture_view),
|
||||||
|
},
|
||||||
|
wgpu::BindGroupEntry {
|
||||||
|
binding: 1,
|
||||||
|
resource: wgpu::BindingResource::Sampler(&sampler),
|
||||||
|
},
|
||||||
|
wgpu::BindGroupEntry {
|
||||||
|
binding: 2,
|
||||||
|
resource: color_buf.as_entire_binding(),
|
||||||
|
},
|
||||||
|
],
|
||||||
|
});
|
||||||
|
|
||||||
|
(
|
||||||
|
Self {
|
||||||
|
bind_group: Arc::new(bind_group),
|
||||||
|
},
|
||||||
|
sink,
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Widget for &GameScreen {
|
||||||
|
fn ui(self, ui: &mut egui::Ui) -> egui::Response {
|
||||||
|
let response = ui.allocate_rect(ui.clip_rect(), egui::Sense::hover());
|
||||||
|
let callback = egui_wgpu::Callback::new_paint_callback(
|
||||||
|
response.rect,
|
||||||
|
GameScreenCallback {
|
||||||
|
bind_group: self.bind_group.clone(),
|
||||||
|
},
|
||||||
|
);
|
||||||
|
ui.painter().add(callback);
|
||||||
|
response
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
struct GameScreenCallback {
|
||||||
|
bind_group: Arc<BindGroup>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl egui_wgpu::CallbackTrait for GameScreenCallback {
|
||||||
|
fn paint(
|
||||||
|
&self,
|
||||||
|
_info: egui::PaintCallbackInfo,
|
||||||
|
render_pass: &mut wgpu::RenderPass<'static>,
|
||||||
|
callback_resources: &egui_wgpu::CallbackResources,
|
||||||
|
) {
|
||||||
|
let resources: &SharedGameScreenResources = callback_resources.get().unwrap();
|
||||||
|
// TODO: maintain aspect ratio
|
||||||
|
render_pass.set_pipeline(&resources.pipeline);
|
||||||
|
render_pass.set_bind_group(0, &self.bind_group, &[]);
|
||||||
|
render_pass.draw(0..6, 0..1);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
struct SharedGameScreenResources {
|
||||||
|
pipeline: RenderPipeline,
|
||||||
|
bind_group_layout: BindGroupLayout,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
|
||||||
|
#[repr(C)]
|
||||||
|
struct Colors {
|
||||||
|
left: [f32; 4],
|
||||||
|
right: [f32; 4],
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,133 @@
|
||||||
|
use egui::{
|
||||||
|
Button, CentralPanel, Context, Label, Layout, TopBottomPanel, Ui, ViewportBuilder, ViewportId,
|
||||||
|
};
|
||||||
|
use egui_extras::{Column, TableBuilder};
|
||||||
|
|
||||||
|
use crate::{
|
||||||
|
emulator::{SimId, VBKey},
|
||||||
|
input::MappingProvider,
|
||||||
|
};
|
||||||
|
|
||||||
|
use super::AppWindow;
|
||||||
|
|
||||||
|
pub struct InputWindow {
|
||||||
|
mappings: MappingProvider,
|
||||||
|
now_binding: Option<(SimId, VBKey)>,
|
||||||
|
active_tab: InputTab,
|
||||||
|
}
|
||||||
|
|
||||||
|
const KEY_NAMES: [(VBKey, &str); 14] = [
|
||||||
|
(VBKey::LU, "Up"),
|
||||||
|
(VBKey::LD, "Down"),
|
||||||
|
(VBKey::LL, "Left"),
|
||||||
|
(VBKey::LR, "Right"),
|
||||||
|
(VBKey::SEL, "Select"),
|
||||||
|
(VBKey::STA, "Start"),
|
||||||
|
(VBKey::B, "B"),
|
||||||
|
(VBKey::A, "A"),
|
||||||
|
(VBKey::LT, "L-Trigger"),
|
||||||
|
(VBKey::RT, "R-Trigger"),
|
||||||
|
(VBKey::RU, "R-Up"),
|
||||||
|
(VBKey::RD, "R-Down"),
|
||||||
|
(VBKey::RL, "R-Left"),
|
||||||
|
(VBKey::RR, "R-Right"),
|
||||||
|
];
|
||||||
|
|
||||||
|
impl InputWindow {
|
||||||
|
pub fn new(mappings: MappingProvider) -> Self {
|
||||||
|
Self {
|
||||||
|
mappings,
|
||||||
|
now_binding: None,
|
||||||
|
active_tab: InputTab::Player1,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn render_key_bindings(&mut self, ui: &mut Ui, sim_id: SimId) {
|
||||||
|
let mappings = self.mappings.for_sim(sim_id);
|
||||||
|
let binding_names = {
|
||||||
|
let mapping = mappings.read().unwrap();
|
||||||
|
mapping.keyboard_mapping_names()
|
||||||
|
};
|
||||||
|
TableBuilder::new(ui)
|
||||||
|
.column(Column::remainder())
|
||||||
|
.column(Column::remainder())
|
||||||
|
.cell_layout(Layout::left_to_right(egui::Align::Center))
|
||||||
|
.body(|mut body| {
|
||||||
|
for keys in KEY_NAMES.chunks_exact(2) {
|
||||||
|
body.row(20.0, |mut row| {
|
||||||
|
for (key, name) in keys {
|
||||||
|
let binding = binding_names.get(key).map(|s| s.as_str());
|
||||||
|
row.col(|ui| {
|
||||||
|
let size = ui.available_size_before_wrap();
|
||||||
|
let width = size.x;
|
||||||
|
let height = size.y;
|
||||||
|
ui.add_sized((width * 0.2, height), Label::new(*name));
|
||||||
|
let label_text = if self.now_binding == Some((sim_id, *key)) {
|
||||||
|
"Press any input"
|
||||||
|
} else {
|
||||||
|
binding.unwrap_or("")
|
||||||
|
};
|
||||||
|
if ui
|
||||||
|
.add_sized((width * 0.6, height), Button::new(label_text))
|
||||||
|
.clicked()
|
||||||
|
{
|
||||||
|
self.now_binding = Some((sim_id, *key))
|
||||||
|
}
|
||||||
|
if ui
|
||||||
|
.add_sized(ui.available_size(), Button::new("Clear"))
|
||||||
|
.clicked()
|
||||||
|
{
|
||||||
|
let mut mapping = mappings.write().unwrap();
|
||||||
|
mapping.clear_keyboard_mappings(*key);
|
||||||
|
}
|
||||||
|
});
|
||||||
|
}
|
||||||
|
});
|
||||||
|
}
|
||||||
|
});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl AppWindow for InputWindow {
|
||||||
|
fn viewport_id(&self) -> ViewportId {
|
||||||
|
ViewportId::from_hash_of("input")
|
||||||
|
}
|
||||||
|
|
||||||
|
fn initial_viewport(&self) -> ViewportBuilder {
|
||||||
|
ViewportBuilder::default()
|
||||||
|
.with_title("Bind Inputs")
|
||||||
|
.with_inner_size((600.0, 400.0))
|
||||||
|
}
|
||||||
|
|
||||||
|
fn show(&mut self, ctx: &Context) {
|
||||||
|
TopBottomPanel::top("options").show(ctx, |ui| {
|
||||||
|
ui.horizontal(|ui| {
|
||||||
|
ui.selectable_value(&mut self.active_tab, InputTab::Player1, "Player 1");
|
||||||
|
ui.selectable_value(&mut self.active_tab, InputTab::Player2, "Player 2");
|
||||||
|
});
|
||||||
|
});
|
||||||
|
CentralPanel::default().show(ctx, |ui| {
|
||||||
|
match self.active_tab {
|
||||||
|
InputTab::Player1 => self.render_key_bindings(ui, SimId::Player1),
|
||||||
|
InputTab::Player2 => self.render_key_bindings(ui, SimId::Player2),
|
||||||
|
};
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
fn handle_key_event(&mut self, event: &winit::event::KeyEvent) {
|
||||||
|
if !event.state.is_pressed() {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
let Some((sim_id, vb)) = self.now_binding.take() else {
|
||||||
|
return;
|
||||||
|
};
|
||||||
|
let mut mappings = self.mappings.for_sim(sim_id).write().unwrap();
|
||||||
|
mappings.add_keyboard_mapping(vb, event.physical_key);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Clone, Copy, PartialEq, Eq)]
|
||||||
|
enum InputTab {
|
||||||
|
Player1,
|
||||||
|
Player2,
|
||||||
|
}
|
||||||
Loading…
Reference in New Issue