Restructure node crates (#3384)

* Restructure node-graph folder

* Fix wasm compilation

* Move node definitions out of *-types crates

* Cleanup

* Fix warnings

* Fix warnings

* Start adding migrations

* Add migrations and move memo nodes to gcore

* Move nodes/gsvg-render -> rendering

* Replace some hard coded identifiers and fix automatic conversion

* Fix Vec2Value node migration

* Fix formatting

* Add more migrations

* Cleanup features

* Fix core_types::raster import

* Update demo artwork (to make profile ci work)

* Move *-types to node-graph/libraries folder

* Add missing node migrations

* Migrate more nodes

* Remove impure memo node

* More fixes and remove warning

* Migrate context and add a few missing migrations

---------

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

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

@@ -0,0 +1,27 @@
+use core_types::NodeIO;
+use core_types::WasmNotSend;
+pub use core_types::registry::{DowncastBothNode, DynAnyNode, FutureWrapperNode, PanicNode};
+pub use core_types::{Node, generic, ops};
+use dyn_any::StaticType;
+pub use graph_craft::proto::{Any, NodeContainer, TypeErasedBox, TypeErasedNode};
+use graph_craft::proto::{FutureAny, SharedNodeContainer};
+
+pub trait IntoTypeErasedNode<'n> {
+	fn into_type_erased(self) -> TypeErasedBox<'n>;
+}
+
+impl<'n, N: 'n> IntoTypeErasedNode<'n> for N
+where
+	N: for<'i> NodeIO<'i, Any<'i>, Output = FutureAny<'i>> + Sync + WasmNotSend,
+{
+	fn into_type_erased(self) -> TypeErasedBox<'n> {
+		Box::new(self)
+	}
+}
+
+pub fn input_node<O: StaticType>(n: SharedNodeContainer) -> DowncastBothNode<(), O> {
+	downcast_node(n)
+}
+pub fn downcast_node<I: StaticType, O: StaticType>(n: SharedNodeContainer) -> DowncastBothNode<I, O> {
+	DowncastBothNode::new(n)
+}

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

@@ -0,0 +1,117 @@
+pub mod any;
+pub mod render_node;
+pub mod text;
+#[cfg(feature = "wasm")]
+pub mod wasm_application_io;
+
+pub use blending_nodes;
+pub use brush_nodes as brush;
+pub use core_types::*;
+pub use graphene_application_io as application_io;
+pub use graphene_core;
+pub use graphic_nodes;
+pub use math_nodes;
+pub use path_bool_nodes as path_bool;
+pub use raster_nodes;
+pub use text_nodes;
+pub use transform_nodes;
+pub use vector_nodes;
+pub use vector_types;
+
+/// Backward compatibility re-exports
+pub mod vector {
+	pub use graphic_types::Vector;
+	pub use vector_types::vector::{VectorModification, VectorModificationType, misc, style};
+	pub use vector_types::*;
+
+	// Re-export commonly used types and submodules
+	pub use vector_types::vector::algorithms;
+	pub use vector_types::vector::click_target;
+	pub use vector_types::vector::misc::HandleId;
+	pub use vector_types::vector::{PointId, RegionId, SegmentId, StrokeId};
+	pub use vector_types::vector::{deserialize_hashmap, serialize_hashmap};
+
+	// Re-export HandleExt trait and NoHashBuilder
+	pub use vector_types::vector::HandleExt;
+	pub use vector_types::vector::NoHashBuilder;
+
+	// Re-export vector node modules and functions
+	pub use vector_nodes::*;
+}
+
+pub mod graphic {
+	pub use graphic_nodes::graphic::*;
+	pub use graphic_types::Artboard;
+	pub use graphic_types::graphic::*;
+}
+
+pub mod artboard {
+	pub use graphic_nodes::artboard::*;
+	pub use graphic_types::artboard::*;
+}
+
+pub mod subpath {
+	pub use vector_types::subpath::*;
+}
+
+pub mod gradient {
+	pub use vector_types::GradientStops;
+}
+
+pub mod transform {
+	pub use core_types::transform::*;
+	pub use vector_types::ReferencePoint;
+}
+
+pub mod math {
+	pub use core_types::math::quad;
+
+	pub mod math_ext {
+		pub use vector_types::{QuadExt, RectExt};
+	}
+}
+
+pub mod logic {
+	pub use graphene_core::logic::*;
+}
+
+pub use graphene_core::debug;
+
+// Re-export graphene_core modules for backward compatibility
+pub mod ops {
+	pub use core_types::ops::*;
+	pub use graphene_core::ops::*;
+}
+
+pub mod extract_xy {
+	pub use graphene_core::extract_xy::*;
+}
+
+pub mod animation {
+	pub use graphene_core::animation::*;
+}
+
+// Re-export at top level for convenience
+pub use graphic_types::{Artboard, Graphic, Vector};
+
+/// stop gap solutions until all paths have been replaced with their absolute ones
+pub mod renderer {
+	pub use core_types::math::quad::Quad;
+	pub use core_types::math::rect::Rect;
+	pub use rendering::*;
+}
+
+pub mod raster {
+	pub use graphic_types::raster_types::*;
+	pub use raster_nodes::adjustments::*;
+	pub use raster_nodes::*;
+}
+
+pub mod raster_types {
+	pub use graphic_types::raster_types::*;
+}
+
+pub mod memo {
+	pub use core_types::memo::*;
+	pub use graphene_core::memo::*;
+}

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

@@ -0,0 +1,230 @@
+use core_types::table::Table;
+use core_types::transform::Footprint;
+use core_types::{CloneVarArgs, ExtractAll, ExtractVarArgs};
+use core_types::{Color, Context, Ctx, ExtractFootprint, OwnedContextImpl, WasmNotSend};
+use graph_craft::document::value::RenderOutput;
+pub use graph_craft::document::value::RenderOutputType;
+pub use graph_craft::wasm_application_io::*;
+use graphene_application_io::{ApplicationIo, ExportFormat, ImageTexture, RenderConfig, SurfaceFrame};
+use graphic_types::Artboard;
+use graphic_types::Graphic;
+use graphic_types::Vector;
+use graphic_types::raster_types::Image;
+use graphic_types::raster_types::{CPU, Raster};
+use rendering::{Render, RenderOutputType as RenderOutputTypeRequest, RenderParams, RenderSvgSegmentList, SvgRender, format_transform_matrix};
+use rendering::{RenderMetadata, SvgSegment};
+use std::sync::Arc;
+use vector_types::GradientStops;
+use wgpu_executor::RenderContext;
+
+/// List of (canvas id, image data) pairs for embedding images as canvases in the final SVG string.
+type ImageData = Vec<(u64, Image<Color>)>;
+
+#[derive(Clone, dyn_any::DynAny)]
+pub enum RenderIntermediateType {
+	Vello(Arc<(vello::Scene, RenderContext)>),
+	Svg(Arc<(String, ImageData, String)>),
+}
+#[derive(Clone, dyn_any::DynAny)]
+pub struct RenderIntermediate {
+	ty: RenderIntermediateType,
+	metadata: RenderMetadata,
+	contains_artboard: bool,
+}
+
+#[node_macro::node(category(""))]
+async fn render_intermediate<'a: 'n, T: 'static + Render + WasmNotSend + Send + Sync>(
+	ctx: impl Ctx + ExtractVarArgs + ExtractAll + CloneVarArgs,
+	#[implementations(
+		Context -> Table<Artboard>,
+		Context -> Table<Graphic>,
+		Context -> Table<Vector>,
+		Context -> Table<Raster<CPU>>,
+		Context -> Table<Color>,
+		Context -> Table<GradientStops>,
+	)]
+	data: impl Node<Context<'static>, Output = T>,
+) -> RenderIntermediate {
+	let render_params = ctx
+		.vararg(0)
+		.expect("Did not find var args")
+		.downcast_ref::<RenderParams>()
+		.expect("Downcasting render params yielded invalid type");
+
+	let ctx = OwnedContextImpl::from(ctx.clone()).into_context();
+	let data = data.eval(ctx).await;
+
+	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();
+
+			let mut context = wgpu_executor::RenderContext::default();
+			data.render_to_vello(&mut scene, Default::default(), &mut context, render_params);
+
+			RenderIntermediate {
+				ty: RenderIntermediateType::Vello(Arc::new((scene, context))),
+				metadata,
+				contains_artboard,
+			}
+		}
+		RenderOutputTypeRequest::Svg => {
+			let mut render = SvgRender::new();
+
+			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()))),
+				metadata,
+				contains_artboard,
+			}
+		}
+	}
+}
+
+#[node_macro::node(category(""))]
+async fn create_context<'a: 'n>(
+	// Context injections are defined in the wrap_network_in_scope function
+	render_config: RenderConfig,
+	data: impl Node<Context<'static>, Output = RenderOutput>,
+) -> RenderOutput {
+	let footprint = render_config.viewport;
+
+	let render_output_type = match render_config.export_format {
+		ExportFormat::Svg => RenderOutputTypeRequest::Svg,
+		ExportFormat::Raster => RenderOutputTypeRequest::Vello,
+	};
+
+	let render_params = RenderParams {
+		render_mode: render_config.render_mode,
+		hide_artboards: render_config.hide_artboards,
+		for_export: render_config.for_export,
+		render_output_type,
+		footprint: Footprint::default(),
+		scale: render_config.scale,
+		..Default::default()
+	};
+
+	let ctx = OwnedContextImpl::default()
+		.with_footprint(footprint)
+		.with_real_time(render_config.time.time)
+		.with_animation_time(render_config.time.animation_time.as_secs_f64())
+		.with_vararg(Box::new(render_params))
+		.into_context();
+
+	data.eval(ctx).await
+}
+
+#[node_macro::node(category(""))]
+async fn render<'a: 'n>(
+	ctx: impl Ctx + ExtractFootprint + ExtractVarArgs,
+	editor_api: &'a WasmEditorApi,
+	data: RenderIntermediate,
+	_surface_handle: impl Node<Context<'static>, Output = Option<wgpu_executor::WgpuSurface>>,
+) -> 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 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();
+			if !contains_artboard && !render_params.hide_artboards {
+				rendering.leaf_tag("rect", |attributes| {
+					attributes.push("x", "0");
+					attributes.push("y", "0");
+					attributes.push("width", footprint.resolution.x.to_string());
+					attributes.push("height", footprint.resolution.y.to_string());
+					let matrix = format_transform_matrix(footprint.transform.inverse());
+					if !matrix.is_empty() {
+						attributes.push("transform", matrix);
+					}
+					attributes.push("fill", "white");
+				});
+			}
+			rendering.svg.push(SvgSegment::from(svg_data.0.clone()));
+			rendering.image_data = svg_data.1.clone();
+			rendering.svg_defs = svg_data.2.clone();
+
+			rendering.wrap_with_transform(footprint.transform, Some(footprint.resolution.as_dvec2()));
+			RenderOutputType::Svg {
+				svg: rendering.svg.to_svg_string(),
+				image_data: rendering.image_data,
+			}
+		}
+		(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 surface_handle = if cfg!(all(feature = "vello", target_family = "wasm")) {
+				_surface_handle.eval(None).await
+			} else {
+				None
+			};
+
+			// When rendering to a surface, we do not want to apply the scale
+			let scale = if surface_handle.is_none() { render_params.scale } else { 1. };
+
+			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();
+			scene.append(child, Some(footprint_transform_vello));
+
+			let resolution = (footprint.resolution.as_dvec2() * scale).as_uvec2();
+
+			// 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
+			let scaled_infinite_transform = vello::kurbo::Affine::scale_non_uniform(resolution.x as f64, resolution.y as f64);
+			let encoding = scene.encoding_mut();
+			for transform in encoding.transforms.iter_mut() {
+				if transform.matrix[0] == f32::INFINITY {
+					*transform = vello_encoding::Transform::from_kurbo(&scaled_infinite_transform);
+				}
+			}
+
+			let mut background = Color::from_rgb8_srgb(0x22, 0x22, 0x22);
+			if !contains_artboard && !render_params.hide_artboards {
+				background = Color::WHITE;
+			}
+
+			if let Some(surface_handle) = surface_handle {
+				exec.render_vello_scene(&scene, &surface_handle, resolution, context, background)
+					.await
+					.expect("Failed to render Vello scene");
+
+				let frame = SurfaceFrame {
+					surface_id: surface_handle.window_id,
+					// TODO: Find a cleaner way to get the unscaled resolution here.
+					// This is done because the surface frame (canvas) is in logical pixels, not physical pixels.
+					resolution,
+					transform: glam::DAffine2::IDENTITY,
+				};
+
+				RenderOutputType::CanvasFrame(frame)
+			} else {
+				let texture = exec.render_vello_scene_to_texture(&scene, resolution, context, background).await.expect("Failed to render Vello scene");
+
+				RenderOutputType::Texture(ImageTexture { texture })
+			}
+		}
+		_ => unreachable!("Render node did not receive its requested data type"),
+	};
+	RenderOutput { data, metadata }
+}

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

@@ -0,0 +1,43 @@
+use core_types::{Ctx, table::Table};
+use graph_craft::wasm_application_io::WasmEditorApi;
+use graphic_types::Vector;
+pub use text_nodes::*;
+
+#[node_macro::node(category(""))]
+fn text<'i: 'n>(
+	_: impl Ctx,
+	editor: &'i WasmEditorApi,
+	text: String,
+	font_name: Font,
+	#[unit(" px")]
+	#[default(24.)]
+	font_size: f64,
+	#[unit("x")]
+	#[default(1.2)]
+	line_height_ratio: f64,
+	#[unit(" px")]
+	#[default(0.)]
+	character_spacing: f64,
+	#[unit(" px")] max_width: Option<f64>,
+	#[unit(" px")] max_height: Option<f64>,
+	/// Faux italic.
+	#[unit("°")]
+	#[default(0.)]
+	tilt: f64,
+	align: TextAlign,
+	/// Splits each text glyph into its own row in the table of vector geometry.
+	#[default(false)]
+	per_glyph_instances: bool,
+) -> Table<Vector> {
+	let typesetting = TypesettingConfig {
+		font_size,
+		line_height_ratio,
+		character_spacing,
+		max_width,
+		max_height,
+		tilt,
+		align,
+	};
+
+	to_path(&text, &font_name, &editor.font_cache, typesetting, per_glyph_instances)
+}

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

@@ -0,0 +1,213 @@
+#[cfg(target_family = "wasm")]
+use base64::Engine;
+#[cfg(target_family = "wasm")]
+use core_types::WasmNotSend;
+#[cfg(target_family = "wasm")]
+use core_types::math::bbox::Bbox;
+use core_types::table::Table;
+#[cfg(target_family = "wasm")]
+use core_types::transform::Footprint;
+use core_types::{Color, Ctx};
+pub use graph_craft::document::value::RenderOutputType;
+pub use graph_craft::wasm_application_io::*;
+use graphene_application_io::ApplicationIo;
+#[cfg(target_family = "wasm")]
+use graphic_types::Graphic;
+#[cfg(target_family = "wasm")]
+use graphic_types::Vector;
+use graphic_types::raster_types::Image;
+use graphic_types::raster_types::{CPU, Raster};
+#[cfg(target_family = "wasm")]
+use graphic_types::vector_types::gradient::GradientStops;
+#[cfg(target_family = "wasm")]
+use rendering::{Render, RenderParams, RenderSvgSegmentList, SvgRender};
+use std::sync::Arc;
+#[cfg(target_family = "wasm")]
+use wasm_bindgen::JsCast;
+#[cfg(target_family = "wasm")]
+use web_sys::{CanvasRenderingContext2d, HtmlCanvasElement};
+
+#[cfg(feature = "wgpu")]
+#[node_macro::node(category("Debug: GPU"))]
+async fn create_surface<'a: 'n>(_: impl Ctx, editor: &'a WasmEditorApi) -> Arc<WasmSurfaceHandle> {
+	Arc::new(editor.application_io.as_ref().unwrap().create_window())
+}
+
+#[node_macro::node(category("Web Request"))]
+async fn get_request(_: impl Ctx, _primary: (), #[name("URL")] url: String, discard_result: bool) -> String {
+	#[cfg(target_family = "wasm")]
+	{
+		if discard_result {
+			wasm_bindgen_futures::spawn_local(async move {
+				let _ = reqwest::get(url).await;
+			});
+			return String::new();
+		}
+	}
+	#[cfg(not(target_family = "wasm"))]
+	{
+		#[cfg(feature = "tokio")]
+		if discard_result {
+			tokio::spawn(async move {
+				let _ = reqwest::get(url).await;
+			});
+			return String::new();
+		}
+		#[cfg(not(feature = "tokio"))]
+		if discard_result {
+			return String::new();
+		}
+	}
+
+	let Ok(response) = reqwest::get(url).await else { return String::new() };
+	response.text().await.ok().unwrap_or_default()
+}
+
+#[node_macro::node(category("Web Request"))]
+async fn post_request(_: impl Ctx, _primary: (), #[name("URL")] url: String, body: Vec<u8>, discard_result: bool) -> String {
+	#[cfg(target_family = "wasm")]
+	{
+		if discard_result {
+			wasm_bindgen_futures::spawn_local(async move {
+				let _ = reqwest::Client::new().post(url).body(body).header("Content-Type", "application/octet-stream").send().await;
+			});
+			return String::new();
+		}
+	}
+	#[cfg(not(target_family = "wasm"))]
+	{
+		#[cfg(feature = "tokio")]
+		if discard_result {
+			let url = url.clone();
+			let body = body.clone();
+			tokio::spawn(async move {
+				let _ = reqwest::Client::new().post(url).body(body).header("Content-Type", "application/octet-stream").send().await;
+			});
+			return String::new();
+		}
+		#[cfg(not(feature = "tokio"))]
+		if discard_result {
+			return String::new();
+		}
+	}
+
+	let Ok(response) = reqwest::Client::new().post(url).body(body).header("Content-Type", "application/octet-stream").send().await else {
+		return String::new();
+	};
+	response.text().await.ok().unwrap_or_default()
+}
+
+#[node_macro::node(category("Web Request"), name("String to Bytes"))]
+fn string_to_bytes(_: impl Ctx, string: String) -> Vec<u8> {
+	string.into_bytes()
+}
+
+#[node_macro::node(category("Web Request"), name("Image to Bytes"))]
+fn image_to_bytes(_: impl Ctx, image: Table<Raster<CPU>>) -> Vec<u8> {
+	let Some(image) = image.iter().next() else { return vec![] };
+	image.element.data.iter().flat_map(|color| color.to_rgb8_srgb().into_iter()).collect::<Vec<u8>>()
+}
+
+#[node_macro::node(category("Web Request"))]
+async fn load_resource<'a: 'n>(_: impl Ctx, _primary: (), #[scope("editor-api")] editor: &'a WasmEditorApi, #[name("URL")] url: String) -> Arc<[u8]> {
+	let Some(api) = editor.application_io.as_ref() else {
+		return Arc::from(include_bytes!("../../../graph-craft/src/null.png").to_vec());
+	};
+	let Ok(data) = api.load_resource(url) else {
+		return Arc::from(include_bytes!("../../../graph-craft/src/null.png").to_vec());
+	};
+	let Ok(data) = data.await else {
+		return Arc::from(include_bytes!("../../../graph-craft/src/null.png").to_vec());
+	};
+
+	data
+}
+
+#[node_macro::node(category("Web Request"))]
+fn decode_image(_: impl Ctx, data: Arc<[u8]>) -> Table<Raster<CPU>> {
+	let Some(image) = image::load_from_memory(data.as_ref()).ok() else {
+		return Table::new();
+	};
+	let image = image.to_rgba32f();
+	let image = Image {
+		data: image
+			.chunks(4)
+			.map(|pixel| Color::from_unassociated_alpha(pixel[0], pixel[1], pixel[2], pixel[3]).to_linear_srgb())
+			.collect(),
+		width: image.width(),
+		height: image.height(),
+		..Default::default()
+	};
+
+	Table::new_from_element(Raster::new_cpu(image))
+}
+
+#[cfg(target_family = "wasm")]
+#[node_macro::node(category(""))]
+async fn rasterize<T: WasmNotSend + 'n>(
+	_: impl Ctx,
+	#[implementations(
+		Table<Vector>,
+		Table<Raster<CPU>>,
+		Table<Graphic>,
+		Table<Color>,
+		Table<GradientStops>,
+	)]
+	mut data: Table<T>,
+	footprint: Footprint,
+	surface_handle: Arc<graphene_application_io::SurfaceHandle<HtmlCanvasElement>>,
+) -> Table<Raster<CPU>>
+where
+	Table<T>: Render,
+{
+	use core_types::table::TableRow;
+
+	if footprint.transform.matrix2.determinant() == 0. {
+		log::trace!("Invalid footprint received for rasterization");
+		return Table::new();
+	}
+
+	let mut render = SvgRender::new();
+	let aabb = Bbox::from_transform(footprint.transform).to_axis_aligned_bbox();
+	let size = aabb.size();
+	let resolution = footprint.resolution;
+	let render_params = RenderParams {
+		footprint,
+		for_export: true,
+		..Default::default()
+	};
+
+	for row in data.iter_mut() {
+		*row.transform = glam::DAffine2::from_translation(-aabb.start) * *row.transform;
+	}
+	data.render_svg(&mut render, &render_params);
+	render.format_svg(glam::DVec2::ZERO, size);
+	let svg_string = render.svg.to_svg_string();
+
+	let canvas = &surface_handle.surface;
+	canvas.set_width(resolution.x);
+	canvas.set_height(resolution.y);
+
+	let context = canvas.get_context("2d").unwrap().unwrap().dyn_into::<CanvasRenderingContext2d>().unwrap();
+
+	let preamble = "data:image/svg+xml;base64,";
+	let mut base64_string = String::with_capacity(preamble.len() + svg_string.len() * 4);
+	base64_string.push_str(preamble);
+	base64::engine::general_purpose::STANDARD.encode_string(svg_string, &mut base64_string);
+
+	let image_data = web_sys::HtmlImageElement::new().unwrap();
+	image_data.set_src(base64_string.as_str());
+	wasm_bindgen_futures::JsFuture::from(image_data.decode()).await.unwrap();
+	context
+		.draw_image_with_html_image_element_and_dw_and_dh(&image_data, 0., 0., resolution.x as f64, resolution.y as f64)
+		.unwrap();
+
+	let rasterized = context.get_image_data(0., 0., resolution.x as f64, resolution.y as f64).unwrap();
+
+	let image = Image::from_image_data(&rasterized.data().0, resolution.x as u32, resolution.y as u32);
+	Table::new_from_row(TableRow {
+		element: Raster::new_cpu(image),
+		transform: footprint.transform,
+		..Default::default()
+	})
+}