Skip to content

Commit de21dc4

Browse files
feat: proper error handling
1 parent 3f2b7ac commit de21dc4

File tree

3 files changed

+73
-31
lines changed

3 files changed

+73
-31
lines changed

Cargo.lock

Lines changed: 17 additions & 0 deletions
Some generated files are not rendered by default. Learn more about customizing how changed files appear on GitHub.

Cargo.toml

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -6,5 +6,6 @@ edition = "2021"
66
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
77

88
[dependencies]
9-
winit = "0.29.1-beta"
9+
eyre = "0.6.8"
1010
softbuffer = "0.3.1"
11+
winit = "0.29.1-beta"

src/main.rs

Lines changed: 54 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -1,76 +1,100 @@
11
use std::num::NonZeroU32;
22

3+
use eyre::{format_err, Result, WrapErr};
34
use winit::{
5+
dpi::PhysicalSize,
46
event::{Event, WindowEvent},
57
event_loop::{ControlFlow, EventLoop},
6-
window::Window, dpi::PhysicalSize,
8+
window::Window,
79
};
810

911
struct State {
1012
// reverse order is important for safety (though I doubt anyone cares at exit)
1113
surface: softbuffer::Surface,
12-
context: softbuffer::Context,
14+
_context: softbuffer::Context,
1315
window: Window,
1416
}
1517

1618
impl State {
17-
pub fn new(event_loop: &EventLoop<()>) -> Self {
18-
let window = Window::new(event_loop).unwrap();
19+
pub fn new(event_loop: &EventLoop<()>) -> Result<Self> {
20+
let window = Window::new(event_loop).wrap_err("while creating window")?;
1921

2022
// SAFETY: window is only dropped at the end of the struct
21-
let context = unsafe { softbuffer::Context::new(&window) }.unwrap();
22-
let surface = unsafe { softbuffer::Surface::new(&context, &window) }.unwrap();
23+
// can't use wrap_err since softbuffer's error is neither send nor sync
24+
let context = unsafe { softbuffer::Context::new(&window) }
25+
.map_err(|e| format_err!("while creating softbuffer context: {e}"))?;
26+
let surface = unsafe { softbuffer::Surface::new(&context, &window) }
27+
.map_err(|e| format_err!("while creating surface: {e}"))?;
2328

2429
let mut state = Self {
2530
surface,
26-
context,
31+
_context: context,
2732
window,
2833
};
2934

3035
// initial resize needed for the surface to configure itself
3136
let initial_size = state.window.inner_size();
32-
state.resize(initial_size);
37+
state.resize(initial_size)?;
3338

34-
state
39+
Ok(state)
3540
}
3641

37-
pub fn process(&mut self, event: Event<()>) -> ControlFlow {
42+
pub fn process(&mut self, event: Event<()>) -> Result<ControlFlow> {
3843
match event {
39-
Event::RedrawRequested(_) => self.draw(),
44+
Event::RedrawRequested(_) => self.draw()?,
4045
Event::WindowEvent { event, .. } => match event {
41-
WindowEvent::Resized(new_size) => self.resize(new_size),
42-
WindowEvent::CloseRequested => return ControlFlow::Exit,
46+
WindowEvent::Resized(new_size) => self.resize(new_size)?,
47+
WindowEvent::CloseRequested => return Ok(ControlFlow::Exit),
4348
_ => (),
44-
}
49+
},
4550
_ => (),
4651
}
4752

48-
ControlFlow::Wait
53+
Ok(ControlFlow::Wait)
4954
}
5055

51-
pub fn resize(&mut self, new_size: PhysicalSize<u32>) {
52-
let (width, height) = (
53-
NonZeroU32::new(new_size.width).unwrap(),
54-
NonZeroU32::new(new_size.height).unwrap(),
55-
);
56-
self.surface.resize(width, height).unwrap();
56+
pub fn resize(&mut self, new_size: PhysicalSize<u32>) -> Result<()> {
57+
let Some(width) = NonZeroU32::new(new_size.width) else {
58+
// probably minimized, won't be drawn then anyway
59+
return Ok(());
60+
};
61+
let Some(height) = NonZeroU32::new(new_size.height) else {
62+
return Ok(());
63+
};
64+
65+
self.surface
66+
.resize(width, height)
67+
.map_err(|e| format_err!("could not resize surface: {e}"))
5768
}
5869

59-
pub fn draw(&mut self) {
60-
let mut buffer = self.surface.buffer_mut().unwrap();
70+
pub fn draw(&mut self) -> Result<()> {
71+
let mut buffer = self
72+
.surface
73+
.buffer_mut()
74+
.map_err(|e| format_err!("could not get reference to display buffer: {e}"))?;
6175

6276
let light_color = (255 << 16) | (255 << 8) | 255;
6377
buffer.fill(light_color);
6478

65-
buffer.present().unwrap();
79+
buffer
80+
.present()
81+
.map_err(|e| format_err!("could not present display buffer: {e}"))
6682
}
6783
}
6884

69-
fn main() -> Result<(), winit::error::EventLoopError> {
70-
let event_loop = EventLoop::new().unwrap();
71-
let mut state = State::new(&event_loop);
85+
fn main() -> Result<()> {
86+
let event_loop = EventLoop::new().wrap_err("while creating event loop")?;
87+
let mut state = State::new(&event_loop).wrap_err("while creating state")?;
7288

73-
event_loop.run(move |event, _, flow| {
74-
*flow = state.process(event);
75-
})
89+
event_loop
90+
.run(move |event, _, flow| {
91+
*flow = match state.process(event) {
92+
Ok(flow) => flow,
93+
Err(e) => {
94+
eprintln!("error: {e}");
95+
ControlFlow::Exit
96+
}
97+
}
98+
})
99+
.wrap_err("while running event loop")
76100
}

0 commit comments

Comments
 (0)