wgpu-executor: cleanup copy-pasted code

Author: Firestar99

node-graph/gstd/src/wasm_application_io.rs

@@ -16,7 +16,6 @@ use graphene_svg_renderer::{Render, RenderParams, RenderSvgSegmentList, SvgRende
 
 #[cfg(target_family = "wasm")]
 use base64::Engine;
-#[cfg(target_family = "wasm")]
 use glam::DAffine2;
 use std::sync::Arc;
 #[cfg(target_family = "wasm")]
@@ -169,7 +168,8 @@ fn render_svg(data: impl Render, mut render: SvgRender, render_params: RenderPar
 async fn render_canvas(render_config: RenderConfig, data: impl Render, editor: &WasmEditorApi, surface_handle: Option<wgpu_executor::WgpuSurface>, render_params: RenderParams) -> RenderOutputType {
 	use graphene_application_io::{ImageTexture, SurfaceFrame};
 
-	let footprint = render_config.viewport;
+	let mut footprint = render_config.viewport;
+	footprint.resolution = footprint.resolution.max(glam::UVec2::splat(1));
 	let Some(exec) = editor.application_io.as_ref().unwrap().gpu_executor() else {
 		unreachable!("Attempted to render with Vello when no GPU executor is available");
 	};
@@ -196,7 +196,7 @@ async fn render_canvas(render_config: RenderConfig, data: impl Render, editor: &
 		let frame = SurfaceFrame {
 			surface_id: surface_handle.window_id,
 			resolution: render_config.viewport.resolution,
-			transform: glam::DAffine2::IDENTITY,
+			transform: DAffine2::IDENTITY,
 		};
 
 		RenderOutputType::CanvasFrame(frame)

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

@@ -42,6 +42,7 @@ pub struct Surface {
 }
 
 pub struct TargetTexture {
+	texture: wgpu::Texture,
 	view: wgpu::TextureView,
 	size: UVec2,
 }
@@ -60,29 +61,6 @@ const VELLO_SURFACE_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba8Unor
 impl WgpuExecutor {
 	pub async fn render_vello_scene(&self, scene: &Scene, surface: &WgpuSurface, size: UVec2, context: &RenderContext, background: Color) -> Result<()> {
 		let mut guard = surface.surface.target_texture.lock().await;
-		let target_texture = if let Some(target_texture) = &*guard
-			&& target_texture.size == size
-		{
-			target_texture
-		} else {
-			let texture = self.context.device.create_texture(&wgpu::TextureDescriptor {
-				label: None,
-				size: wgpu::Extent3d {
-					width: size.x,
-					height: size.y,
-					depth_or_array_layers: 1,
-				},
-				mip_level_count: 1,
-				sample_count: 1,
-				dimension: wgpu::TextureDimension::D2,
-				usage: wgpu::TextureUsages::STORAGE_BINDING | wgpu::TextureUsages::TEXTURE_BINDING,
-				format: VELLO_SURFACE_FORMAT,
-				view_formats: &[],
-			});
-			let view = texture.create_view(&wgpu::TextureViewDescriptor::default());
-			*guard = Some(TargetTexture { size, view });
-			guard.as_ref().unwrap()
-		};
 
 		let surface_inner = &surface.surface.inner;
 		let surface_caps = surface_inner.get_capabilities(&self.context.adapter);
@@ -100,39 +78,14 @@ impl WgpuExecutor {
 			},
 		);
 
-		let [r, g, b, _] = background.to_rgba8_srgb();
-		let render_params = RenderParams {
-			// We are using an explicit opaque color here to eliminate the alpha premultiplication step
-			// which would be required to support a transparent webgpu canvas
-			base_color: vello::peniko::Color::from_rgba8(r, g, b, 0xff),
-			width: size.x,
-			height: size.y,
-			antialiasing_method: AaConfig::Msaa16,
-		};
-
-		{
-			let mut renderer = self.vello_renderer.lock().await;
-			for (image, texture) in context.resource_overrides.iter() {
-				let texture_view = wgpu::TexelCopyTextureInfoBase {
-					texture: texture.clone(),
-					mip_level: 0,
-					origin: Origin3d::ZERO,
-					aspect: TextureAspect::All,
-				};
-				renderer.override_image(image, Some(texture_view));
-			}
-			renderer.render_to_texture(&self.context.device, &self.context.queue, scene, &target_texture.view, &render_params)?;
-			for (image, _) in context.resource_overrides.iter() {
-				renderer.override_image(image, None);
-			}
-		}
+		self.render_vello_scene_to_target_texture(scene, size, context, background, &mut guard).await?;
 
 		let surface_texture = surface_inner.get_current_texture()?;
 		let mut encoder = self.context.device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: Some("Surface Blit") });
 		surface.surface.blitter.copy(
 			&self.context.device,
 			&mut encoder,
-			&target_texture.view,
+			&guard.as_ref().unwrap().view,
 			&surface_texture.texture.create_view(&wgpu::TextureViewDescriptor::default()),
 		);
 		self.context.queue.submit([encoder.finish()]);
@@ -142,21 +95,35 @@ impl WgpuExecutor {
 	}
 
 	pub async fn render_vello_scene_to_texture(&self, scene: &Scene, size: UVec2, context: &RenderContext, background: Color) -> Result<wgpu::Texture> {
-		let texture = self.context.device.create_texture(&wgpu::TextureDescriptor {
-			label: None,
-			size: wgpu::Extent3d {
-				width: size.x.max(1),
-				height: size.y.max(1),
-				depth_or_array_layers: 1,
-			},
-			mip_level_count: 1,
-			sample_count: 1,
-			dimension: wgpu::TextureDimension::D2,
-			usage: wgpu::TextureUsages::STORAGE_BINDING | wgpu::TextureUsages::TEXTURE_BINDING,
-			format: VELLO_SURFACE_FORMAT,
-			view_formats: &[],
-		});
-		let view = texture.create_view(&wgpu::TextureViewDescriptor::default());
+		let mut output = None;
+		self.render_vello_scene_to_target_texture(scene, size, context, background, &mut output).await?;
+		Ok(output.unwrap().texture)
+	}
+
+	async fn render_vello_scene_to_target_texture(&self, scene: &Scene, size: UVec2, context: &RenderContext, background: Color, output: &mut Option<TargetTexture>) -> Result<()> {
+		let target_texture = if let Some(target_texture) = output
+			&& target_texture.size == size
+		{
+			target_texture
+		} else {
+			let texture = self.context.device.create_texture(&wgpu::TextureDescriptor {
+				label: None,
+				size: wgpu::Extent3d {
+					width: size.x,
+					height: size.y,
+					depth_or_array_layers: 1,
+				},
+				mip_level_count: 1,
+				sample_count: 1,
+				dimension: wgpu::TextureDimension::D2,
+				usage: wgpu::TextureUsages::STORAGE_BINDING | wgpu::TextureUsages::TEXTURE_BINDING,
+				format: VELLO_SURFACE_FORMAT,
+				view_formats: &[],
+			});
+			let view = texture.create_view(&wgpu::TextureViewDescriptor::default());
+			*output = Some(TargetTexture { texture, view, size });
+			output.as_mut().unwrap()
+		};
 
 		let [r, g, b, a] = background.to_rgba8_srgb();
 		let render_params = RenderParams {
@@ -177,13 +144,12 @@ impl WgpuExecutor {
 				};
 				renderer.override_image(image, Some(texture_view));
 			}
-			renderer.render_to_texture(&self.context.device, &self.context.queue, scene, &view, &render_params)?;
+			renderer.render_to_texture(&self.context.device, &self.context.queue, scene, &target_texture.view, &render_params)?;
 			for (image, _) in context.resource_overrides.iter() {
 				renderer.override_image(image, None);
 			}
 		}
-
-		Ok(texture)
+		Ok(())
 	}
 
 	#[cfg(target_family = "wasm")]
@@ -212,26 +178,9 @@ impl WgpuExecutor {
 
 impl WgpuExecutor {
 	pub async fn new() -> Option<Self> {
-		let context = Context::new().await?;
-
-		let vello_renderer = Renderer::new(
-			&context.device,
-			RendererOptions {
-				// surface_format: Some(wgpu::TextureFormat::Rgba8Unorm),
-				pipeline_cache: None,
-				use_cpu: false,
-				antialiasing_support: AaSupport::all(),
-				num_init_threads: std::num::NonZeroUsize::new(1),
-			},
-		)
-		.map_err(|e| anyhow::anyhow!("Failed to create Vello renderer: {:?}", e))
-		.ok()?;
-
-		Some(Self {
-			context,
-			vello_renderer: vello_renderer.into(),
-		})
+		Self::with_context(Context::new().await?)
 	}
+
 	pub fn with_context(context: Context) -> Option<Self> {
 		let vello_renderer = Renderer::new(
 			&context.device,