Reimplement checkered background rendering (#4034)

* Reimplement background checkerboard rendering

node-graph/nodes/gstd/src/pixel_preview.rs

@@ -59,7 +59,7 @@ pub async fn pixel_preview<'a: 'n>(
 	let transform = DAffine2::from_translation(-upstream_min) * footprint.transform.inverse() * DAffine2::from_scale(logical_resolution);
 
 	let exec = editor_api.application_io.as_ref().unwrap().gpu_executor().unwrap();
-	let resampled = exec.resample_texture(source_texture.as_ref(), physical_resolution, &transform);
+	let resampled = exec.resample_texture(source_texture.as_ref(), physical_resolution, &transform).await;
 
 	result.data = RenderOutputType::Texture(resampled.into());
 

node-graph/nodes/gstd/src/render_cache.rs

@@ -6,7 +6,7 @@ use core_types::{CloneVarArgs, Context, Ctx, ExtractAll, ExtractAnimationTime, E
 use glam::{DAffine2, DVec2, IVec2, UVec2};
 use graph_craft::application_io::PlatformEditorApi;
 use graph_craft::document::value::RenderOutput;
-use graphene_application_io::ApplicationIo;
+use graphene_application_io::{ApplicationIo, ImageTexture};
 use rendering::{RenderOutputType as RenderOutputTypeRequest, RenderParams};
 use std::collections::HashSet;
 use std::hash::Hash;
@@ -26,7 +26,7 @@ pub struct TileCoord {
 
 #[derive(Debug, Clone)]
 pub struct CachedRegion {
-	pub texture: wgpu::Texture,
+	pub texture: ImageTexture,
 	pub texture_size: UVec2,
 	pub tiles: Vec<TileCoord>,
 	pub metadata: rendering::RenderMetadata,
@@ -41,7 +41,6 @@ pub struct CacheKey {
 	pub device_scale: u64,
 	pub zoom: u64,
 	pub rotation: u64,
-	pub hide_artboards: bool,
 	pub for_export: bool,
 	pub for_mask: bool,
 	pub thumbnail: bool,
@@ -60,7 +59,6 @@ impl CacheKey {
 		device_scale: f64,
 		zoom: f64,
 		rotation: f64,
-		hide_artboards: bool,
 		for_export: bool,
 		for_mask: bool,
 		thumbnail: bool,
@@ -87,7 +85,6 @@ impl CacheKey {
 			device_scale: device_scale.to_bits(),
 			zoom: zoom.to_bits(),
 			rotation: quantized_rotation.to_bits(),
-			hide_artboards,
 			for_export,
 			for_mask,
 			thumbnail,
@@ -100,23 +97,27 @@ impl CacheKey {
 	}
 }
 
+#[derive(Clone, Default, dyn_any::DynAny, Debug)]
+pub struct TileCache(Arc<Mutex<TileCacheImpl>>);
+
+impl TileCache {
+	pub fn query(&self, viewport_bounds: &AxisAlignedBbox, cache_key: &CacheKey, max_region_area: u32) -> CacheQuery {
+		self.0.lock().unwrap().query(viewport_bounds, cache_key, max_region_area)
+	}
+
+	pub fn store_regions(&self, regions: Vec<CachedRegion>) {
+		self.0.lock().unwrap().store_regions(regions);
+	}
+}
+
 #[derive(Default, Debug)]
 struct TileCacheImpl {
 	regions: Vec<CachedRegion>,
 	timestamp: u64,
 	total_memory: usize,
 	cache_key: CacheKey,
-	texture_cache_resolution: UVec2,
-	/// Pool of textures of the same size: `texture_cache_resolution`.
-	/// Reusing textures reduces the wgpu allocation pressure,
-	/// which is a problem on web since we have to wait for
-	/// the browser to garbage collect unused textures, eating up memory.
-	texture_cache: Vec<Arc<wgpu::Texture>>,
 }
 
-#[derive(Clone, Default, dyn_any::DynAny, Debug)]
-pub struct TileCache(Arc<Mutex<TileCacheImpl>>);
-
 #[derive(Debug, Clone)]
 pub struct RenderRegion {
 	pub tiles: Vec<TileCoord>,
@@ -205,7 +206,6 @@ impl TileCacheImpl {
 		while self.total_memory > MAX_CACHE_MEMORY_BYTES && !self.regions.is_empty() {
 			if let Some((oldest_idx, _)) = self.regions.iter().enumerate().min_by_key(|(_, r)| r.last_access) {
 				let removed = self.regions.remove(oldest_idx);
-				removed.texture.destroy();
 				self.total_memory = self.total_memory.saturating_sub(removed.memory_size);
 			} else {
 				break;
@@ -214,56 +214,9 @@ impl TileCacheImpl {
 	}
 
 	fn invalidate_all(&mut self) {
-		for region in &self.regions {
-			region.texture.destroy();
-		}
 		self.regions.clear();
 		self.total_memory = 0;
 	}
-
-	pub fn request_texture(&mut self, size: UVec2, device: &wgpu::Device) -> Arc<wgpu::Texture> {
-		if self.texture_cache_resolution != size {
-			self.texture_cache_resolution = size;
-			self.texture_cache.clear();
-		}
-		self.texture_cache.truncate(5);
-		for texture in &self.texture_cache {
-			if Arc::strong_count(texture) == 1 {
-				return Arc::clone(texture);
-			}
-		}
-		let texture = Arc::new(device.create_texture(&wgpu::TextureDescriptor {
-			label: Some("viewport_output"),
-			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,
-			format: wgpu::TextureFormat::Rgba8Unorm,
-			usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_DST | wgpu::TextureUsages::COPY_SRC | wgpu::TextureUsages::TEXTURE_BINDING,
-			view_formats: &[],
-		}));
-		self.texture_cache.push(texture.clone());
-
-		texture
-	}
-}
-
-impl TileCache {
-	pub fn query(&self, viewport_bounds: &AxisAlignedBbox, cache_key: &CacheKey, max_region_area: u32) -> CacheQuery {
-		self.0.lock().unwrap().query(viewport_bounds, cache_key, max_region_area)
-	}
-
-	pub fn store_regions(&self, regions: Vec<CachedRegion>) {
-		self.0.lock().unwrap().store_regions(regions);
-	}
-
-	pub fn request_texture(&self, size: UVec2, device: &wgpu::Device) -> Arc<wgpu::Texture> {
-		self.0.lock().unwrap().request_texture(size, device)
-	}
 }
 
 fn group_into_regions(tiles: &[TileCoord], max_region_area: u32) -> Vec<RenderRegion> {
@@ -411,7 +364,6 @@ pub async fn render_output_cache<'a: 'n>(
 		device_scale,
 		zoom,
 		rotation,
-		render_params.hide_artboards,
 		render_params.for_export,
 		render_params.for_mask,
 		render_params.thumbnail,
@@ -454,10 +406,9 @@ pub async fn render_output_cache<'a: 'n>(
 
 	let exec = editor_api.application_io.as_ref().unwrap().gpu_executor().unwrap();
 
-	let device = &exec.context.device;
-	let output_texture = tile_cache.request_texture(physical_resolution, device);
+	let output_texture = exec.request_texture(physical_resolution).await;
 
-	let combined_metadata = composite_cached_regions(&all_regions, output_texture.as_ref(), &device_origin_offset, &footprint.transform, exec);
+	let combined_metadata = composite_cached_regions(&all_regions, &output_texture, &device_origin_offset, &footprint.transform, exec);
 
 	RenderOutput {
 		data: RenderOutputType::Texture(output_texture.into()),
@@ -496,7 +447,7 @@ where
 	let region_ctx = OwnedContextImpl::from(ctx).with_footprint(region_footprint).with_vararg(Box::new(region_params)).into_context();
 	let mut result = render_fn(region_ctx).await;
 
-	let RenderOutputType::Texture(rendered_texture) = result.data else {
+	let RenderOutputType::Texture(texture) = result.data else {
 		unreachable!("render_missing_region: expected texture output from Vello render");
 	};
 
@@ -506,7 +457,7 @@ where
 	let memory_size = (region_pixel_size.x * region_pixel_size.y) as usize * BYTES_PER_PIXEL;
 
 	CachedRegion {
-		texture: rendered_texture.as_ref().clone(),
+		texture,
 		texture_size: region_pixel_size,
 		tiles: region.tiles.clone(),
 		metadata: result.metadata,
@@ -552,7 +503,7 @@ fn composite_cached_regions(
 		if width > 0 && height > 0 {
 			encoder.copy_texture_to_texture(
 				wgpu::TexelCopyTextureInfo {
-					texture: &region.texture,
+					texture: region.texture.as_ref(),
 					mip_level: 0,
 					origin: wgpu::Origin3d { x: src_x, y: src_y, z: 0 },
 					aspect: wgpu::TextureAspect::All,

node-graph/nodes/gstd/src/render_node.rs

@@ -7,12 +7,10 @@ pub use graph_craft::application_io::*;
 use graph_craft::document::value::RenderOutput;
 pub use graph_craft::document::value::RenderOutputType;
 use graphene_application_io::{ApplicationIo, ExportFormat, RenderConfig};
-use graphic_types::raster_types::Image;
 use graphic_types::raster_types::{CPU, Raster};
 use graphic_types::{Graphic, Vector};
-use rendering::{Render, RenderOutputType as RenderOutputTypeRequest, RenderParams, RenderSvgSegmentList, SvgRender, checkerboard_brush};
-use rendering::{RenderMetadata, SvgSegment};
-use std::collections::HashMap;
+use rendering::{Render, RenderMetadata, RenderOutputType as RenderOutputTypeRequest, RenderParams, SvgRender, SvgRenderOutput};
+use std::fmt::Write;
 use std::sync::Arc;
 use vector_types::GradientStops;
 use wgpu_executor::RenderContext;
@@ -20,19 +18,15 @@ use wgpu_executor::RenderContext;
 // Re-export render_output_cache from render_cache module
 pub use crate::render_cache::render_output_cache;
 
-/// List of (canvas id, image data) pairs for embedding images as canvases in the final SVG string.
-type ImageData = HashMap<core_types::graphene_hash::CacheHashWrapper<Image<Color>>, u64>;
-
 #[derive(Clone, dyn_any::DynAny)]
 pub enum RenderIntermediateType {
 	Vello(Arc<(vello::Scene, RenderContext)>),
-	Svg(Arc<(String, ImageData, String)>),
+	Svg(Arc<SvgRenderOutput>),
 }
 #[derive(Clone, dyn_any::DynAny)]
 pub struct RenderIntermediate {
 	pub(crate) ty: RenderIntermediateType,
 	pub(crate) metadata: RenderMetadata,
-	pub(crate) contains_artboard: bool,
 }
 
 #[node_macro::node(category(""))]
@@ -60,8 +54,6 @@ async fn render_intermediate<'a: 'n, T: 'static + Render + WasmNotSend + Send +
 	let footprint = Footprint::default();
 	let mut metadata = RenderMetadata::default();
 	data.collect_metadata(&mut metadata, footprint, None);
-	let contains_artboard = data.contains_artboard();
-
 	match &render_params.render_output_type {
 		RenderOutputTypeRequest::Vello => {
 			let mut scene = vello::Scene::new();
@@ -72,7 +64,6 @@ async fn render_intermediate<'a: 'n, T: 'static + Render + WasmNotSend + Send +
 			RenderIntermediate {
 				ty: RenderIntermediateType::Vello(Arc::new((scene, context))),
 				metadata,
-				contains_artboard,
 			}
 		}
 		RenderOutputTypeRequest::Svg => {
@@ -81,14 +72,185 @@ async fn render_intermediate<'a: 'n, T: 'static + Render + WasmNotSend + Send +
 			data.render_svg(&mut render, render_params);
 
 			RenderIntermediate {
-				ty: RenderIntermediateType::Svg(Arc::new((render.svg.to_svg_string(), render.image_data, render.svg_defs.clone()))),
+				ty: RenderIntermediateType::Svg(Arc::new(render.into())),
 				metadata,
-				contains_artboard,
 			}
 		}
 	}
 }
 
+#[node_macro::node(category(""))]
+async fn render<'a: 'n>(ctx: impl Ctx + ExtractFootprint + ExtractVarArgs, editor_api: &'a PlatformEditorApi, data: RenderIntermediate) -> RenderOutput {
+	let footprint = ctx.footprint();
+	let render_params = ctx
+		.vararg(0)
+		.expect("Did not find var args")
+		.downcast_ref::<RenderParams>()
+		.expect("Downcasting render params yielded invalid type");
+	let mut render_params = render_params.clone();
+	render_params.footprint = *footprint;
+
+	let RenderIntermediate { ty, mut metadata } = data;
+	metadata.apply_transform(footprint.transform);
+
+	let data = match (render_params.render_output_type, ty) {
+		(RenderOutputTypeRequest::Svg, RenderIntermediateType::Svg(data)) => {
+			let logical_resolution = render_params.footprint.resolution.as_dvec2() / render_params.scale;
+
+			let mut render = SvgRender::from(data.as_ref());
+			render.wrap_with_transform(render_params.footprint.transform, Some(logical_resolution));
+
+			let output = SvgRenderOutput::from(render);
+			assert!(output.svg_defs.is_empty());
+
+			RenderOutputType::Svg {
+				svg: output.svg,
+				image_data: output.image_data.into_iter().map(|(image, id)| (id, image.0)).collect(),
+			}
+		}
+		(RenderOutputTypeRequest::Vello, RenderIntermediateType::Vello(data)) => {
+			let Some(exec) = editor_api.application_io.as_ref().unwrap().gpu_executor() else {
+				unreachable!("Attempted to render with Vello when no GPU executor is available");
+			};
+			let (scene, context) = data.as_ref();
+			let scale = render_params.scale;
+			let physical_resolution = render_params.footprint.resolution;
+
+			let scale_transform = glam::DAffine2::from_scale(glam::DVec2::splat(scale));
+			let footprint_transform = scale_transform * render_params.footprint.transform;
+			let footprint_transform_vello = vello::kurbo::Affine::new(footprint_transform.to_cols_array());
+
+			let mut transformed_scene = vello::Scene::new();
+			transformed_scene.append(scene, Some(footprint_transform_vello));
+
+			// We now replace all transforms which are supposed to be infinite with a transform which covers the entire viewport.
+			// See <https://xi.zulipchat.com/#narrow/channel/197075-vello/topic/Full.20screen.20color.2Fgradients/near/538435044> for more detail.
+			//
+			// `!is_finite()` rather than `== f32::INFINITY`: `scene.append` composes the child's `Affine::scale(INFINITY)` with
+			// the viewport rotation, leaving `matrix[0] = cos(θ) * INFINITY`. In the (90°, 270°) tilt range cos is negative so
+			// the result is `-INFINITY`, which the old equality check missed; Vello then rasterized a unit rect with non-finite
+			// vertices, dropping the gradient and tanking performance. `!is_finite()` also covers NaN as a guard against future
+			// code paths where `matrix[0]` could land on `0 * INFINITY`.
+			let scaled_infinite_transform = vello::kurbo::Affine::scale_non_uniform(physical_resolution.x as f64, physical_resolution.y as f64);
+			for transform in transformed_scene.encoding_mut().transforms.iter_mut() {
+				if !transform.matrix[0].is_finite() {
+					*transform = vello_encoding::Transform::from_kurbo(&scaled_infinite_transform);
+				}
+			}
+
+			let texture = exec
+				.render_vello_scene(&transformed_scene, physical_resolution, context, None)
+				.await
+				.expect("Failed to render Vello scene");
+			RenderOutputType::Texture(texture.into())
+		}
+		_ => unreachable!("Render node did not receive its requested data type"),
+	};
+
+	RenderOutput { data, metadata }
+}
+
+#[node_macro::node(category(""))]
+async fn render_background<'a: 'n>(ctx: impl Ctx + ExtractFootprint + ExtractVarArgs, editor_api: &'a PlatformEditorApi, data: RenderOutput) -> RenderOutput {
+	let footprint = ctx.footprint();
+	let render_params = ctx
+		.vararg(0)
+		.expect("Did not find var args")
+		.downcast_ref::<RenderParams>()
+		.expect("Downcasting render params yielded invalid type");
+
+	if !render_params.to_canvas() {
+		return data;
+	}
+
+	let RenderOutput { data: foreground_data, metadata } = data;
+	let mut render_params = render_params.clone();
+	render_params.footprint = *footprint;
+
+	let data = match foreground_data {
+		RenderOutputType::Texture(foreground_texture) => {
+			if let Some(exec) = editor_api.application_io.as_ref().unwrap().gpu_executor() {
+				let doc_to_screen = (glam::DAffine2::from_scale(glam::DVec2::splat(render_params.scale)) * render_params.footprint.transform).as_affine2();
+				let blended = exec
+					.composite_background(foreground_texture.as_ref(), &metadata.backgrounds, doc_to_screen, render_params.viewport_zoom as f32)
+					.await;
+
+				RenderOutputType::Texture(blended.into())
+			} else {
+				RenderOutputType::Texture(foreground_texture)
+			}
+		}
+		RenderOutputType::Svg {
+			svg: foreground_svg,
+			image_data: foreground_images,
+		} => {
+			let mut render = SvgRender::new();
+
+			if render_params.viewport_zoom > 0. {
+				let draw_checkerboard = |render: &mut SvgRender, rect: vello::kurbo::Rect, pattern_origin: glam::DVec2, checker_id_prefix: &str| {
+					let checker_id = format!("{checker_id_prefix}-{}", generate_uuid());
+					let cell_size = 8. / render_params.viewport_zoom;
+					let pattern_size = cell_size * 2.;
+
+					write!(
+						&mut render.svg_defs,
+						r##"<pattern id="{checker_id}" x="{}" y="{}" width="{pattern_size}" height="{pattern_size}" patternUnits="userSpaceOnUse"><rect width="{pattern_size}" height="{pattern_size}" fill="#ffffff" /><rect x="{cell_size}" y="0" width="{cell_size}" height="{cell_size}" fill="#cccccc" /><rect x="0" y="{cell_size}" width="{cell_size}" height="{cell_size}" fill="#cccccc" /></pattern>"##,
+						pattern_origin.x,
+						pattern_origin.y,
+					)
+					.unwrap();
+
+					render.leaf_tag("rect", |attributes| {
+						attributes.push("x", rect.x0.to_string());
+						attributes.push("y", rect.y0.to_string());
+						attributes.push("width", rect.width().to_string());
+						attributes.push("height", rect.height().to_string());
+						attributes.push("fill", format!("url(#{checker_id})"));
+					});
+				};
+
+				if metadata.backgrounds.is_empty() {
+					if render_params.scale > 0. {
+						let logical_resolution = render_params.footprint.resolution.as_dvec2() / render_params.scale;
+						let logical_footprint = Footprint {
+							resolution: logical_resolution.round().as_uvec2().max(glam::UVec2::ONE),
+							..render_params.footprint
+						};
+						let bounds = logical_footprint.viewport_bounds_in_local_space();
+						let min = bounds.start.floor();
+						let max = bounds.end.ceil();
+
+						if min.is_finite() && max.is_finite() {
+							let rect = vello::kurbo::Rect::new(min.x, min.y, max.x, max.y);
+							draw_checkerboard(&mut render, rect, glam::DVec2::ZERO, "checkered-viewport");
+						}
+					}
+				} else {
+					for background in &metadata.backgrounds {
+						let [a, b] = [background.location, background.location + background.dimensions];
+						let rect = vello::kurbo::Rect::new(a.x.min(b.x), a.y.min(b.y), a.x.max(b.x), a.y.max(b.y));
+						draw_checkerboard(&mut render, rect, glam::DVec2::new(rect.x0, rect.y0), "checkered-artboard");
+					}
+				}
+			}
+
+			let logical_resolution = render_params.footprint.resolution.as_dvec2() / render_params.scale;
+			render.wrap_with_transform(render_params.footprint.transform, Some(logical_resolution));
+
+			let background = SvgRenderOutput::from(render);
+			assert!(background.svg_defs.is_empty());
+
+			let svg = format!("{}{}", background.svg, foreground_svg);
+			let image_data = foreground_images;
+
+			RenderOutputType::Svg { svg, image_data }
+		}
+		_ => unreachable!("Render background node received unsupported render output type"),
+	};
+
+	RenderOutput { data, metadata }
+}
+
 #[node_macro::node(category(""))]
 async fn create_context<'a: 'n>(
 	// Context injections are defined in the wrap_network_in_scope function
@@ -104,10 +266,8 @@ async fn create_context<'a: 'n>(
 
 	let render_params = RenderParams {
 		render_mode: render_config.render_mode,
-		hide_artboards: false,
 		for_export: render_config.for_export,
 		render_output_type,
-		footprint: Footprint::default(),
 		scale: render_config.scale,
 		viewport_zoom: footprint.scale_magnitudes().x,
 		..Default::default()
@@ -123,133 +283,3 @@ async fn create_context<'a: 'n>(
 
 	data.eval(ctx).await
 }
-
-#[node_macro::node(category(""))]
-async fn render<'a: 'n>(ctx: impl Ctx + ExtractFootprint + ExtractVarArgs, editor_api: &'a PlatformEditorApi, data: RenderIntermediate) -> RenderOutput {
-	let footprint = ctx.footprint();
-	let render_params = ctx
-		.vararg(0)
-		.expect("Did not find var args")
-		.downcast_ref::<RenderParams>()
-		.expect("Downcasting render params yielded invalid type");
-	let mut render_params = render_params.clone();
-	render_params.footprint = *footprint;
-	let render_params = &render_params;
-
-	let scale = render_params.scale;
-	let physical_resolution = render_params.footprint.resolution;
-	let logical_resolution = render_params.footprint.resolution.as_dvec2() / scale;
-
-	let RenderIntermediate { ty, mut metadata, contains_artboard } = data;
-	metadata.apply_transform(footprint.transform);
-
-	let data = match (render_params.render_output_type, &ty) {
-		(RenderOutputTypeRequest::Svg, RenderIntermediateType::Svg(svg_data)) => {
-			let mut rendering = SvgRender::new();
-
-			// Infinite canvas background (no artboards)
-			if !contains_artboard && !render_params.hide_artboards {
-				let show_checkerboard = render_params.to_canvas();
-				if show_checkerboard && render_params.viewport_zoom > 0. {
-					// Checkerboard pattern anchored at the document origin, tiling at 8x8 viewport pixels
-					let checker_id = format!("checkered-canvas-{}", generate_uuid());
-					let cell_size = 8. / render_params.viewport_zoom;
-					let pattern_size = cell_size * 2.;
-
-					// Compute the axis-aligned bounding box of all four viewport corners in document space,
-					// which is necessary when the view is rotated so the rect fully covers the visible area
-					let inverse_transform = footprint.transform.inverse();
-					let corners = [
-						inverse_transform.transform_point2(glam::DVec2::ZERO),
-						inverse_transform.transform_point2(glam::DVec2::new(logical_resolution.x, 0.)),
-						inverse_transform.transform_point2(glam::DVec2::new(0., logical_resolution.y)),
-						inverse_transform.transform_point2(logical_resolution),
-					];
-					let bb_min = corners.iter().fold(glam::DVec2::MAX, |acc, &c| acc.min(c));
-					let bb_max = corners.iter().fold(glam::DVec2::MIN, |acc, &c| acc.max(c));
-
-					rendering.leaf_tag("rect", |attributes| {
-						attributes.push("x", bb_min.x.to_string());
-						attributes.push("y", bb_min.y.to_string());
-						attributes.push("width", (bb_max.x - bb_min.x).to_string());
-						attributes.push("height", (bb_max.y - bb_min.y).to_string());
-						attributes.push("fill", format!("url(#{checker_id})"));
-					});
-
-					// Pattern defs will be appended after the intermediate defs are copied below
-					rendering.svg_defs = format!(
-						r##"<pattern id="{checker_id}" x="0" y="0" width="{pattern_size}" height="{pattern_size}" patternUnits="userSpaceOnUse"><rect width="{pattern_size}" height="{pattern_size}" fill="#fff"/><rect x="{cell_size}" y="0" width="{cell_size}" height="{cell_size}" fill="#ccc"/><rect x="0" y="{cell_size}" width="{cell_size}" height="{cell_size}" fill="#ccc"/></pattern>"##,
-					);
-				}
-			}
-
-			let existing_defs = rendering.svg_defs.clone();
-			rendering.svg.push(SvgSegment::from(svg_data.0.clone()));
-			rendering.image_data = svg_data.1.clone();
-			rendering.svg_defs = format!("{existing_defs}{}", svg_data.2);
-
-			rendering.wrap_with_transform(footprint.transform, Some(logical_resolution));
-			RenderOutputType::Svg {
-				svg: rendering.svg.to_svg_string(),
-				image_data: rendering.image_data.into_iter().map(|(image, id)| (id, image.0)).collect(),
-			}
-		}
-		(RenderOutputTypeRequest::Vello, RenderIntermediateType::Vello(vello_data)) => {
-			let Some(exec) = editor_api.application_io.as_ref().unwrap().gpu_executor() else {
-				unreachable!("Attempted to render with Vello when no GPU executor is available");
-			};
-			let (child, context) = Arc::as_ref(vello_data);
-
-			let scale_transform = glam::DAffine2::from_scale(glam::DVec2::splat(scale));
-			let footprint_transform = scale_transform * footprint.transform;
-			let footprint_transform_vello = vello::kurbo::Affine::new(footprint_transform.to_cols_array());
-
-			let mut scene = vello::Scene::new();
-
-			// Infinite canvas checkerboard (when no artboards are present)
-			let show_checkerboard = !render_params.for_export && !contains_artboard && !render_params.hide_artboards;
-			if show_checkerboard && scale > 0. && render_params.viewport_zoom > 0. {
-				// Compute the axis-aligned bounding box of all four viewport corners in document space,
-				// which is necessary so the rect fully covers the visible area when the canvas is tilted
-				let inverse_footprint = footprint_transform.inverse();
-				let corners = [
-					inverse_footprint.transform_point2(glam::DVec2::ZERO),
-					inverse_footprint.transform_point2(glam::DVec2::new(physical_resolution.x as f64, 0.)),
-					inverse_footprint.transform_point2(glam::DVec2::new(0., physical_resolution.y as f64)),
-					inverse_footprint.transform_point2(physical_resolution.as_dvec2()),
-				];
-				let bb_min = corners.iter().fold(glam::DVec2::MAX, |acc, &c| acc.min(c));
-				let bb_max = corners.iter().fold(glam::DVec2::MIN, |acc, &c| acc.max(c));
-				let doc_rect = vello::kurbo::Rect::new(bb_min.x, bb_min.y, bb_max.x, bb_max.y);
-
-				// Draw in document space, transformed to screen by footprint_transform (includes rotation)
-				// Brush maps each pixel to 1/viewport_zoom document units, giving constant 8px cells
-				let brush_transform = vello::kurbo::Affine::scale(1. / render_params.viewport_zoom);
-				scene.fill(vello::peniko::Fill::NonZero, footprint_transform_vello, &checkerboard_brush(), Some(brush_transform), &doc_rect);
-			}
-
-			scene.append(child, Some(footprint_transform_vello));
-
-			// We now replace all transforms which are supposed to be infinite with a transform which covers the entire viewport.
-			// See <https://xi.zulipchat.com/#narrow/channel/197075-vello/topic/Full.20screen.20color.2Fgradients/near/538435044> for more detail.
-			//
-			// `!is_finite()` rather than `== f32::INFINITY`: `scene.append` composes the child's `Affine::scale(INFINITY)` with
-			// the viewport rotation, leaving `matrix[0] = cos(θ) * INFINITY`. In the (90°, 270°) tilt range cos is negative so
-			// the result is `-INFINITY`, which the old equality check missed; Vello then rasterized a unit rect with non-finite
-			// vertices, dropping the gradient and tanking performance. `!is_finite()` also covers NaN as a guard against future
-			// code paths where `matrix[0]` could land on `0 * INFINITY`.
-			let scaled_infinite_transform = vello::kurbo::Affine::scale_non_uniform(physical_resolution.x as f64, physical_resolution.y as f64);
-			for transform in scene.encoding_mut().transforms.iter_mut() {
-				if !transform.matrix[0].is_finite() {
-					*transform = vello_encoding::Transform::from_kurbo(&scaled_infinite_transform);
-				}
-			}
-
-			let texture = Arc::new(exec.render_vello_scene_to_texture(&scene, physical_resolution, context).await.expect("Failed to render Vello scene"));
-
-			RenderOutputType::Texture(texture.into())
-		}
-		_ => unreachable!("Render node did not receive its requested data type"),
-	};
-	RenderOutput { data, metadata }
-}