WIP: add shear to text node

Author: BKSalman

editor/src/messages/portfolio/document/node_graph/document_node_definitions.rs

@@ -1555,6 +1555,7 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 						NodeInput::value(TaggedValue::F64(TypesettingConfig::default().character_spacing), false),
 						NodeInput::value(TaggedValue::OptionalF64(TypesettingConfig::default().max_width), false),
 						NodeInput::value(TaggedValue::OptionalF64(TypesettingConfig::default().max_height), false),
+						NodeInput::value(TaggedValue::F64(TypesettingConfig::default().shear), false),
 					],
 					..Default::default()
 				},
@@ -1608,6 +1609,17 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 								..Default::default()
 							}),
 						),
+						PropertiesRow::with_override(
+							"Shear",
+							"TODO",
+							WidgetOverride::Number(NumberInputSettings {
+								min: Some(-85.),
+
+								max: Some(85.),
+								unit: Some("°".to_string()),
+								..Default::default()
+							}),
+						),
 					],
 					output_names: vec!["Vector".to_string()],
 					..Default::default()

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

@@ -361,13 +361,15 @@ pub fn get_text(layer: LayerNodeIdentifier, network_interface: &NodeNetworkInter
 	let Some(&TaggedValue::F64(character_spacing)) = inputs[5].as_value() else { return None };
 	let Some(&TaggedValue::OptionalF64(max_width)) = inputs[6].as_value() else { return None };
 	let Some(&TaggedValue::OptionalF64(max_height)) = inputs[7].as_value() else { return None };
+	let Some(&TaggedValue::F64(shear)) = inputs[8].as_value() else { return None };
 
 	let typesetting = TypesettingConfig {
 		font_size,
 		line_height_ratio,
 		max_width,
 		character_spacing,
 		max_height,
+		shear,
 	};
 	Some((text, font, typesetting))
 }

editor/src/messages/tool/tool_messages/text_tool.rs

@@ -35,6 +35,7 @@ pub struct TextOptions {
 	font_name: String,
 	font_style: String,
 	fill: ToolColorOptions,
+	shear: f64,
 }
 
 impl Default for TextOptions {
@@ -46,6 +47,7 @@ impl Default for TextOptions {
 			font_name: graphene_std::consts::DEFAULT_FONT_FAMILY.into(),
 			font_style: graphene_std::consts::DEFAULT_FONT_STYLE.into(),
 			fill: ToolColorOptions::new_primary(),
+			shear: 0.,
 		}
 	}
 }
@@ -784,6 +786,7 @@ impl Fsm for TextToolFsmState {
 						max_width: constraint_size.map(|size| size.x),
 						character_spacing: tool_options.character_spacing,
 						max_height: constraint_size.map(|size| size.y),
+						shear: tool_options.shear,
 					},
 					font: Font::new(tool_options.font_name.clone(), tool_options.font_style.clone()),
 					color: tool_options.fill.active_color(),

node-graph/gcore/src/text/to_path.rs

@@ -1,7 +1,7 @@
 use crate::vector::PointId;
 use bezier_rs::{ManipulatorGroup, Subpath};
 use core::cell::RefCell;
-use glam::DVec2;
+use glam::{DAffine2, DVec2};
 use parley::fontique::Blob;
 use parley::{Alignment, AlignmentOptions, FontContext, GlyphRun, Layout, LayoutContext, LineHeight, PositionedLayoutItem, StyleProperty};
 use skrifa::GlyphId;
@@ -18,6 +18,7 @@ thread_local! {
 
 struct PathBuilder {
 	current_subpath: Subpath<PointId>,
+	glyph_subpaths: Vec<Subpath<PointId>>,
 	other_subpaths: Vec<Subpath<PointId>>,
 	origin: DVec2,
 	scale: f64,
@@ -33,21 +34,29 @@ impl PathBuilder {
 		self.origin = DVec2::new(x, y);
 	}
 
-	fn draw_glyph(&mut self, glyph: &OutlineGlyph<'_>, size: f32, normalized_coords: &[NormalizedCoord]) {
+	fn draw_glyph(&mut self, glyph: &OutlineGlyph<'_>, size: f32, normalized_coords: &[NormalizedCoord], style_skew: Option<DAffine2>, skew: DAffine2) {
 		let location_ref = LocationRef::new(normalized_coords);
 		let settings = DrawSettings::unhinted(Size::new(size), location_ref);
 		glyph.draw(settings, self).unwrap();
 
-		if !self.current_subpath.is_empty() {
-			self.other_subpaths.push(core::mem::replace(&mut self.current_subpath, Subpath::new(Vec::new(), false)));
+		for glyph_subpath in &mut self.glyph_subpaths {
+			if let Some(style_skew) = style_skew {
+				glyph_subpath.apply_transform(style_skew);
+			}
+
+			glyph_subpath.apply_transform(skew);
+		}
+
+		if !self.glyph_subpaths.is_empty() {
+			self.other_subpaths.extend(core::mem::take(&mut self.glyph_subpaths));
 		}
 	}
 }
 
 impl OutlinePen for PathBuilder {
 	fn move_to(&mut self, x: f32, y: f32) {
 		if !self.current_subpath.is_empty() {
-			self.other_subpaths.push(std::mem::replace(&mut self.current_subpath, Subpath::new(Vec::new(), false)));
+			self.glyph_subpaths.push(std::mem::replace(&mut self.current_subpath, Subpath::new(Vec::new(), false)));
 		}
 		self.current_subpath.push_manipulator_group(ManipulatorGroup::new_anchor_with_id(self.point(x, y), self.id.next_id()));
 	}
@@ -71,7 +80,7 @@ impl OutlinePen for PathBuilder {
 
 	fn close(&mut self) {
 		self.current_subpath.set_closed(true);
-		self.other_subpaths.push(std::mem::replace(&mut self.current_subpath, Subpath::new(Vec::new(), false)));
+		self.glyph_subpaths.push(std::mem::replace(&mut self.current_subpath, Subpath::new(Vec::new(), false)));
 	}
 }
 
@@ -82,6 +91,7 @@ pub struct TypesettingConfig {
 	pub character_spacing: f64,
 	pub max_width: Option<f64>,
 	pub max_height: Option<f64>,
+	pub shear: f64,
 }
 
 impl Default for TypesettingConfig {
@@ -92,16 +102,28 @@ impl Default for TypesettingConfig {
 			character_spacing: 0.,
 			max_width: None,
 			max_height: None,
+			shear: 0.,
 		}
 	}
 }
 
-fn render_glyph_run(glyph_run: &GlyphRun<'_, ()>, path_builder: &mut PathBuilder) {
+fn render_glyph_run(glyph_run: &GlyphRun<'_, ()>, path_builder: &mut PathBuilder, shear: f64) {
 	let mut run_x = glyph_run.offset();
 	let run_y = glyph_run.baseline();
 
 	let run = glyph_run.run();
 
+	let skew = DAffine2::from_translation(DVec2::new(0.0, run_y as f64))
+		* DAffine2::from_cols_array(&[1.0, 0.0, -shear.to_radians().tan() as f64, 1.0, 0.0, 0.0])
+		* DAffine2::from_translation(DVec2::new(0.0, -run_y as f64));
+
+	let synthesis = run.synthesis();
+	let style_skew = synthesis.skew().map(|angle| {
+		DAffine2::from_translation(DVec2::new(0.0, run_y as f64))
+			* DAffine2::from_cols_array(&[1.0, 0.0, -angle.to_radians().tan() as f64, 1.0, 0.0, 0.0])
+			* DAffine2::from_translation(DVec2::new(0.0, -run_y as f64))
+	});
+
 	let font = run.font();
 	let font_size = run.font_size();
 
@@ -120,7 +142,7 @@ fn render_glyph_run(glyph_run: &GlyphRun<'_, ()>, path_builder: &mut PathBuilder
 		let glyph_id = GlyphId::from(glyph.id);
 		if let Some(glyph_outline) = outlines.get(glyph_id) {
 			path_builder.set_origin(glyph_x as f64, glyph_y as f64);
-			path_builder.draw_glyph(&glyph_outline, font_size, &normalized_coords);
+			path_builder.draw_glyph(&glyph_outline, font_size, &normalized_coords, style_skew, skew);
 		}
 	}
 }
@@ -160,6 +182,7 @@ pub fn to_path(str: &str, font_data: Option<Blob<u8>>, typesetting: TypesettingC
 
 	let mut path_builder = PathBuilder {
 		current_subpath: Subpath::new(Vec::new(), false),
+		glyph_subpaths: Vec::new(),
 		other_subpaths: Vec::new(),
 		origin: DVec2::ZERO,
 		scale: layout.scale() as f64,
@@ -170,7 +193,7 @@ pub fn to_path(str: &str, font_data: Option<Blob<u8>>, typesetting: TypesettingC
 		for item in line.items() {
 			match item {
 				PositionedLayoutItem::GlyphRun(glyph_run) => {
-					render_glyph_run(&glyph_run, &mut path_builder);
+					render_glyph_run(&glyph_run, &mut path_builder, typesetting.shear);
 				}
 				PositionedLayoutItem::InlineBox(_inline_box) => {
 					// Render the inline box

node-graph/gstd/src/text.rs

@@ -14,13 +14,15 @@ fn text<'i: 'n>(
 	#[default(0.)] character_spacing: f64,
 	#[default(None)] max_width: Option<f64>,
 	#[default(None)] max_height: Option<f64>,
+	#[default(0.)] shear: f64,
 ) -> VectorDataTable {
 	let typesetting = TypesettingConfig {
 		font_size,
 		line_height_ratio,
 		character_spacing,
 		max_width,
 		max_height,
+		shear,
 	};
 
 	let font_data = editor.font_cache.get(&font_name).map(|f| load_font(f));