wgpu: Store wgpu::Instance in Descriptors

desktop/src/gui/controller.rs

@@ -83,7 +83,7 @@ impl GuiController {
                 view_formats: Default::default(),
             },
         );
-        let descriptors = Descriptors::new(adapter, device, queue);
+        let descriptors = Descriptors::new(instance, adapter, device, queue);
         let egui_ctx = Context::default();
         if let Some(Theme::Light) = window.theme() {
             egui_ctx.set_visuals(egui::Visuals::light());

exporter/src/main.rs

@@ -414,7 +414,7 @@ fn main() -> Result<()> {
     ))
     .map_err(|e| anyhow!(e.to_string()))?;
 
-    let descriptors = Arc::new(Descriptors::new(adapter, device, queue));
+    let descriptors = Arc::new(Descriptors::new(instance, adapter, device, queue));
 
     if opt.swf.is_file() {
         capture_single_swf(descriptors, &opt)?;

render/wgpu/src/backend.rs

@@ -73,7 +73,7 @@ impl WgpuRenderBackend<SwapChainTarget> {
             None,
         )
         .await?;
-        let descriptors = Descriptors::new(adapter, device, queue);
+        let descriptors = Descriptors::new(instance, adapter, device, queue);
         let target =
             SwapChainTarget::new(surface, &descriptors.adapter, (1, 1), &descriptors.device);
         Self::new(Arc::new(descriptors), target)
@@ -107,7 +107,7 @@ impl WgpuRenderBackend<SwapChainTarget> {
             power_preference,
             trace_path,
         ))?;
-        let descriptors = Descriptors::new(adapter, device, queue);
+        let descriptors = Descriptors::new(instance, adapter, device, queue);
         let target = SwapChainTarget::new(surface, &descriptors.adapter, size, &descriptors.device);
         Self::new(Arc::new(descriptors), target)
     }
@@ -138,7 +138,7 @@ impl WgpuRenderBackend<crate::target::TextureTarget> {
             power_preference,
             trace_path,
         ))?;
-        let descriptors = Descriptors::new(adapter, device, queue);
+        let descriptors = Descriptors::new(instance, adapter, device, queue);
         let target = crate::target::TextureTarget::new(&descriptors.device, size)?;
         Self::new(Arc::new(descriptors), target)
     }

render/wgpu/src/descriptors.rs

@@ -12,6 +12,7 @@ use std::mem;
 use std::sync::{Arc, Mutex};
 
 pub struct Descriptors {
+    pub wgpu_instance: wgpu::Instance,
     pub adapter: wgpu::Adapter,
     pub device: wgpu::Device,
     pub limits: wgpu::Limits,
@@ -34,7 +35,12 @@ impl Debug for Descriptors {
 }
 
 impl Descriptors {
-    pub fn new(adapter: wgpu::Adapter, device: wgpu::Device, queue: wgpu::Queue) -> Self {
+    pub fn new(
+        instance: wgpu::Instance,
+        adapter: wgpu::Adapter,
+        device: wgpu::Device,
+        queue: wgpu::Queue,
+    ) -> Self {
         let limits = device.limits();
         let bind_layouts = BindLayouts::new(&device);
         let bitmap_samplers = BitmapSamplers::new(&device);
@@ -57,6 +63,7 @@ impl Descriptors {
         let filters = Filters::new(&device);
 
         Self {
+            wgpu_instance: instance,
             adapter,
             device,
             limits,

tests/tests/util/environment.rs

@@ -15,20 +15,22 @@ use std::sync::{Arc, OnceLock};
    but for `cargo nextest run` it's a big cost per test if it's not going to use it.
 */
 
-fn create_wgpu_device() -> Option<(wgpu::Adapter, wgpu::Device, wgpu::Queue)> {
+fn create_wgpu_device() -> Option<(wgpu::Instance, wgpu::Adapter, wgpu::Device, wgpu::Queue)> {
+    let instance = wgpu::Instance::new(Default::default());
     futures::executor::block_on(request_adapter_and_device(
         wgpu::Backends::all(),
-        &wgpu::Instance::new(Default::default()),
+        &instance,
         None,
         Default::default(),
         None,
     ))
     .ok()
+    .map(|(adapter, device, queue)| (instance, adapter, device, queue))
 }
 
 fn build_wgpu_descriptors() -> Option<Arc<Descriptors>> {
-    if let Some((adapter, device, queue)) = create_wgpu_device() {
+    if let Some((instance, adapter, device, queue)) = create_wgpu_device() {
-        Some(Arc::new(Descriptors::new(adapter, device, queue)))
+        Some(Arc::new(Descriptors::new(instance, adapter, device, queue)))
     } else {
         None
     }