Lifetimes, surface creation, and multi-threaded rendering using winit and wgpu.

[chaueve]

The problem

I am trying to create a multi-window multi-threaded application using winit (0.30.5) and wgpu (22.1.0).
The plan is for each window to have a render thread.
The problem is where and when to do surface creation.

First, the window can only be created with reference to winit ActiveEventLoop.
Thus, the window must be created on the same thread in which the event loop runs.
The surface's lifetime is bound to the window, which means rust does not allow you to move it to another thread.
Even if you put the window in an Arc and move it alongside into the spawned render thread, you run into lifetime issues.
Thus, the surface must be created on the render thread.

Except at least on Windows, creating the surface on the render thread causes an "underlying handle not available" error.
At the moment, to work around this issue, I do the following on the event loop thread:

let surface: wgpu::Surface<'static> = unsafe { std::mem::transmute(surface) };

And manually ensure the surface is dropped before the window.
Is there something I am missing?

[bwoods]

Storing the window in an Arc will give it (and its surface) the 'static lifetime that you need.

[chaueve]

Tried that.
When you store it in an Arc, the Arc then has a static lifetime, but not the surface.
Its lifetime is dependent on the reference to the inner value of the Arc. (Even though it is probably PhantomData)

If they both had static lifetime, you could drop the window before the surface, which is probably why the Surface type is set up the way it is.

[cwfitzgerald]

You need to clone the arc, then pass the arc by value to surface creation

[bwoods]

Are you passing a clone() of the Arc<Window> directly into instance.create_surface?

Here is what I am doing:

    pub async fn new(window: Arc<Window>) -> Self {
        let (width, height) = window.inner_size().into();
        let scale = window.scale_factor() as f32;

        let instance = wgpu::Instance::default();
        let surface = instance.create_surface(window).unwrap();

[chaueve]

We are on the same page thus far.
Now try moving the surface and the window into the render thread.

pub async fn new(window: Arc<Window>) -> Self {
    <snip>
    let surface = instance.create_surface(window).unwrap();
    std::thread::spawn(move || {
        do_something(window, surface);
    });
}

Remember that you can not call new() directly on the render thread because that causes an error.

[chaueve]

Got it working. Thanks. :-) Just needed not to take a reference and to clone.

pub async fn new(window: Arc<Window>) -> Self {
    <snip>
    let surface = instance.create_surface(window.clone()).unwrap();
    std::thread::spawn(move || {
        do_something(window, surface);
    });
}