Out with dear imgui, in with egui
This commit is contained in:
@@ -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,
|
||||
}
|
||||
Reference in New Issue
Block a user