Testing native export with raster convert implementation

timon-schelling · timon-schelling · commit 0ba273dfaef4 · 2025-09-26T19:58:13.000Z
diff --git a/desktop/wrapper/src/intercept_frontend_message.rs b/desktop/wrapper/src/intercept_frontend_message.rs
@@ -61,6 +61,61 @@ pub(super) fn intercept_frontend_message(dispatcher: &mut DesktopWrapperMessageD
 				context: SaveFileDialogContext::File { content },
 			});
 		}
+		FrontendMessage::TriggerExportImageBuffer {
+			data,
+			width,
+			height,
+			transparent,
+			file_type,
+			name,
+		} => {
+			let mut encoded = Vec::new();
+
+			use graphite_editor::messages::frontend::utility_types::FileType;
+			use image::ColorType;
+			use image::ImageEncoder;
+			match file_type {
+				FileType::Png => {
+					let result = image::codecs::png::PngEncoder::new(std::io::Cursor::new(&mut encoded)).write_image(&data, width, height, ColorType::Rgba8.into());
+					if let Err(err) = result {
+						tracing::error!("Failed to encode PNG: {err}");
+						return None;
+					}
+				}
+				FileType::Jpg => {
+					let result = image::codecs::jpeg::JpegEncoder::new(std::io::Cursor::new(&mut encoded)).write_image(&data, width, height, ColorType::Rgba8.into());
+					if let Err(err) = result {
+						tracing::error!("Failed to encode JPG: {err}");
+						return None;
+					}
+				}
+				FileType::Svg => {
+					tracing::error!("SVG cannot be exported from an image buffer");
+					return None;
+				}
+			}
+			let file_extension = match file_type {
+				FileType::Png => "png",
+				FileType::Jpg => "jpg",
+				FileType::Svg => unreachable!(),
+			};
+
+			let default_filename = if name.ends_with(&format!(".{file_extension}")) {
+				name
+			} else {
+				format!("{name}.{file_extension}")
+			};
+
+			println!("Successfully encoded image, size: {} bytes", encoded.len());
+
+			dispatcher.respond(DesktopFrontendMessage::SaveFileDialog {
+				title: "Export".to_string(),
+				default_filename,
+				default_folder: None,
+				filters: Vec::new(),
+				context: SaveFileDialogContext::File { content: encoded },
+			});
+		}
 		FrontendMessage::TriggerVisitLink { url } => {
 			dispatcher.respond(DesktopFrontendMessage::OpenUrl(url));
 		}
diff --git a/desktop/wrapper/src/messages.rs b/desktop/wrapper/src/messages.rs
@@ -135,3 +135,8 @@ pub enum Platform {
 	Mac,
 	Linux,
 }
+
+pub enum ExportType {
+	Png,
+	Jpg,
+}
diff --git a/editor/src/messages/frontend/frontend_message.rs b/editor/src/messages/frontend/frontend_message.rs
@@ -82,6 +82,16 @@ pub enum FrontendMessage {
 		mime: String,
 		size: (f64, f64),
 	},
+	#[cfg(feature = "gpu")]
+	#[serde(skip)]
+	TriggerExportImageBuffer {
+		data: Vec<u8>,
+		width: u32,
+		height: u32,
+		transparent: bool,
+		file_type: super::utility_types::FileType,
+		name: String,
+	},
 	TriggerFetchAndOpenDocument {
 		name: String,
 		filename: String,
diff --git a/editor/src/node_graph_executor.rs b/editor/src/node_graph_executor.rs
@@ -190,14 +190,20 @@ impl NodeGraphExecutor {
 		let size = bounds[1] - bounds[0];
 		let transform = DAffine2::from_translation(bounds[0]).inverse();
 
+		let export_format = if export_config.file_type == FileType::Svg || cfg!(not(feature = "gpu")) {
+			graphene_std::application_io::ExportFormat::Svg
+		} else {
+			graphene_std::application_io::ExportFormat::Buffer
+		};
+
 		let render_config = RenderConfig {
 			viewport: Footprint {
 				transform: DAffine2::from_scale(DVec2::splat(export_config.scale_factor)) * transform,
 				resolution: (size * export_config.scale_factor).as_uvec2(),
 				..Default::default()
 			},
 			time: Default::default(),
-			export_format: graphene_std::application_io::ExportFormat::Svg,
+			export_format,
 			render_mode: document.render_mode,
 			hide_artboards: export_config.transparent_background,
 			for_export: true,
@@ -219,28 +225,49 @@ impl NodeGraphExecutor {
 	}
 
 	fn export(&self, node_graph_output: TaggedValue, export_config: ExportConfig, responses: &mut VecDeque<Message>) -> Result<(), String> {
-		let TaggedValue::RenderOutput(RenderOutput {
-			data: RenderOutputType::Svg { svg, .. },
-			..
-		}) = node_graph_output
-		else {
-			return Err("Incorrect render type for exporting (expected RenderOutput::Svg)".to_string());
-		};
-
 		let ExportConfig {
-			file_type, name, size, scale_factor, ..
+			file_type,
+			name,
+			size,
+			scale_factor,
+			transparent_background,
+			..
 		} = export_config;
 
 		let file_suffix = &format!(".{file_type:?}").to_lowercase();
 		let name = name + file_suffix;
 
-		if file_type == FileType::Svg {
-			responses.add(FrontendMessage::TriggerSaveFile { name, content: svg.into_bytes() });
-		} else {
-			let mime = file_type.to_mime().to_string();
-			let size = (size * scale_factor).into();
-			responses.add(FrontendMessage::TriggerExportImage { svg, name, mime, size });
-		}
+		match node_graph_output {
+			TaggedValue::RenderOutput(RenderOutput {
+				data: RenderOutputType::Svg { svg, .. },
+				..
+			}) => {
+				if file_type == FileType::Svg {
+					responses.add(FrontendMessage::TriggerSaveFile { name, content: svg.into_bytes() });
+				} else {
+					let mime = file_type.to_mime().to_string();
+					let size = (size * scale_factor).into();
+					responses.add(FrontendMessage::TriggerExportImage { svg, name, mime, size });
+				}
+			}
+			#[cfg(feature = "gpu")]
+			TaggedValue::RenderOutput(RenderOutput {
+				data: RenderOutputType::Buffer { data, width, height },
+				..
+			}) if file_type != FileType::Svg => {
+				responses.add(FrontendMessage::TriggerExportImageBuffer {
+					data,
+					width,
+					height,
+					transparent: transparent_background,
+					name,
+					file_type,
+				});
+			}
+			_ => {
+				return Err(format!("Incorrect render type for exporting to an SVG ({file_type:?}, {node_graph_output})"));
+			}
+		};
 
 		Ok(())
 	}
diff --git a/node-graph/gapplication-io/src/lib.rs b/node-graph/gapplication-io/src/lib.rs
@@ -222,11 +222,8 @@ pub trait GetEditorPreferences {
 pub enum ExportFormat {
 	#[default]
 	Svg,
-	Png {
-		transparent: bool,
-	},
-	Jpeg,
 	Canvas,
+	Buffer,
 	Texture,
 }
 
diff --git a/node-graph/graph-craft/src/document/value.rs b/node-graph/graph-craft/src/document/value.rs
@@ -441,11 +441,16 @@ pub enum RenderOutputType {
 	CanvasFrame(SurfaceFrame),
 	#[serde(skip)]
 	Texture(ImageTexture),
+	#[serde(skip)]
+	Buffer {
+		data: Vec<u8>,
+		width: u32,
+		height: u32,
+	},
 	Svg {
 		svg: String,
 		image_data: Vec<(u64, Image<Color>)>,
 	},
-	Image(Vec<u8>),
 }
 
 impl Hash for RenderOutput {
diff --git a/node-graph/gstd/src/render_node.rs b/node-graph/gstd/src/render_node.rs
@@ -3,6 +3,7 @@ pub use graph_craft::document::value::RenderOutputType;
 pub use graph_craft::wasm_application_io::*;
 use graphene_application_io::{ApplicationIo, ExportFormat, ImageTexture, RenderConfig, SurfaceFrame};
 use graphene_core::gradient::GradientStops;
+use graphene_core::ops::Convert;
 use graphene_core::raster::image::Image;
 use graphene_core::raster_types::{CPU, Raster};
 use graphene_core::table::Table;
@@ -44,7 +45,6 @@ async fn render_intermediate<'a: 'n, T: 'static + Render + WasmNotSend + Send +
 	data: impl Node<Context<'static>, Output = T>,
 	editor_api: impl Node<Context<'static>, Output = &'a WasmEditorApi>,
 ) -> RenderIntermediate {
-	let mut render = SvgRender::new();
 	let render_params = ctx
 		.vararg(0)
 		.expect("Did not find var args")
@@ -61,7 +61,9 @@ async fn render_intermediate<'a: 'n, T: 'static + Render + WasmNotSend + Send +
 
 	let editor_api = editor_api.eval(None).await;
 
-	if !render_params.for_export && editor_api.editor_preferences.use_vello() && matches!(render_params.render_output_type, graphene_svg_renderer::RenderOutputType::Vello) {
+	if (!render_params.for_export && editor_api.editor_preferences.use_vello() && matches!(render_params.render_output_type, graphene_svg_renderer::RenderOutputType::Texture))
+		|| matches!(render_params.render_output_type, RenderOutputTypeRequest::Buffer)
+	{
 		let mut scene = vello::Scene::new();
 
 		let mut context = wgpu_executor::RenderContext::default();
@@ -73,6 +75,8 @@ async fn render_intermediate<'a: 'n, T: 'static + Render + WasmNotSend + Send +
 			contains_artboard,
 		}
 	} else {
+		let mut render = SvgRender::new();
+
 		data.render_svg(&mut render, render_params);
 
 		RenderIntermediate {
@@ -93,11 +97,11 @@ async fn create_context<'a: 'n>(
 
 	let render_output_type = match render_config.export_format {
 		ExportFormat::Svg => RenderOutputTypeRequest::Svg,
-		ExportFormat::Png { .. } => todo!(),
-		ExportFormat::Jpeg => todo!(),
-		ExportFormat::Canvas => RenderOutputTypeRequest::Vello,
-		ExportFormat::Texture => RenderOutputTypeRequest::Vello,
+		ExportFormat::Buffer => RenderOutputTypeRequest::Buffer,
+		ExportFormat::Texture => RenderOutputTypeRequest::Texture,
+		ExportFormat::Canvas => RenderOutputTypeRequest::Texture,
 	};
+
 	let render_params = RenderParams {
 		render_mode: render_config.render_mode,
 		hide_artboards: render_config.hide_artboards,
@@ -106,6 +110,7 @@ async fn create_context<'a: 'n>(
 		footprint: Footprint::default(),
 		..Default::default()
 	};
+
 	let ctx = OwnedContextImpl::default()
 		.with_footprint(footprint)
 		.with_real_time(render_config.time.time)
@@ -173,7 +178,7 @@ async fn render<'a: 'n>(
 				image_data: svg_renderer.image_data,
 			}
 		}
-		(RenderOutputTypeRequest::Vello, RenderIntermediateType::Vello(vello_data)) => {
+		(render_output_request_type, 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");
 			};
@@ -198,6 +203,23 @@ async fn render<'a: 'n>(
 			if !contains_artboard && !render_params.hide_artboards {
 				background = Color::WHITE;
 			}
+
+			if matches!(render_output_request_type, RenderOutputTypeRequest::Buffer) {
+				let texture = exec
+					.render_vello_scene_to_texture(&scene, footprint.resolution, context, background)
+					.await
+					.expect("Failed to render Vello scene");
+
+				let raster_cpu = Raster::new_gpu(texture).convert(Footprint::BOUNDLESS, exec).await;
+
+				let (data, width, height) = raster_cpu.to_flat_u8();
+
+				return RenderOutput {
+					data: RenderOutputType::Buffer { data, width, height },
+					metadata,
+				};
+			}
+
 			if let Some(surface_handle) = surface_handle {
 				exec.render_vello_scene(&scene, &surface_handle, footprint.resolution, context, background)
 					.await
diff --git a/node-graph/gsvg-renderer/src/renderer.rs b/node-graph/gsvg-renderer/src/renderer.rs
@@ -160,7 +160,8 @@ pub struct RenderContext {
 pub enum RenderOutputType {
 	#[default]
 	Svg,
-	Vello,
+	Texture,
+	Buffer,
 }
 
 /// Static state used whilst rendering
diff --git a/node-graph/wgpu-executor/src/lib.rs b/node-graph/wgpu-executor/src/lib.rs
@@ -124,7 +124,7 @@ impl WgpuExecutor {
 				mip_level_count: 1,
 				sample_count: 1,
 				dimension: wgpu::TextureDimension::D2,
-				usage: wgpu::TextureUsages::STORAGE_BINDING | wgpu::TextureUsages::TEXTURE_BINDING,
+				usage: wgpu::TextureUsages::STORAGE_BINDING | wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_SRC,
 				format: VELLO_SURFACE_FORMAT,
 				view_formats: &[],
 			});
@@ -210,6 +210,8 @@ impl WgpuExecutor {
 	}
 }
 
+pub use wgpu::Texture as WgpuTexture;
+
 pub type WindowHandle = Arc<SurfaceHandle<Window>>;
 
 #[node_macro::node(skip_impl)]

Original file line number	Diff line number	Diff line change
`@@ -135,3 +135,8 @@ pub enum Platform {`
`135`	`135`	`Mac,`
`136`	`136`	`Linux,`
`137`	`137`	`}`
	`138`	`+`
	`139`	`+pub enum ExportType {`
	`140`	`+ Png,`
	`141`	`+ Jpg,`
	`142`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -160,7 +160,8 @@ pub struct RenderContext {`
`160`	`160`	`pub enum RenderOutputType {`
`161`	`161`	`#[default]`
`162`	`162`	`Svg,`
`163`		`- Vello,`
	`163`	`+ Texture,`
	`164`	`+ Buffer,`
`164`	`165`	`}`
`165`	`166`
`166`	`167`	`/// Static state used whilst rendering`