Render List<String> as raw paths in SVG and Vello mode instead of ever becoming List<Vector>

editor/src/messages/portfolio/document/data_panel/data_panel_message_handler.rs

@@ -336,6 +336,7 @@ impl TableItemLayout for Graphic {
 			Self::RasterGPU(list) => list.identifier(),
 			Self::Color(list) => list.identifier(),
 			Self::Gradient(list) => list.identifier(),
+			Self::Text(list) => list.identifier(),
 		}
 	}
 	// Don't put a breadcrumb for Graphic
@@ -350,6 +351,7 @@ impl TableItemLayout for Graphic {
 			Self::RasterGPU(list) => list.layout_with_breadcrumb(data),
 			Self::Color(list) => list.layout_with_breadcrumb(data),
 			Self::Gradient(list) => list.layout_with_breadcrumb(data),
+			Self::Text(list) => list.layout_with_breadcrumb(data),
 		}
 	}
 }

editor/src/messages/tool/common_functionality/graph_modification_utils.rs

@@ -427,6 +427,10 @@ pub fn get_text_id(layer: LayerNodeIdentifier, network_interface: &NodeNetworkIn
 	NodeGraphLayer::new(layer, network_interface).upstream_node_id_from_name(&DefinitionIdentifier::ProtoNode(graphene_std::text::text::IDENTIFIER))
 }
 
+pub fn get_text_layer_id(layer: LayerNodeIdentifier, network_interface: &NodeNetworkInterface) -> Option<NodeId> {
+	NodeGraphLayer::new(layer, network_interface).upstream_node_id_from_name(&DefinitionIdentifier::ProtoNode(graphene_std::text::text_layer::IDENTIFIER))
+}
+
 pub fn get_grid_id(layer: LayerNodeIdentifier, network_interface: &NodeNetworkInterface) -> Option<NodeId> {
 	NodeGraphLayer::new(layer, network_interface).upstream_node_id_from_name(&DefinitionIdentifier::ProtoNode(graphene_std::vector::generator_nodes::grid::IDENTIFIER))
 }
@@ -484,6 +488,56 @@ pub fn get_text(layer: LayerNodeIdentifier, network_interface: &NodeNetworkInter
 	Some((text, font, typesetting, per_glyph_items))
 }
 
+/// Gets properties from the Text Layer node
+pub fn get_text_layer(layer: LayerNodeIdentifier, network_interface: &NodeNetworkInterface) -> Option<(&String, &Font, TypesettingConfig)> {
+	let inputs = NodeGraphLayer::new(layer, network_interface).find_node_inputs(&DefinitionIdentifier::ProtoNode(graphene_std::text::text_layer::IDENTIFIER))?;
+
+	let Some(TaggedValue::String(text)) = &inputs[graphene_std::text::text_layer::TextInput::INDEX].as_value() else {
+		return None;
+	};
+	let Some(TaggedValue::Font(font)) = &inputs[graphene_std::text::text_layer::FontInput::INDEX].as_value() else {
+		return None;
+	};
+	let Some(&TaggedValue::F64(font_size)) = inputs[graphene_std::text::text_layer::SizeInput::INDEX].as_value() else {
+		return None;
+	};
+	let Some(&TaggedValue::F64(line_height_ratio)) = inputs[graphene_std::text::text_layer::LineHeightInput::INDEX].as_value() else {
+		return None;
+	};
+	let Some(&TaggedValue::F64(character_spacing)) = inputs[graphene_std::text::text_layer::CharacterSpacingInput::INDEX].as_value() else {
+		return None;
+	};
+	let Some(&TaggedValue::Bool(has_max_width)) = inputs[graphene_std::text::text_layer::HasMaxWidthInput::INDEX].as_value() else {
+		return None;
+	};
+	let Some(&TaggedValue::F64(max_width)) = inputs[graphene_std::text::text_layer::MaxWidthInput::INDEX].as_value() else {
+		return None;
+	};
+	let Some(&TaggedValue::Bool(has_max_height)) = inputs[graphene_std::text::text_layer::HasMaxHeightInput::INDEX].as_value() else {
+		return None;
+	};
+	let Some(&TaggedValue::F64(max_height)) = inputs[graphene_std::text::text_layer::MaxHeightInput::INDEX].as_value() else {
+		return None;
+	};
+	let Some(&TaggedValue::F64(tilt)) = inputs[graphene_std::text::text_layer::TiltInput::INDEX].as_value() else {
+		return None;
+	};
+	let Some(&TaggedValue::TextAlign(align)) = inputs[graphene_std::text::text_layer::AlignInput::INDEX].as_value() else {
+		return None;
+	};
+
+	let typesetting = TypesettingConfig {
+		font_size,
+		line_height_ratio,
+		max_width: has_max_width.then_some(max_width),
+		max_height: has_max_height.then_some(max_height),
+		character_spacing,
+		tilt,
+		align,
+	};
+	Some((text, font, typesetting))
+}
+
 pub fn get_stroke_width(layer: LayerNodeIdentifier, network_interface: &NodeNetworkInterface) -> Option<f64> {
 	let weight_node_input_index = graphene_std::vector::stroke::WeightInput::INDEX;
 	if let TaggedValue::F64(width) = NodeGraphLayer::new(layer, network_interface).find_input(&DefinitionIdentifier::ProtoNode(graphene_std::vector::stroke::IDENTIFIER), weight_node_input_index)? {

editor/src/node_graph_executor/runtime.rs

@@ -15,7 +15,7 @@ use graphene_std::ops::Convert;
 #[cfg(all(target_family = "wasm", feature = "gpu", feature = "wasm"))]
 use graphene_std::platform_application_io::canvas_utils::{Canvas, CanvasSurface, CanvasSurfaceHandle};
 use graphene_std::raster_types::Raster;
-use graphene_std::renderer::{Render, RenderParams, RenderSvgSegmentList, SvgRender, SvgSegment};
+use graphene_std::renderer::{Render, RenderParams, RenderSvgSegmentList, SvgRender, SvgSegment, set_render_fonts};
 use graphene_std::text::FontCache;
 use graphene_std::transform::RenderQuality;
 use graphene_std::vector::Vector;
@@ -200,6 +200,7 @@ impl NodeRuntime {
 		for request in requests {
 			match request {
 				GraphRuntimeRequest::FontCacheUpdate(font_cache) => {
+					set_render_fonts(font_cache.iter_fonts().map(|(family, style, bytes)| (family.to_string(), style.to_string(), bytes)));
 					self.editor_api = PlatformEditorApi {
 						font_cache,
 						application_io: self.editor_api.application_io.clone(),

node-graph/libraries/core-types/src/lib.rs

@@ -26,7 +26,8 @@ pub use graphene_hash;
 pub use graphene_hash::CacheHash;
 pub use list::{
 	ATTR_BACKGROUND, ATTR_BLEND_MODE, ATTR_CLIP, ATTR_CLIPPING_MASK, ATTR_DIMENSIONS, ATTR_EDITOR_CLICK_TARGET, ATTR_EDITOR_LAYER_PATH, ATTR_EDITOR_MERGED_LAYERS, ATTR_EDITOR_TEXT_FRAME, ATTR_END,
-	ATTR_GRADIENT_TYPE, ATTR_LOCATION, ATTR_NAME, ATTR_OPACITY, ATTR_OPACITY_FILL, ATTR_SPREAD_METHOD, ATTR_START, ATTR_TRANSFORM, ATTR_TYPE,
+	ATTR_FONT_FAMILY, ATTR_FONT_SIZE, ATTR_FONT_STYLE, ATTR_GRADIENT_TYPE, ATTR_LOCATION, ATTR_NAME, ATTR_OPACITY, ATTR_OPACITY_FILL, ATTR_SPREAD_METHOD, ATTR_START, ATTR_TEXT_ALIGN,
+	ATTR_TEXT_CHARACTER_SPACING, ATTR_TEXT_FONT, ATTR_TEXT_LINE_HEIGHT, ATTR_TEXT_MAX_HEIGHT, ATTR_TEXT_MAX_WIDTH, ATTR_TEXT_TILT, ATTR_TRANSFORM, ATTR_TYPE,
 };
 pub use memo::MemoHash;
 pub use no_std_types::AsU32;

node-graph/libraries/core-types/src/list.rs

@@ -77,6 +77,36 @@ pub const ATTR_SPREAD_METHOD: &str = "spread_method";
 /// Gradient's `GradientType` (`Linear` or `Radial`).
 pub const ATTR_GRADIENT_TYPE: &str = "gradient_type";
 
+/// Text item's font family (`String`, implicit default `"Lato"`).
+pub const ATTR_FONT_FAMILY: &str = "font_family";
+
+/// Text item's font style (`String`, implicit default `"Regular"`).
+pub const ATTR_FONT_STYLE: &str = "font_style";
+
+/// Text item's font size in document-space units (`f64`, implicit default `16.`).
+pub const ATTR_FONT_SIZE: &str = "font_size";
+
+/// Text item's full `Font` struct (family + style). Only set by `text_layer`; used by `text_to_vector` to reconstruct exact glyph paths.
+pub const ATTR_TEXT_FONT: &str = "text_font";
+
+/// Text item's line height ratio relative to the font size (`f64`, implicit default `1.2`). Only stored when it deviates from the default.
+pub const ATTR_TEXT_LINE_HEIGHT: &str = "text_line_height";
+
+/// Text item's extra inter-character spacing in document-space units (`f64`, implicit default `0.0`). Only stored when non-zero.
+pub const ATTR_TEXT_CHARACTER_SPACING: &str = "text_character_spacing";
+
+/// Text item's optional max line-wrap width (`Option<f64>`). Absent = no limit; present = wrap at that width.
+pub const ATTR_TEXT_MAX_WIDTH: &str = "text_max_width";
+
+/// Text item's optional max height cutoff (`Option<f64>`). Absent = no limit; lines whose baseline exceeds this value are not drawn.
+pub const ATTR_TEXT_MAX_HEIGHT: &str = "text_max_height";
+
+/// Text item's faux-italic tilt angle in degrees (`f64`, implicit default `0.0`). Only stored when non-zero.
+pub const ATTR_TEXT_TILT: &str = "text_tilt";
+
+/// Text item's horizontal alignment encoded as a `u8` discriminant of `TextAlign` (0 = AlignLeft, 1 = AlignCenter, 2 = AlignRight, 3–6 = justify variants). Only stored when non-zero.
+pub const ATTR_TEXT_ALIGN: &str = "text_align";
+
 // ========================
 // TRAIT: AnyAttributeValue
 // ========================

node-graph/libraries/core-types/src/render_complexity.rs

@@ -19,3 +19,9 @@ impl RenderComplexity for Color {
 		1
 	}
 }
+
+impl RenderComplexity for String {
+	fn render_complexity(&self) -> usize {
+		1
+	}
+}

node-graph/libraries/graphic-types/src/graphic.rs

@@ -22,6 +22,7 @@ pub enum Graphic {
 	RasterGPU(List<Raster<GPU>>),
 	Color(List<Color>),
 	Gradient(List<GradientStops>),
+	Text(List<String>),
 }
 
 impl Default for Graphic {
@@ -103,6 +104,18 @@ impl From<List<GradientStops>> for Graphic {
 	}
 }
 
+// String
+impl From<String> for Graphic {
+	fn from(text: String) -> Self {
+		Graphic::Text(List::new_from_element(text))
+	}
+}
+impl From<List<String>> for Graphic {
+	fn from(text: List<String>) -> Self {
+		Graphic::Text(text)
+	}
+}
+
 /// Deeply flattens a `List<Graphic>`, collecting only elements matching a specific variant (extracted by `extract_variant`)
 /// and discarding all other non-matching content. Recursion through `Graphic::Graphic` sub-`List`s composes transforms and opacity.
 fn flatten_graphic_list<T>(content: List<Graphic>, extract_variant: fn(Graphic) -> Option<List<T>>) -> List<T> {
@@ -199,6 +212,12 @@ impl TryFromGraphic for GradientStops {
 	}
 }
 
+impl TryFromGraphic for String {
+	fn try_from_graphic(graphic: Graphic) -> Option<List<Self>> {
+		if let Graphic::Text(t) = graphic { Some(t) } else { None }
+	}
+}
+
 // Local trait to convert types to List<Graphic> (avoids orphan rule issues)
 pub trait IntoGraphicList {
 	fn into_graphic_list(self) -> List<Graphic>;
@@ -255,6 +274,17 @@ impl IntoGraphicList for List<GradientStops> {
 	}
 }
 
+impl IntoGraphicList for List<String> {
+	fn into_graphic_list(self) -> List<Graphic> {
+		let layer_path: List<NodeId> = self.attribute_cloned_or_default(ATTR_EDITOR_LAYER_PATH, 0);
+		let mut graphic_list = List::new_from_element(Graphic::Text(self));
+		if !layer_path.is_empty() {
+			graphic_list.set_attribute(ATTR_EDITOR_LAYER_PATH, 0, layer_path);
+		}
+		graphic_list
+	}
+}
+
 impl IntoGraphicList for DAffine2 {
 	fn into_graphic_list(self) -> List<Graphic> {
 		List::new_from_element(Graphic::default())
@@ -324,6 +354,7 @@ impl Graphic {
 			Graphic::RasterGPU(list) => all_clipped(list),
 			Graphic::Color(list) => all_clipped(list),
 			Graphic::Gradient(list) => all_clipped(list),
+			Graphic::Text(list) => all_clipped(list),
 		}
 	}
 
@@ -348,6 +379,7 @@ impl BoundingBox for Graphic {
 			Graphic::Graphic(list) => list.bounding_box(transform, include_stroke),
 			Graphic::Color(list) => list.bounding_box(transform, include_stroke),
 			Graphic::Gradient(list) => list.bounding_box(transform, include_stroke),
+			Graphic::Text(_) => RenderBoundingBox::Infinite,
 		}
 	}
 
@@ -359,6 +391,7 @@ impl BoundingBox for Graphic {
 			Graphic::Graphic(graphic) => graphic.thumbnail_bounding_box(transform, include_stroke),
 			Graphic::Color(color) => color.thumbnail_bounding_box(transform, include_stroke),
 			Graphic::Gradient(gradient) => gradient.thumbnail_bounding_box(transform, include_stroke),
+			Graphic::Text(_) => RenderBoundingBox::Infinite,
 		}
 	}
 }
@@ -388,6 +421,7 @@ impl RenderComplexity for Graphic {
 			Self::RasterGPU(list) => list.render_complexity(),
 			Self::Color(list) => list.render_complexity(),
 			Self::Gradient(list) => list.render_complexity(),
+			Self::Text(list) => list.len(),
 		}
 	}
 }

node-graph/libraries/rendering/Cargo.toml

@@ -27,6 +27,8 @@ vector-types = { workspace = true }
 graphic-types = { workspace = true }
 vello = { workspace = true }
 vello_encoding = { workspace = true }
+parley = { workspace = true }
+skrifa = { workspace = true }
 
 # Optional workspace dependencies
 serde = { workspace = true, optional = true }