Upgrade several Rust dependencies (#1613)

`specta` from Hypercube's fork commit to latest upstream commit
`wasm-bindgen` 0.2.87 -> 0.2.91
`spirv-std` from 0.9 to not-yet-merged commit in https://github.com/EmbarkStudios/rust-gpu/pull/1115
`wgpu` 0.17 -> 0.19
`winit` 0.28.6 -> 0.29
`vello` and `vello_svg` from latest upstream commit to not-yet-merged commit in https://github.com/linebender/vello/pull/427
`resvg` 0.36.0 -> 0.39
`glam` 0.24 -> 0.25
`rustybuzz` 0.8.0 -> 0.10.0
`js-sys` and `web-sys` 0.3.55 -> 0.3.67
`usvg` 0.36.0 -> 0.39
`spirv` 0.2.0 -> 0.3

* Update a couple of dependencies

* More test fixing…

* Use upstream Specta instead of fork

* Update comments in Cargo.toml

---------

Co-authored-by: Keavon Chambers <keavon@keavon.com>

node-graph/gcore/src/graphic_element.rs

@@ -233,7 +233,7 @@ impl GraphicGroup {
 	};
 
 	pub fn to_usvg_tree(&self, resolution: UVec2, viewbox: [DVec2; 2]) -> usvg::Tree {
-		let root_node = usvg::Node::new(usvg::NodeKind::Group(usvg::Group::default()));
+		let mut root_node = usvg::Group::default();
 		let tree = usvg::Tree {
 			size: usvg::Size::from_wh(resolution.x as f32, resolution.y as f32).unwrap(),
 			view_box: usvg::ViewBox {
@@ -244,7 +244,7 @@ impl GraphicGroup {
 		};
 
 		for element in self.iter() {
-			root_node.append(element.to_usvg_node());
+			root_node.children.push(element.to_usvg_node());
 		}
 		tree
 	}
@@ -283,20 +283,20 @@ impl GraphicElement {
 				}
 				let path = builder.finish().unwrap();
 				let mut path = usvg::Path::new(path.into());
-				path.transform = transform;
+				path.abs_transform = transform;
 				// TODO: use proper style
 				path.fill = None;
 				path.stroke = Some(usvg::Stroke::default());
-				usvg::Node::new(usvg::NodeKind::Path(path))
+				usvg::Node::Path(Box::new(path))
 			}
 			GraphicElement::ImageFrame(image_frame) => {
 				if image_frame.image.width * image_frame.image.height == 0 {
-					return usvg::Node::new(usvg::NodeKind::Group(usvg::Group::default()));
+					return usvg::Node::Group(Box::new(usvg::Group::default()));
 				}
 				let png = image_frame.image.to_png();
-				usvg::Node::new(usvg::NodeKind::Image(usvg::Image {
+				usvg::Node::Image(Box::new(usvg::Image {
 					id: String::new(),
-					transform: to_transform(image_frame.transform),
+					abs_transform: to_transform(image_frame.transform),
 					visibility: usvg::Visibility::Visible,
 					view_box: usvg::ViewBox {
 						rect: usvg::NonZeroRect::from_xywh(0., 0., 1., 1.).unwrap(),
@@ -304,14 +304,13 @@ impl GraphicElement {
 					},
 					rendering_mode: usvg::ImageRendering::OptimizeSpeed,
 					kind: usvg::ImageKind::PNG(png.into()),
+					bounding_box: None,
 				}))
 			}
-			GraphicElement::Text(text) => usvg::Node::new(usvg::NodeKind::Text(usvg::Text {
+			GraphicElement::Text(text) => usvg::Node::Text(Box::new(usvg::Text {
 				id: String::new(),
-				transform: usvg::Transform::identity(),
+				abs_transform: usvg::Transform::identity(),
 				rendering_mode: usvg::TextRendering::OptimizeSpeed,
-				positions: Vec::new(),
-				rotate: Vec::new(),
 				writing_mode: usvg::WritingMode::LeftToRight,
 				chunks: vec![usvg::TextChunk {
 					text: text.clone(),
@@ -321,17 +320,25 @@ impl GraphicElement {
 					spans: vec![],
 					text_flow: usvg::TextFlow::Linear,
 				}],
+				dx: Vec::new(),
+				dy: Vec::new(),
+				rotate: Vec::new(),
+				bounding_box: None,
+				abs_bounding_box: None,
+				stroke_bounding_box: None,
+				abs_stroke_bounding_box: None,
+				flattened: None,
 			})),
 			GraphicElement::GraphicGroup(group) => {
-				let group_element = usvg::Node::new(usvg::NodeKind::Group(usvg::Group::default()));
+				let mut group_element = usvg::Group::default();
 
 				for element in group.iter() {
-					group_element.append(element.to_usvg_node());
+					group_element.children.push(element.to_usvg_node());
 				}
-				group_element
+				usvg::Node::Group(Box::new(group_element))
 			}
 			// TODO
-			GraphicElement::Artboard(_board) => usvg::Node::new(usvg::NodeKind::Group(usvg::Group::default())),
+			GraphicElement::Artboard(_board) => usvg::Node::Group(Box::new(usvg::Group::default())),
 		}
 	}
 }

node-graph/gcore/src/graphic_element/renderer.rs

@@ -10,7 +10,6 @@ use bezier_rs::Subpath;
 
 use base64::Engine;
 use glam::{DAffine2, DVec2};
-use usvg::TreeParsing;
 
 /// Represents a clickable target for the layer
 #[derive(Clone, Debug)]
@@ -216,18 +215,21 @@ pub trait GraphicElementRendered {
 		let opt = usvg::Options::default();
 
 		let tree = usvg::Tree::from_str(&svg, &opt).expect("Failed to parse SVG");
-		tree.root.clone()
+		usvg::Node::Group(Box::new(tree.root.clone()))
 	}
 
 	fn to_usvg_tree(&self, resolution: glam::UVec2, viewbox: [DVec2; 2]) -> usvg::Tree {
-		let root_node = self.to_usvg_node();
+		let root = match self.to_usvg_node() {
+			usvg::Node::Group(root_node) => *root_node,
+			_ => usvg::Group::default(),
+		};
 		usvg::Tree {
 			size: usvg::Size::from_wh(resolution.x as f32, resolution.y as f32).unwrap(),
 			view_box: usvg::ViewBox {
 				rect: usvg::NonZeroRect::from_ltrb(viewbox[0].x as f32, viewbox[0].y as f32, viewbox[1].x as f32, viewbox[1].y as f32).unwrap(),
 				aspect: usvg::AspectRatio::default(),
 			},
-			root: root_node.clone(),
+			root,
 		}
 	}
 
@@ -275,11 +277,11 @@ impl GraphicElementRendered for GraphicGroup {
 	}
 
 	fn to_usvg_node(&self) -> usvg::Node {
-		let root_node = usvg::Node::new(usvg::NodeKind::Group(usvg::Group::default()));
+		let mut root_node = usvg::Group::default();
 		for element in self.iter() {
-			root_node.append(element.to_usvg_node());
+			root_node.children.push(element.to_usvg_node());
 		}
-		root_node
+		usvg::Node::Group(Box::new(root_node))
 	}
 
 	fn contains_artboard(&self) -> bool {
@@ -358,11 +360,11 @@ impl GraphicElementRendered for VectorData {
 		}
 		let path = builder.finish().unwrap();
 		let mut path = usvg::Path::new(path.into());
-		path.transform = transform;
+		path.abs_transform = transform;
 		// TODO: use proper style
 		path.fill = None;
 		path.stroke = Some(usvg::Stroke::default());
-		usvg::Node::new(usvg::NodeKind::Path(path))
+		usvg::Node::Path(Box::new(path))
 	}
 }
 
@@ -499,12 +501,12 @@ impl GraphicElementRendered for ImageFrame<Color> {
 	fn to_usvg_node(&self) -> usvg::Node {
 		let image_frame = self;
 		if image_frame.image.width * image_frame.image.height == 0 {
-			return usvg::Node::new(usvg::NodeKind::Group(usvg::Group::default()));
+			return usvg::Node::Group(Box::new(usvg::Group::default()));
 		}
 		let png = image_frame.image.to_png();
-		usvg::Node::new(usvg::NodeKind::Image(usvg::Image {
+		usvg::Node::Image(Box::new(usvg::Image {
 			id: String::new(),
-			transform: to_transform(image_frame.transform),
+			abs_transform: to_transform(image_frame.transform),
 			visibility: usvg::Visibility::Visible,
 			view_box: usvg::ViewBox {
 				rect: usvg::NonZeroRect::from_xywh(0., 0., 1., 1.).unwrap(),
@@ -512,6 +514,7 @@ impl GraphicElementRendered for ImageFrame<Color> {
 			},
 			rendering_mode: usvg::ImageRendering::OptimizeSpeed,
 			kind: usvg::ImageKind::PNG(png.into()),
+			bounding_box: None,
 		}))
 	}
 }
@@ -594,12 +597,10 @@ impl<T: Primitive> GraphicElementRendered for T {
 
 	fn to_usvg_node(&self) -> usvg::Node {
 		let text = self;
-		usvg::Node::new(usvg::NodeKind::Text(usvg::Text {
+		usvg::Node::Text(Box::new(usvg::Text {
 			id: String::new(),
-			transform: usvg::Transform::identity(),
+			abs_transform: usvg::Transform::identity(),
 			rendering_mode: usvg::TextRendering::OptimizeSpeed,
-			positions: Vec::new(),
-			rotate: Vec::new(),
 			writing_mode: usvg::WritingMode::LeftToRight,
 			chunks: vec![usvg::TextChunk {
 				text: text.to_string(),
@@ -609,6 +610,14 @@ impl<T: Primitive> GraphicElementRendered for T {
 				spans: vec![],
 				text_flow: usvg::TextFlow::Linear,
 			}],
+			dx: Vec::new(),
+			dy: Vec::new(),
+			rotate: Vec::new(),
+			bounding_box: None,
+			abs_bounding_box: None,
+			stroke_bounding_box: None,
+			abs_stroke_bounding_box: None,
+			flattened: None,
 		}))
 	}
 }

node-graph/gpu-executor/src/lib.rs

@@ -44,7 +44,7 @@ pub trait GpuExecutor {
 	type BufferHandle: Send + Sync;
 	type TextureHandle: Send + Sync;
 	type TextureView: Send + Sync;
-	type Surface: Send + Sync;
+	type Surface<'window>: Send + Sync;
 	type Window;
 	type CommandBuffer;
 
@@ -55,10 +55,10 @@ pub trait GpuExecutor {
 	fn create_texture_view(&self, texture: ShaderInput<Self>) -> Result<ShaderInput<Self>>;
 	fn create_output_buffer(&self, len: usize, ty: Type, cpu_readable: bool) -> Result<ShaderInput<Self>>;
 	fn create_compute_pass(&self, layout: &PipelineLayout<Self>, read_back: Option<Arc<ShaderInput<Self>>>, instances: ComputePassDimensions) -> Result<Self::CommandBuffer>;
-	fn create_render_pass(&self, texture: Arc<ShaderInput<Self>>, canvas: Arc<SurfaceHandle<Self::Surface>>) -> Result<()>;
+	fn create_render_pass(&self, texture: Arc<ShaderInput<Self>>, canvas: Arc<SurfaceHandle<Self::Surface<'_>>>) -> Result<()>;
 	fn execute_compute_pipeline(&self, encoder: Self::CommandBuffer) -> Result<()>;
 	fn read_output_buffer(&self, buffer: Arc<ShaderInput<Self>>) -> ReadBackFuture;
-	fn create_surface(&self, window: SurfaceHandle<Self::Window>) -> Result<SurfaceHandle<Self::Surface>>;
+	fn create_surface(&self, window: SurfaceHandle<Self::Window>) -> Result<SurfaceHandle<Self::Surface<'_>>>;
 }
 
 pub trait SpirVCompiler {
@@ -110,7 +110,7 @@ impl GpuExecutor for DummyExecutor {
 	type BufferHandle = ();
 	type TextureHandle = ();
 	type TextureView = ();
-	type Surface = ();
+	type Surface<'window> = ();
 	type Window = ();
 	type CommandBuffer = ();
 
@@ -142,7 +142,7 @@ impl GpuExecutor for DummyExecutor {
 		todo!()
 	}
 
-	fn create_render_pass(&self, _texture: Arc<ShaderInput<Self>>, _canvas: Arc<SurfaceHandle<Self::Surface>>) -> Result<()> {
+	fn create_render_pass(&self, _texture: Arc<ShaderInput<Self>>, _canvas: Arc<SurfaceHandle<Self::Surface<'_>>>) -> Result<()> {
 		todo!()
 	}
 
@@ -154,7 +154,7 @@ impl GpuExecutor for DummyExecutor {
 		todo!()
 	}
 
-	fn create_surface(&self, _window: SurfaceHandle<Self::Window>) -> Result<SurfaceHandle<Self::Surface>> {
+	fn create_surface(&self, _window: SurfaceHandle<Self::Window>) -> Result<SurfaceHandle<Self::Surface<'_>>> {
 		todo!()
 	}
 }
@@ -496,7 +496,7 @@ async fn read_output_buffer_node<'a: 'input, E: 'a + GpuExecutor>(buffer: Arc<Sh
 pub struct CreateGpuSurfaceNode {}
 
 #[node_macro::node_fn(CreateGpuSurfaceNode)]
-async fn create_gpu_surface<'a: 'input, E: 'a + GpuExecutor<Window = Io::Surface>, Io: ApplicationIo<Executor = E>>(editor_api: EditorApi<'a, Io>) -> Arc<SurfaceHandle<E::Surface>> {
+async fn create_gpu_surface<'a: 'input, E: 'a + GpuExecutor<Window = Io::Surface>, Io: ApplicationIo<Executor = E>>(editor_api: EditorApi<'a, Io>) -> Arc<SurfaceHandle<E::Surface<'a>>> {
 	let canvas = editor_api.application_io.create_surface();
 	let executor = editor_api.application_io.gpu_executor().unwrap();
 	Arc::new(executor.create_surface(canvas).unwrap())
@@ -529,7 +529,7 @@ where
 }
 
 #[node_macro::node_fn(RenderTextureNode)]
-async fn render_texture_node<'a: 'input, E: 'a + GpuExecutor>(image: ShaderInputFrame<E>, surface: Arc<SurfaceHandle<E::Surface>>, executor: &'a E) -> SurfaceFrame {
+async fn render_texture_node<'a: 'input, E: 'a + GpuExecutor>(image: ShaderInputFrame<E>, surface: Arc<SurfaceHandle<E::Surface<'input>>>, executor: &'a E) -> SurfaceFrame {
 	let surface_id = surface.surface_id;
 	log::trace!("rendering to surface {surface_id:?}");
 

node-graph/graph-craft/src/imaginate_input.rs

@@ -40,6 +40,7 @@ struct InternalImaginateControl {
 	status: Mutex<ImaginateStatus>,
 	trigger_regenerate: AtomicBool,
 	#[serde(skip)]
+	#[specta(skip)]
 	termination_sender: Mutex<Option<Box<dyn ImaginateTerminationHandle>>>,
 }
 

node-graph/gstd/src/wasm_application_io.rs

@@ -141,9 +141,9 @@ impl ApplicationIo for WasmApplicationIo {
 		use winit::platform::wayland::EventLoopBuilderExtWayland;
 
 		#[cfg(feature = "wayland")]
-		let event_loop = winit::event_loop::EventLoopBuilder::new().with_any_thread(true).build();
+		let event_loop = winit::event_loop::EventLoopBuilder::new().with_any_thread(true).build().unwrap();
 		#[cfg(not(feature = "wayland"))]
-		let event_loop = winit::event_loop::EventLoop::new();
+		let event_loop = winit::event_loop::EventLoop::new().unwrap();
 		let window = winit::window::WindowBuilder::new()
 			.with_title("Graphite")
 			.with_inner_size(winit::dpi::PhysicalSize::new(800, 600))
@@ -336,11 +336,9 @@ fn render_canvas(
 	if let Some(exec) = editor.application_io.gpu_executor() {
 		todo!()
 	} else {
-		let rtree = resvg::Tree::from_usvg(&usvg_tree);
-
-		let pixmap_size = rtree.size.to_int_size();
+		let pixmap_size = usvg_tree.size.to_int_size();
 		let mut pixmap = resvg::tiny_skia::Pixmap::new(pixmap_size.width(), pixmap_size.height()).unwrap();
-		rtree.render(resvg::tiny_skia::Transform::default(), &mut pixmap.as_mut());
+		resvg::render(&usvg_tree, resvg::tiny_skia::Transform::default(), &mut pixmap.as_mut());
 		let array: Clamped<&[u8]> = Clamped(pixmap.data());
 		let context = canvas.get_context("2d").unwrap().unwrap().dyn_into::<CanvasRenderingContext2d>().unwrap();
 		let image_data = web_sys::ImageData::new_with_u8_clamped_array_and_sh(array, pixmap_size.width(), pixmap_size.height()).expect("Failed to construct ImageData");

node-graph/interpreted-executor/src/node_registry.rs

@@ -369,9 +369,10 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 		#[cfg(feature = "gpu")]
 		async_node!(gpu_executor::ReadOutputBufferNode<_, _>, input: Arc<ShaderInput<WgpuExecutor>>, output: Vec<u8>, params: [&WgpuExecutor, ()]),
 		#[cfg(feature = "gpu")]
-		async_node!(gpu_executor::CreateGpuSurfaceNode, input: WasmEditorApi, output: Arc<SurfaceHandle<<WgpuExecutor as GpuExecutor>::Surface>>, params: []),
-		#[cfg(feature = "gpu")]
-		async_node!(gpu_executor::RenderTextureNode<_, _>, input: ShaderInputFrame<WgpuExecutor>, output: SurfaceFrame, params: [Arc<SurfaceHandle<<WgpuExecutor as GpuExecutor>::Surface>>, &WgpuExecutor]),
+		async_node!(gpu_executor::CreateGpuSurfaceNode, input: WasmEditorApi, output: Arc<SurfaceHandle<<WgpuExecutor as GpuExecutor>::Surface<'_>>>, params: []),
+		// todo!(gpu) get this to compie without saying that one type is more general than the other
+		// #[cfg(feature = "gpu")]
+		// async_node!(gpu_executor::RenderTextureNode<_, _>, input: ShaderInputFrame<WgpuExecutor>, output: SurfaceFrame, params: [Arc<SurfaceHandle<<WgpuExecutor as GpuExecutor>::Surface<'_>>>, &WgpuExecutor]),
 		#[cfg(feature = "gpu")]
 		async_node!(
 			gpu_executor::UploadTextureNode<_>,

node-graph/wgpu-executor/src/context.rs

@@ -21,7 +21,7 @@ impl Context {
 		// `request_adapter` instantiates the general connection to the GPU
 		let adapter = instance.request_adapter(&wgpu::RequestAdapterOptions::default()).await?;
 
-		let limits = adapter.limits();
+		let required_limits = adapter.limits();
 		// `request_device` instantiates the feature specific connection to the GPU, defining some parameters,
 		//  `features` being the available features.
 		let (device, queue) = adapter
@@ -29,10 +29,10 @@ impl Context {
 				&wgpu::DeviceDescriptor {
 					label: None,
 					#[cfg(not(feature = "passthrough"))]
-					features: wgpu::Features::empty(),
+					required_features: wgpu::Features::empty(),
 					#[cfg(feature = "passthrough")]
-					features: wgpu::Features::SPIRV_SHADER_PASSTHROUGH,
-					limits,
+					required_features: wgpu::Features::SPIRV_SHADER_PASSTHROUGH,
+					required_limits,
 				},
 				None,
 			)

node-graph/wgpu-executor/src/executor.rs

@@ -124,7 +124,7 @@ async fn execute_shader<I: Pod + Send + Sync, O: Pod + Send + Sync>(device: Arc<
 	// It is to WebGPU what a command buffer is to Vulkan.
 	let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
 	{
-		let mut cpass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor { label: None });
+		let mut cpass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor { label: None, timestamp_writes: None });
 		cpass.set_pipeline(&compute_pipeline);
 		cpass.set_bind_group(0, &bind_group, &[]);
 		cpass.insert_debug_marker("compute node network evaluation");

node-graph/wgpu-executor/src/lib.rs

@@ -43,7 +43,7 @@ impl<'a, T: ApplicationIo<Executor = WgpuExecutor>> From<EditorApi<'a, T>> for &
 	}
 }
 
-pub type WgpuSurface = Arc<SurfaceHandle<wgpu::Surface>>;
+pub type WgpuSurface<'window> = Arc<SurfaceHandle<wgpu::Surface<'window>>>;
 
 #[repr(C)]
 #[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
@@ -111,7 +111,7 @@ impl gpu_executor::GpuExecutor for WgpuExecutor {
 	type TextureHandle = Texture;
 	type TextureView = TextureView;
 	type CommandBuffer = CommandBufferWrapper;
-	type Surface = wgpu::Surface;
+	type Surface<'window> = wgpu::Surface<'window>;
 	#[cfg(target_arch = "wasm32")]
 	type Window = HtmlCanvasElement;
 	#[cfg(not(target_arch = "wasm32"))]
@@ -196,6 +196,7 @@ impl gpu_executor::GpuExecutor for WgpuExecutor {
 				usage,
 				view_formats: &[format],
 			},
+			wgpu::util::TextureDataOrder::LayerMajor,
 			bytes.as_ref(),
 		);
 		match options {
@@ -256,7 +257,7 @@ impl gpu_executor::GpuExecutor for WgpuExecutor {
 		let mut encoder = self.context.device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: Some("compute encoder") });
 		{
 			let dimensions = instances.get();
-			let mut cpass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor { label: None });
+			let mut cpass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor { label: None, timestamp_writes: None });
 			cpass.set_pipeline(&compute_pipeline);
 			cpass.set_bind_group(0, &bind_group, &[]);
 			cpass.insert_debug_marker("compute node network evaluation");
@@ -349,10 +350,12 @@ impl gpu_executor::GpuExecutor for WgpuExecutor {
 					resolve_target: None,
 					ops: wgpu::Operations {
 						load: wgpu::LoadOp::Load,
-						store: true,
+						store: wgpu::StoreOp::Store,
 					},
 				})],
 				depth_stencil_attachment: None,
+				timestamp_writes: None,
+				occlusion_query_set: None,
 			});
 
 			render_pass.set_pipeline(&self.render_configuration.render_pipeline);
@@ -430,7 +433,7 @@ impl gpu_executor::GpuExecutor for WgpuExecutor {
 
 	#[cfg(target_arch = "wasm32")]
 	fn create_surface(&self, canvas: graphene_core::WasmSurfaceHandle) -> Result<SurfaceHandle<wgpu::Surface>> {
-		let surface = self.context.instance.create_surface_from_canvas(canvas.surface)?;
+		let surface = self.context.instance.create_surface(wgpu::SurfaceTarget::Canvas(canvas.surface))?;
 
 		let surface_caps = surface.get_capabilities(&self.context.adapter);
 		let surface_format = wgpu::TextureFormat::Bgra8Unorm;
@@ -442,6 +445,7 @@ impl gpu_executor::GpuExecutor for WgpuExecutor {
 			present_mode: surface_caps.present_modes[0],
 			alpha_mode: wgpu::CompositeAlphaMode::PreMultiplied,
 			view_formats: vec![wgpu::TextureFormat::Bgra8UnormSrgb],
+			desired_maximum_frame_latency: 2,
 		};
 		surface.configure(&self.context.device, &config);
 		Ok(SurfaceHandle {
@@ -451,9 +455,9 @@ impl gpu_executor::GpuExecutor for WgpuExecutor {
 	}
 	#[cfg(not(target_arch = "wasm32"))]
 	fn create_surface(&self, window: SurfaceHandle<Self::Window>) -> Result<SurfaceHandle<wgpu::Surface>> {
-		let surface = unsafe { self.context.instance.create_surface(window.surface.as_ref()) }?;
-
 		let size = window.surface.inner_size();
+		let surface = self.context.instance.create_surface(wgpu::SurfaceTarget::Window(Box::new(window.surface)))?;
+
 		let surface_caps = surface.get_capabilities(&self.context.adapter);
 		println!("{surface_caps:?}");
 		let surface_format = wgpu::TextureFormat::Bgra8Unorm;
@@ -465,6 +469,7 @@ impl gpu_executor::GpuExecutor for WgpuExecutor {
 			present_mode: surface_caps.present_modes[0],
 			alpha_mode: surface_caps.alpha_modes[0],
 			view_formats: vec![],
+			desired_maximum_frame_latency: 2,
 		};
 		surface.configure(&self.context.device, &config);
 		self.surface_config.set(Some(config));