PVB/lemur
PVB
/
lemur
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 28 Wiki Activity

Merge pull request 'Upgrade deps' (#6) from upgrade-deps into main 

Reviewed-on: #6
This commit is contained in:
Simon Gellis 2025-08-03 21:42:34 +00:00
parent dc072cc2ba 74ce44db8b
commit d4844a303a
8 changed files with 904 additions and 758 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1451
Cargo.lock generated
View File

File diff suppressed because it is too large Load Diff

16
Cargo.toml
View File

@ -16,11 +16,11 @@ 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" }
directories = "6" directories = "6"
egui = { version = "0.30", features = ["serde"] } egui = { version = "0.32", features = ["serde"] }
egui_extras = { version = "0.30", features = ["image"] } egui_extras = { version = "0.32", features = ["image"] }
egui-toast = { git = "https://github.com/urholaukkarinen/egui-toast.git", rev = "d0bcf97" } egui-notify = "0.20"
egui-winit = "0.30" egui-winit = "0.32"
egui-wgpu = { version = "0.30", features = ["winit"] } egui-wgpu = { version = "0.32", features = ["winit"] }
fixed = { version = "1.28", features = ["num-traits"] } fixed = { version = "1.28", features = ["num-traits"] }
gilrs = { version = "0.11", features = ["serde-serialize"] } gilrs = { version = "0.11", features = ["serde-serialize"] }
hex = "0.4" hex = "0.4"
@ -35,15 +35,15 @@ rtrb = "0.3"
rubato = "0.16" rubato = "0.16"
serde = { version = "1", features = ["derive"] } serde = { version = "1", features = ["derive"] }
serde_json = "1" serde_json = "1"
thread-priority = "1" thread-priority = "2"
tokio = { version = "1", features = ["io-util", "macros", "net", "rt", "sync", "time"] } tokio = { version = "1", features = ["io-util", "macros", "net", "rt", "sync", "time"] }
tracing = { version = "0.1", features = ["release_max_level_info"] } tracing = { version = "0.1", features = ["release_max_level_info"] }
tracing-subscriber = { version = "0.3", features = ["env-filter"] } tracing-subscriber = { version = "0.3", features = ["env-filter"] }
wgpu = "23" wgpu = "25"
winit = { version = "0.30", features = ["serde"] } winit = { version = "0.30", features = ["serde"] }
[target.'cfg(windows)'.dependencies] [target.'cfg(windows)'.dependencies]
windows = { version = "0.59", features = ["Win32_System_Threading"] } windows = { version = "0.61", features = ["Win32_System_Threading"] }
[build-dependencies] [build-dependencies]
cc = "1" cc = "1"

51
src/app.rs
View File

@ -298,10 +298,10 @@ impl ApplicationHandler<UserEvent> for Application {
} }
struct WgpuState { struct WgpuState {
instance: Arc<wgpu::Instance>, instance: wgpu::Instance,
adapter: Arc<wgpu::Adapter>, adapter: wgpu::Adapter,
device: Arc<wgpu::Device>, device: wgpu::Device,
queue: Arc<wgpu::Queue>, queue: wgpu::Queue,
} }
impl WgpuState { impl WgpuState {
@ -309,21 +309,21 @@ impl WgpuState {
#[allow(unused_variables)] #[allow(unused_variables)]
let egui_wgpu::WgpuConfiguration { let egui_wgpu::WgpuConfiguration {
wgpu_setup: wgpu_setup:
egui_wgpu::WgpuSetup::CreateNew { egui_wgpu::WgpuSetup::CreateNew(egui_wgpu::WgpuSetupCreateNew {
supported_backends, instance_descriptor: wgpu::InstanceDescriptor { backends, .. },
device_descriptor, device_descriptor,
.. ..
}, }),
.. ..
} = egui_wgpu::WgpuConfiguration::default() } = egui_wgpu::WgpuConfiguration::default()
else { else {
panic!("required fields not found") panic!("required fields not found")
}; };
#[cfg(windows)] #[cfg(windows)]
let supported_backends = wgpu::util::backend_bits_from_env() let backends = wgpu::Backends::from_env()
.unwrap_or((wgpu::Backends::PRIMARY | wgpu::Backends::GL) - wgpu::Backends::VULKAN); .unwrap_or((wgpu::Backends::PRIMARY | wgpu::Backends::GL) - wgpu::Backends::VULKAN);
let instance = wgpu::Instance::new(wgpu::InstanceDescriptor { let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor {
backends: supported_backends, backends,
..wgpu::InstanceDescriptor::default() ..wgpu::InstanceDescriptor::default()
}); });
@ -334,17 +334,14 @@ impl WgpuState {
})) }))
.expect("could not create adapter"); .expect("could not create adapter");
let trace_path = std::env::var("WGPU_TRACE"); let (device, queue) =
let (device, queue) = pollster::block_on(adapter.request_device( pollster::block_on(adapter.request_device(&(*device_descriptor)(&adapter)))
&(*device_descriptor)(&adapter),
trace_path.ok().as_ref().map(std::path::Path::new),
))
.expect("could not request device"); .expect("could not request device");
Self { Self {
instance: Arc::new(instance), instance,
adapter: Arc::new(adapter), adapter,
device: Arc::new(device), device,
queue: Arc::new(queue), queue,
} }
} }
} }
@ -382,24 +379,30 @@ impl Viewport {
ctx.set_fonts(fonts); ctx.set_fonts(fonts);
ctx.style_mut(|s| { ctx.style_mut(|s| {
s.wrap_mode = Some(TextWrapMode::Extend); s.wrap_mode = Some(TextWrapMode::Extend);
s.visuals.menu_rounding = Default::default(); s.visuals.menu_corner_radius = Default::default();
s.spacing.scroll = ScrollStyle::thin(); s.spacing.scroll = ScrollStyle::thin();
}); });
egui_extras::install_image_loaders(&ctx); egui_extras::install_image_loaders(&ctx);
let wgpu_config = egui_wgpu::WgpuConfiguration { let wgpu_config = egui_wgpu::WgpuConfiguration {
present_mode: wgpu::PresentMode::AutoNoVsync, present_mode: wgpu::PresentMode::AutoNoVsync,
wgpu_setup: egui_wgpu::WgpuSetup::Existing { wgpu_setup: egui_wgpu::WgpuSetup::Existing(egui_wgpu::WgpuSetupExisting {
instance: wgpu.instance.clone(), instance: wgpu.instance.clone(),
adapter: wgpu.adapter.clone(), adapter: wgpu.adapter.clone(),
device: wgpu.device.clone(), device: wgpu.device.clone(),
queue: wgpu.queue.clone(), queue: wgpu.queue.clone(),
}, }),
..egui_wgpu::WgpuConfiguration::default() ..egui_wgpu::WgpuConfiguration::default()
}; };
let mut painter = let mut painter = pollster::block_on(egui_wgpu::winit::Painter::new(
egui_wgpu::winit::Painter::new(ctx.clone(), wgpu_config, 1, None, false, true); ctx.clone(),
wgpu_config,
1,
None,
false,
true,
));
let mut info = ViewportInfo::default(); let mut info = ViewportInfo::default();
let mut builder = app.initial_viewport(); let mut builder = app.initial_viewport();

9
src/emulator.rs
View File

@ -9,12 +9,13 @@ use std::{
atomic::{AtomicBool, Ordering}, atomic::{AtomicBool, Ordering},
mpsc::{self, RecvError, TryRecvError}, mpsc::{self, RecvError, TryRecvError},
}, },
time::Duration,
}; };
use anyhow::Result; use anyhow::Result;
use atomic::Atomic; use atomic::Atomic;
use bytemuck::NoUninit; use bytemuck::NoUninit;
use egui_toast::{Toast, ToastKind, ToastOptions}; use egui_notify::Toast;
use tracing::{error, warn}; use tracing::{error, warn};
use crate::{ use crate::{
@ -726,10 +727,8 @@ impl Emulator {
.get(&sim_id) .get(&sim_id)
.or_else(|| self.messages.get(&SimId::Player1)); .or_else(|| self.messages.get(&SimId::Player1));
if let Some(msg) = messages { if let Some(msg) = messages {
let toast = Toast::new() let mut toast = Toast::error(&message);
.kind(ToastKind::Error) toast.duration(Some(Duration::from_secs(5)));
.options(ToastOptions::default().duration_in_seconds(5.0))
.text(&message);
if msg.send(toast).is_ok() { if msg.send(toast).is_ok() {
return; return;
} }

8
src/graphics.rs
View File

@ -10,7 +10,7 @@ use std::{
use anyhow::{Result, bail}; use anyhow::{Result, bail};
use itertools::Itertools as _; use itertools::Itertools as _;
use wgpu::{ use wgpu::{
Device, Extent3d, ImageCopyTexture, ImageDataLayout, Origin3d, Queue, Texture, Device, Extent3d, Origin3d, Queue, TexelCopyBufferLayout, TexelCopyTextureInfo, Texture,
TextureDescriptor, TextureFormat, TextureUsages, TextureView, TextureViewDescriptor, TextureDescriptor, TextureFormat, TextureUsages, TextureView, TextureViewDescriptor,
}; };
@ -21,7 +21,7 @@ pub struct TextureSink {
} }
impl TextureSink { impl TextureSink {
pub fn new(device: &Device, queue: Arc<Queue>) -> (Self, TextureView) { pub fn new(device: &Device, queue: Queue) -> (Self, TextureView) {
let texture = Self::create_texture(device); let texture = Self::create_texture(device);
let view = texture.create_view(&TextureViewDescriptor::default()); let view = texture.create_view(&TextureViewDescriptor::default());
let buffers = Arc::new(BufferPool::new()); let buffers = Arc::new(BufferPool::new());
@ -72,7 +72,7 @@ impl TextureSink {
} }
fn write_texture(queue: &Queue, texture: &Texture, bytes: &[u8]) { fn write_texture(queue: &Queue, texture: &Texture, bytes: &[u8]) {
let texture = ImageCopyTexture { let texture = TexelCopyTextureInfo {
texture, texture,
mip_level: 0, mip_level: 0,
origin: Origin3d::ZERO, origin: Origin3d::ZERO,
@ -83,7 +83,7 @@ impl TextureSink {
height: 224, height: 224,
depth_or_array_layers: 1, depth_or_array_layers: 1,
}; };
let data_layout = ImageDataLayout { let data_layout = TexelCopyBufferLayout {
offset: 0, offset: 0,
bytes_per_row: Some(384 * 2), bytes_per_row: Some(384 * 2),
rows_per_image: Some(224), rows_per_image: Some(224),

4
src/images.rs
View File

@ -193,8 +193,8 @@ struct ImageState {
impl ImageState { impl ImageState {
fn new(size: [usize; 2]) -> Self { fn new(size: [usize; 2]) -> Self {
let buffers = [ let buffers = [
Arc::new(ColorImage::new(size, Color32::BLACK)), Arc::new(ColorImage::filled(size, Color32::BLACK)),
Arc::new(ColorImage::new(size, Color32::BLACK)), Arc::new(ColorImage::filled(size, Color32::BLACK)),
]; ];
let sink = buffers[0].clone(); let sink = buffers[0].clone();
Self { Self {

77
src/window/game.rs
View File

@ -1,4 +1,4 @@
use std::sync::mpsc; use std::{sync::mpsc, time::Duration};
use crate::{ use crate::{
app::UserEvent, app::UserEvent,
@ -8,10 +8,10 @@ use crate::{
}; };
use anyhow::Context as _; use anyhow::Context as _;
use egui::{ use egui::{
Align2, Button, CentralPanel, Color32, Context, Direction, Frame, TopBottomPanel, Ui, Vec2, Align2, Button, CentralPanel, Color32, Context, Frame, MenuBar, TopBottomPanel, Ui, Vec2,
ViewportBuilder, ViewportCommand, ViewportId, Window, menu, ViewportBuilder, ViewportCommand, ViewportId, Window,
}; };
use egui_toast::{Toast, ToastKind, ToastOptions, Toasts}; use egui_notify::{Anchor, Toast, Toasts};
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use winit::event_loop::EventLoopProxy; use winit::event_loop::EventLoopProxy;
@ -43,6 +43,7 @@ pub struct GameWindow {
shortcuts: ShortcutProvider, shortcuts: ShortcutProvider,
sim_id: SimId, sim_id: SimId,
config: GameConfig, config: GameConfig,
toasts: Toasts,
screen: Option<GameScreen>, screen: Option<GameScreen>,
messages: Option<mpsc::Receiver<Toast>>, messages: Option<mpsc::Receiver<Toast>>,
color_picker: Option<ColorPickerState>, color_picker: Option<ColorPickerState>,
@ -57,6 +58,10 @@ impl GameWindow {
sim_id: SimId, sim_id: SimId,
) -> Self { ) -> Self {
let config = load_config(&persistence, sim_id); let config = load_config(&persistence, sim_id);
let toasts = Toasts::new()
.with_anchor(Anchor::BottomLeft)
.with_margin((10.0, 10.0).into())
.reverse(true);
Self { Self {
client, client,
proxy, proxy,
@ -64,13 +69,14 @@ impl GameWindow {
shortcuts, shortcuts,
sim_id, sim_id,
config, config,
toasts,
screen: None, screen: None,
messages: None, messages: None,
color_picker: None, color_picker: None,
} }
} }
fn show_menu(&mut self, ctx: &Context, ui: &mut Ui, toasts: &mut Toasts) { fn show_menu(&mut self, ctx: &Context, ui: &mut Ui) {
let state = self.client.emulator_state(); let state = self.client.emulator_state();
let is_ready = self.client.sim_state(self.sim_id) == SimState::Ready; let is_ready = self.client.sim_state(self.sim_id) == SimState::Ready;
let can_pause = is_ready && state == EmulatorState::Running; let can_pause = is_ready && state == EmulatorState::Running;
@ -119,7 +125,7 @@ impl GameWindow {
if autopause { if autopause {
self.client.send_command(EmulatorCommand::Pause); self.client.send_command(EmulatorCommand::Pause);
} }
pollster::block_on(self.take_screenshot(toasts)); pollster::block_on(self.take_screenshot());
if autopause { if autopause {
self.client.send_command(EmulatorCommand::Resume); self.client.send_command(EmulatorCommand::Resume);
} }
@ -139,7 +145,6 @@ impl GameWindow {
self.client self.client
.send_command(EmulatorCommand::LoadGame(self.sim_id, path)); .send_command(EmulatorCommand::LoadGame(self.sim_id, path));
} }
ui.close_menu();
} }
if ui if ui
.add(self.button_for(ui.ctx(), "Quit", Command::Quit)) .add(self.button_for(ui.ctx(), "Quit", Command::Quit))
@ -158,7 +163,6 @@ impl GameWindow {
.clicked() .clicked()
{ {
self.client.send_command(EmulatorCommand::Pause); self.client.send_command(EmulatorCommand::Pause);
ui.close_menu();
} }
} else if ui } else if ui
.add_enabled( .add_enabled(
@ -168,7 +172,6 @@ impl GameWindow {
.clicked() .clicked()
{ {
self.client.send_command(EmulatorCommand::Resume); self.client.send_command(EmulatorCommand::Resume);
ui.close_menu();
} }
if ui if ui
.add_enabled(is_ready, self.button_for(ui.ctx(), "Reset", Command::Reset)) .add_enabled(is_ready, self.button_for(ui.ctx(), "Reset", Command::Reset))
@ -176,7 +179,6 @@ impl GameWindow {
{ {
self.client self.client
.send_command(EmulatorCommand::Reset(self.sim_id)); .send_command(EmulatorCommand::Reset(self.sim_id));
ui.close_menu();
} }
ui.separator(); ui.separator();
if ui if ui
@ -187,7 +189,6 @@ impl GameWindow {
.clicked() .clicked()
{ {
self.client.send_command(EmulatorCommand::FrameAdvance); self.client.send_command(EmulatorCommand::FrameAdvance);
ui.close_menu();
} }
ui.separator(); ui.separator();
if ui if ui
@ -197,8 +198,7 @@ impl GameWindow {
) )
.clicked() .clicked()
{ {
pollster::block_on(self.take_screenshot(toasts)); pollster::block_on(self.take_screenshot());
ui.close_menu();
} }
}); });
ui.menu_button("Options", |ui| self.show_options_menu(ctx, ui)); ui.menu_button("Options", |ui| self.show_options_menu(ctx, ui));
@ -211,17 +211,14 @@ impl GameWindow {
self.client self.client
.send_command(EmulatorCommand::StartSecondSim(None)); .send_command(EmulatorCommand::StartSecondSim(None));
self.proxy.send_event(UserEvent::OpenPlayer2).unwrap(); self.proxy.send_event(UserEvent::OpenPlayer2).unwrap();
ui.close_menu();
} }
if has_player_2 { if has_player_2 {
let linked = self.client.are_sims_linked(); let linked = self.client.are_sims_linked();
if linked && ui.button("Unlink").clicked() { if linked && ui.button("Unlink").clicked() {
self.client.send_command(EmulatorCommand::Unlink); self.client.send_command(EmulatorCommand::Unlink);
ui.close_menu();
} }
if !linked && ui.button("Link").clicked() { if !linked && ui.button("Link").clicked() {
self.client.send_command(EmulatorCommand::Link); self.client.send_command(EmulatorCommand::Link);
ui.close_menu();
} }
} }
}); });
@ -230,78 +227,63 @@ impl GameWindow {
self.proxy self.proxy
.send_event(UserEvent::OpenTerminal(self.sim_id)) .send_event(UserEvent::OpenTerminal(self.sim_id))
.unwrap(); .unwrap();
ui.close_menu();
} }
if ui.button("GDB Server").clicked() { if ui.button("GDB Server").clicked() {
self.proxy self.proxy
.send_event(UserEvent::OpenDebugger(self.sim_id)) .send_event(UserEvent::OpenDebugger(self.sim_id))
.unwrap(); .unwrap();
ui.close_menu();
} }
ui.separator(); ui.separator();
if ui.button("Character Data").clicked() { if ui.button("Character Data").clicked() {
self.proxy self.proxy
.send_event(UserEvent::OpenCharacterData(self.sim_id)) .send_event(UserEvent::OpenCharacterData(self.sim_id))
.unwrap(); .unwrap();
ui.close_menu();
} }
if ui.button("Background Maps").clicked() { if ui.button("Background Maps").clicked() {
self.proxy self.proxy
.send_event(UserEvent::OpenBgMap(self.sim_id)) .send_event(UserEvent::OpenBgMap(self.sim_id))
.unwrap(); .unwrap();
ui.close_menu();
} }
if ui.button("Objects").clicked() { if ui.button("Objects").clicked() {
self.proxy self.proxy
.send_event(UserEvent::OpenObjects(self.sim_id)) .send_event(UserEvent::OpenObjects(self.sim_id))
.unwrap(); .unwrap();
ui.close_menu();
} }
if ui.button("Worlds").clicked() { if ui.button("Worlds").clicked() {
self.proxy self.proxy
.send_event(UserEvent::OpenWorlds(self.sim_id)) .send_event(UserEvent::OpenWorlds(self.sim_id))
.unwrap(); .unwrap();
ui.close_menu();
} }
if ui.button("Frame Buffers").clicked() { if ui.button("Frame Buffers").clicked() {
self.proxy self.proxy
.send_event(UserEvent::OpenFrameBuffers(self.sim_id)) .send_event(UserEvent::OpenFrameBuffers(self.sim_id))
.unwrap(); .unwrap();
ui.close_menu();
} }
if ui.button("Registers").clicked() { if ui.button("Registers").clicked() {
self.proxy self.proxy
.send_event(UserEvent::OpenRegisters(self.sim_id)) .send_event(UserEvent::OpenRegisters(self.sim_id))
.unwrap(); .unwrap();
ui.close_menu();
} }
}); });
ui.menu_button("Help", |ui| { ui.menu_button("Help", |ui| {
if ui.button("About").clicked() { if ui.button("About").clicked() {
self.proxy.send_event(UserEvent::OpenAbout).unwrap(); self.proxy.send_event(UserEvent::OpenAbout).unwrap();
ui.close_menu();
} }
}); });
} }
async fn take_screenshot(&self, toasts: &mut Toasts) { async fn take_screenshot(&mut self) {
match self.try_take_screenshot().await { match self.try_take_screenshot().await {
Ok(Some(path)) => { Ok(Some(path)) => {
toasts.add( let mut toast = Toast::info(format!("Saved to {path}"));
Toast::new() toast.duration(Some(Duration::from_secs(5)));
.kind(ToastKind::Info) self.toasts.add(toast);
.options(ToastOptions::default().duration_in_seconds(5.0))
.text(format!("Saved to {path}")),
);
} }
Ok(None) => {} Ok(None) => {}
Err(error) => { Err(error) => {
toasts.add( let mut toast = Toast::error(format!("{error:#}"));
Toast::new() toast.duration(Some(Duration::from_secs(5)));
.kind(ToastKind::Error) self.toasts.add(toast);
.options(ToastOptions::default().duration_in_seconds(5.0))
.text(format!("{error:#}")),
);
} }
} }
} }
@ -348,7 +330,6 @@ impl GameWindow {
.clicked() .clicked()
{ {
ctx.send_viewport_cmd(ViewportCommand::InnerSize(dims)); ctx.send_viewport_cmd(ViewportCommand::InnerSize(dims));
ui.close_menu();
} }
} }
}); });
@ -385,13 +366,11 @@ impl GameWindow {
c.display_mode = display_mode; c.display_mode = display_mode;
c.dimensions = current_dims * scale; c.dimensions = current_dims * scale;
}); });
ui.close_menu();
}); });
ui.menu_button("Colors", |ui| { ui.menu_button("Colors", |ui| {
for preset in COLOR_PRESETS { for preset in COLOR_PRESETS {
if ui.color_pair_button(preset[0], preset[1]).clicked() { if ui.color_pair_button(preset[0], preset[1]).clicked() {
self.update_config(|c| c.colors = preset); self.update_config(|c| c.colors = preset);
ui.close_menu();
} }
} }
ui.with_layout(ui.layout().with_cross_align(egui::Align::Center), |ui| { ui.with_layout(ui.layout().with_cross_align(egui::Align::Center), |ui| {
@ -412,7 +391,6 @@ impl GameWindow {
just_opened: true, just_opened: true,
unpause_on_close: is_running, unpause_on_close: is_running,
}); });
ui.close_menu();
} }
}); });
}); });
@ -423,23 +401,19 @@ impl GameWindow {
if ui.selectable_button(p1_enabled, "Player 1").clicked() { if ui.selectable_button(p1_enabled, "Player 1").clicked() {
self.client self.client
.send_command(EmulatorCommand::SetAudioEnabled(!p1_enabled, p2_enabled)); .send_command(EmulatorCommand::SetAudioEnabled(!p1_enabled, p2_enabled));
ui.close_menu();
} }
if ui.selectable_button(p2_enabled, "Player 2").clicked() { if ui.selectable_button(p2_enabled, "Player 2").clicked() {
self.client self.client
.send_command(EmulatorCommand::SetAudioEnabled(p1_enabled, !p2_enabled)); .send_command(EmulatorCommand::SetAudioEnabled(p1_enabled, !p2_enabled));
ui.close_menu();
} }
}); });
ui.menu_button("Input", |ui| { ui.menu_button("Input", |ui| {
if ui.button("Bind Inputs").clicked() { if ui.button("Bind Inputs").clicked() {
self.proxy.send_event(UserEvent::OpenInput).unwrap(); self.proxy.send_event(UserEvent::OpenInput).unwrap();
ui.close_menu();
} }
}); });
if ui.button("Hotkeys").clicked() { if ui.button("Hotkeys").clicked() {
self.proxy.send_event(UserEvent::OpenHotkeys).unwrap(); self.proxy.send_event(UserEvent::OpenHotkeys).unwrap();
ui.close_menu();
} }
} }
@ -535,19 +509,16 @@ impl AppWindow for GameWindow {
}; };
self.update_config(|c| c.dimensions = dimensions); self.update_config(|c| c.dimensions = dimensions);
let mut toasts = Toasts::new()
.anchor(Align2::LEFT_BOTTOM, (10.0, 10.0))
.direction(Direction::BottomUp);
if let Some(messages) = self.messages.as_mut() { if let Some(messages) = self.messages.as_mut() {
while let Ok(toast) = messages.try_recv() { while let Ok(toast) = messages.try_recv() {
toasts.add(toast); self.toasts.add(toast);
} }
} }
TopBottomPanel::top("menubar") TopBottomPanel::top("menubar")
.exact_height(22.0) .exact_height(22.0)
.show(ctx, |ui| { .show(ctx, |ui| {
menu::bar(ui, |ui| { MenuBar::new().ui(ui, |ui| {
self.show_menu(ctx, ui, &mut toasts); self.show_menu(ctx, ui);
}); });
}); });
if self.color_picker.is_some() { if self.color_picker.is_some() {
@ -566,7 +537,7 @@ impl AppWindow for GameWindow {
ui.add(screen); ui.add(screen);
} }
}); });
toasts.show(ctx); self.toasts.show(ctx);
} }
fn on_init(&mut self, _ctx: &Context, render_state: &egui_wgpu::RenderState) { fn on_init(&mut self, _ctx: &Context, render_state: &egui_wgpu::RenderState) {

44
src/window/utils.rs
View File

@ -6,8 +6,8 @@ use std::{
use atoi::FromRadix16; use atoi::FromRadix16;
use egui::{ use egui::{
Align, Color32, CursorIcon, Event, Frame, Key, Layout, Margin, Rect, Response, RichText, Align, Color32, CornerRadius, CursorIcon, Event, Frame, Key, Layout, Margin, Rect, Response,
Rounding, Sense, Shape, Stroke, TextEdit, Ui, UiBuilder, Vec2, Widget, WidgetText, RichText, Sense, Shape, Stroke, StrokeKind, TextEdit, Ui, UiBuilder, Vec2, Widget, WidgetText,
ecolor::HexColor, ecolor::HexColor,
}; };
use num_traits::{CheckedAdd, CheckedSub, One}; use num_traits::{CheckedAdd, CheckedSub, One};
@ -37,8 +37,8 @@ impl UiExt for Ui {
fn section(&mut self, title: impl Into<String>, add_contents: impl FnOnce(&mut Ui)) { fn section(&mut self, title: impl Into<String>, add_contents: impl FnOnce(&mut Ui)) {
let title: String = title.into(); let title: String = title.into();
let mut frame = Frame::group(self.style()); let mut frame = Frame::group(self.style());
frame.outer_margin.top += 10.0; frame.outer_margin.top += 10;
frame.inner_margin.top += 2.0; frame.inner_margin.top += 2;
let res = self.push_id(&title, |ui| { let res = self.push_id(&title, |ui| {
frame.show(ui, |ui| { frame.show(ui, |ui| {
ui.set_max_width(ui.available_width()); ui.set_max_width(ui.available_width());
@ -49,7 +49,7 @@ impl UiExt for Ui {
let old_rect = res.response.rect; let old_rect = res.response.rect;
let mut text_rect = old_rect; let mut text_rect = old_rect;
text_rect.min.x += 6.0; text_rect.min.x += 6.0;
self.allocate_new_ui(UiBuilder::new().max_rect(text_rect), |ui| ui.label(text)); self.scope_builder(UiBuilder::new().max_rect(text_rect), |ui| ui.label(text));
if old_rect.width() > 0.0 { if old_rect.width() > 0.0 {
self.advance_cursor_after_rect(old_rect); self.advance_cursor_after_rect(old_rect);
} }
@ -73,7 +73,8 @@ impl UiExt for Ui {
self.painter().rect_filled(right_rect, 0.0, right); self.painter().rect_filled(right_rect, 0.0, right);
let style = self.style().interact(&response); let style = self.style().interact(&response);
self.painter().rect_stroke(rect, 0.0, style.fg_stroke); self.painter()
.rect_stroke(rect, 0.0, style.fg_stroke, StrokeKind::Inside);
response response
} }
@ -265,10 +266,10 @@ impl<T: Number> Widget for NumberEdit<'_, T> {
.id(id) .id(id)
.desired_width(desired_width) .desired_width(desired_width)
.margin(Margin { .margin(Margin {
left: 4.0, left: 4,
right: if self.arrows { 20.0 } else { 4.0 }, right: if self.arrows { 20 } else { 4 },
top: 2.0, top: 2,
bottom: 2.0, bottom: 2,
}); });
let mut res = if valid { let mut res = if valid {
ui.add(text) ui.add(text)
@ -337,7 +338,7 @@ impl<T: Number> Widget for NumberEdit<'_, T> {
} }
str = to_string(self.value); str = to_string(self.value);
stale = true; stale = true;
} else if res.changed { } else if res.changed() {
if let Some(new_value) = from_string(&str).filter(in_range) { if let Some(new_value) = from_string(&str).filter(in_range) {
if *self.value != new_value { if *self.value != new_value {
res.mark_changed(); res.mark_changed();
@ -355,27 +356,20 @@ impl<T: Number> Widget for NumberEdit<'_, T> {
fn draw_arrow(ui: &mut Ui, rect: Rect, up: bool) -> Response { fn draw_arrow(ui: &mut Ui, rect: Rect, up: bool) -> Response {
let arrow_res = ui let arrow_res = ui
.allocate_rect( .allocate_rect(rect, Sense::all())
rect,
Sense {
click: true,
drag: true,
focusable: false,
},
)
.on_hover_cursor(CursorIcon::Default); .on_hover_cursor(CursorIcon::Default);
let visuals = ui.style().visuals.widgets.style(&arrow_res); let visuals = ui.style().visuals.widgets.style(&arrow_res);
let painter = ui.painter_at(arrow_res.rect); let painter = ui.painter_at(arrow_res.rect);
let rounding = if up { let rounding = if up {
Rounding { CornerRadius {
ne: 2.0, ne: 2,
..Rounding::ZERO ..CornerRadius::ZERO
} }
} else { } else {
Rounding { CornerRadius {
se: 2.0, se: 2,
..Rounding::ZERO ..CornerRadius::ZERO
} }
}; };
painter.rect_filled(arrow_res.rect, rounding, visuals.bg_fill); painter.rect_filled(arrow_res.rect, rounding, visuals.bg_fill);