winit 0.30.0 with wgpu

[IsaacMarovitz]

I'm running into a problem migrating my 0.29 app to 0.30. wgpu requires async to create the context, and this context also needs access to winit's window handle. However, in the new trait-based architecture resumed does not permit the use of async, making creating this context very frustrating.

I've tried using tokio to just block for the context init, but ran into problems were several runtimes were being created even if I used Handle::current().

[kchibisov]

wgpu suggests to use block_on, but it's not like we can do much about it, unless you write a wrapper to make things async, given that winit was never designed to be async and won't be async.

[IsaacMarovitz]

I refactored using pollster instead of tokio and got it working.

[kchibisov]

That's what wgpu uses iirc as well in their examples, but my knowledge could be a bit behind on that matter. It's just what I see in wgpu examples Arc<Window> + pollster is what was a bit expected for 0.30.

[tversteeg]

Unfortunately, pollster doesn't work with WASM on the web.

[EriKWDev]

How did you handle the ownership of the wgpu::Surface<'window>?

I'm struggling a bit with it since now the window should be created inside resumed and the wgpu::Surface should have the lifetime of the window. How did you make the winit ApplicationHandler own the wpgu::Surface?

[rbxb]

I made a working example using ApplicationHandler here:
https://github.com/rbxb/wgpu_test/blob/main/src/main.rs

Here is a trimmed down version:

pub struct State<'a> {
    instance: wgpu::Instance,
    surface: wgpu::Surface<'a>,
}

impl<'a> State<'a> {
    pub async fn new(window: Arc<Window>) -> State<'a> {
        let instance = wgpu::Instance::default();
        let surface = instance.create_surface(Arc::clone(&window)).unwrap();

        Self {
            instance,
            surface,
        }
    }
}

#[derive(Default)]
pub struct App<'a> {
    window: Option<Arc<Window>>,
    state: Option<State<'a>>,
}

impl ApplicationHandler for App<'_> {
    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
        if self.window.is_none() {
            let window = Arc::new(event_loop.create_window(Window::default_attributes()).unwrap());
            self.window = Some(window.clone());

            let state = pollster::block_on(State::new(window.clone()));
            self.state = Some(state);
        }
    }
}

Let me know if anything can be improved.

[kchibisov]

The main issue is that pollster is not present on web. We've discussed with @daxpedda and web will have a trait with async in it and users who want to work on both should glue things, but that's about it.

[cwfitzgerald]

That would be really useful for us, the current solution is a spawn_local + custom event dance which isn't very pretty.

[erer1243]

If anyone is struggling with this in the meantime, I made a copy of wgpu's hello-triangle example that works with winit 0.30 on web & native, using the workaround described by @cwfitzgerald above. https://github.com/erer1243/wgpu-0.20-winit-0.30-web-example

[matthewjberger]

I made a minimal example repo that may be helpful

Demo here

It uses the latest versions of rust, wgpu, winit, egui (without eframe), and compiles to native as well as webassembly

[kchibisov]

How did you handle the ownership of the wgpu::Surface<'window>?

The way the do in their examples, with Arc.