wip: add mesh enum

Author: YohYamasaki

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

@@ -1943,7 +1943,7 @@ pub(crate) fn fill_properties(node_id: NodeId, context: &mut NodePropertiesConte
 	if let Fill::Gradient(gradient) = fill.clone() {
 		let mut row = vec![TextLabel::new("").widget_instance()];
 		match gradient.gradient_type {
-			GradientType::Linear => add_blank_assist(&mut row),
+			GradientType::Linear | GradientType::Mesh => add_blank_assist(&mut row),
 			GradientType::Radial => {
 				let orientation = if (gradient.end.x - gradient.start.x).abs() > f64::EPSILON * 1e6 {
 					gradient.end.x > gradient.start.x

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

@@ -174,8 +174,14 @@ impl LayoutHolder for GradientTool {
 				}
 				.into()
 			}),
+			RadioEntryData::new("Mesh").label("Mesh").tooltip_label(" Gradient").on_update(move |_| {
+				GradientToolMessage::UpdateOptions {
+					options: GradientOptionsUpdate::Type(GradientType::Mesh),
+				}
+				.into()
+			}),
 		])
-		.selected_index(Some((self.options.gradient_type == GradientType::Radial) as u32))
+		.selected_index(Some(self.options.gradient_type as u32))
 		.widget_instance();
 
 		let reverse_stops = IconButton::new("Reverse", 24)

node-graph/libraries/rendering/src/render_ext.rs

@@ -72,6 +72,7 @@ impl RenderExt for Gradient {
 					gradient_id, start.x, start.y, radius, stop
 				);
 			}
+			_ => (),
 		}
 
 		gradient_id

node-graph/libraries/rendering/src/renderer.rs

@@ -24,7 +24,7 @@ use std::fmt::Write;
 use std::hash::{Hash, Hasher};
 use std::ops::Deref;
 use std::sync::{Arc, LazyLock};
-use vector_types::gradient::GradientSpreadMethod;
+use vector_types::gradient::{self, GradientSpreadMethod};
 use vello::*;
 
 /// Cached 16x16 transparency checkerboard image data (two 8x8 cells of #ffffff and #cccccc).
@@ -967,6 +967,15 @@ impl Render for Table<Vector> {
 				}
 			}
 
+			let is_mesh_fill = matches!(
+				&row.element.style.fill,
+				Fill::Gradient(g) if g.gradient_type == GradientType::Mesh
+			);
+			if is_mesh_fill {
+				log::debug!("hoge");
+				return;
+			}
+
 			render.leaf_tag("path", |attributes| {
 				attributes.push("d", path.clone());
 				let matrix = format_transform_matrix(element_transform);
@@ -1159,6 +1168,12 @@ impl Render for Table<Vector> {
 								}
 								.into()
 							}
+							// TODO!!!!!!!!!!!!!!!!
+							GradientType::Mesh => peniko::LinearGradientPosition {
+								start: to_point(start),
+								end: to_point(end),
+							}
+							.into(),
 						},
 						extend: match gradient.spread_method {
 							GradientSpreadMethod::Pad => peniko::Extend::Pad,
@@ -1752,6 +1767,15 @@ impl Render for Table<GradientStops> {
 							r#"<radialGradient id="{gradient_id}" gradientUnits="userSpaceOnUse" cx="{cx}" cy="{cy}" r="{r}"{gradient_transform_attribute}>{stop_string}</radialGradient>"#
 						);
 					}
+					// TODO!!!!!!!!!!!!!!!!!!!!!!
+					GradientType::Mesh => {
+						let (x1, y1) = (start.x, start.y);
+						let (x2, y2) = (end.x, end.y);
+						let _ = write!(
+							&mut attributes.0.svg_defs,
+							r#"<linearGradient id="{gradient_id}" gradientUnits="userSpaceOnUse" x1="{x1}" y1="{y1}" x2="{x2}" y2="{y2}"{gradient_transform_attribute}>{stop_string}</linearGradient>"#
+						);
+					}
 				}
 
 				attributes.push("fill", format!("url('#{gradient_id}')"));

node-graph/libraries/vector-types/src/gradient.rs

@@ -9,6 +9,7 @@ pub enum GradientType {
 	#[default]
 	Linear,
 	Radial,
+	Mesh,
 }
 
 // TODO: Someday we could switch this to a Box[T] to avoid over-allocation

node-graph/nodes/vector/src/vector_nodes.rs

@@ -14,6 +14,7 @@ use kurbo::simplify::{SimplifyOptions, simplify_bezpath};
 use kurbo::{Affine, BezPath, DEFAULT_ACCURACY, Line, ParamCurve, ParamCurveArclen, PathEl, PathSeg, Shape};
 use rand::{Rng, SeedableRng};
 use std::collections::hash_map::DefaultHasher;
+use std::vec;
 use vector_types::subpath::{BezierHandles, ManipulatorGroup};
 use vector_types::vector::PointDomain;
 use vector_types::vector::algorithms::bezpath_algorithms::{self, TValue, eval_pathseg_euclidean, evaluate_bezpath, split_bezpath, tangent_on_bezpath};
@@ -26,6 +27,7 @@ use vector_types::vector::misc::{
 };
 use vector_types::vector::style::{Fill, Gradient, GradientStops, PaintOrder, Stroke, StrokeAlign, StrokeCap, StrokeJoin};
 use vector_types::vector::{FillId, PointId, RegionId, SegmentDomain, SegmentId, StrokeId, VectorExt};
+use wasm_bindgen::UnwrapThrowExt;
 
 /// Implemented for types that can be converted to an iterator of vector rows.
 /// Used for the fill and stroke node so they can be used on `Table<Graphic>` or `Table<Vector>`.
@@ -107,6 +109,51 @@ where
 	content
 }
 
+// #[node_macro::node(category("Vector: Style"), path(graphene_core::vector), properties("fill_properties"))]
+// async fn mesh_gradient(
+// 	_: impl Ctx,
+// 	/// The content with vector paths to apply the mesh gradient to.
+// 	mut content: Table<Vector>,
+// 	/// The top-left color of the gradient.
+// 	#[default(Color::BLACK)]
+// 	top_left_color: Table<Color>,
+// 	/// The top-right color of the gradient.
+// 	#[default(Color::BLACK)]
+// 	top_right_color: Table<Color>,
+// 	/// The bottom-left color of the gradient.
+// 	#[default(Color::BLACK)]
+// 	bottom_left_color: Table<Color>,
+// 	/// The bottom-right color of the gradient.
+// 	#[default(Color::BLACK)]
+// 	bottom_right_color: Table<Color>,
+// 	_backup_color: Table<Color>,
+// 	_backup_gradient: Gradient,
+// ) -> Table<Vector> {
+// 	for vector in content.vector_iter_mut() {
+// 		let grid_num = 8;
+// 		let grid_stride_uv = 1. / grid_num as f64;
+
+// 		let segments: Vec<_> = vector.element.segment_iter().collect();
+// 		let points = vector.element.point_domain.positions();
+// 		let top_seg = segments.get(0).unwrap_throw().1;
+// 		let right_seg = segments.get(1).unwrap_throw().1;
+// 		let bottom_seg = segments.get(2).unwrap_throw().1;
+// 		let left_seg = segments.get(3).unwrap_throw().1;
+
+// 		let bilerp = |u: f64, v: f64| points[0] * (1. - u) * (1. - v) + points[1] * u * (1. - v) + points[2] * (1. - u) * v + points[3] * u * v;
+
+// 		for i in 0..=grid_num {
+// 			for j in 0..=grid_num {
+// 				let u = i as f64 * grid_stride_uv;
+// 				let v = j as f64 * grid_stride_uv;
+// 				let pos = point_to_dvec2(top_seg.eval(u)) + point_to_dvec2(bottom_seg.eval(1. - u)) - bilerp(u, v);
+// 			}
+// 		}
+// 	}
+
+// 	content
+// }
+
 /// Applies a fill style to the vector content, giving an appearance to the area within the interior of the geometry.
 #[node_macro::node(category("Vector: Style"), path(graphene_core::vector), properties("fill_properties"))]
 async fn fill<F: Into<Fill> + 'n + Send, V: VectorTableIterMut + 'n + Send>(