Refactor Vector SVG renderer for Gradient / Color

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

@@ -1,10 +1,15 @@
 use crate::renderer::{RenderParams, format_transform_matrix};
+use core_types::table::Table;
 use core_types::color::SRGBA8;
 use core_types::uuid::generate_uuid;
-use glam::DAffine2;
+use core_types::{ATTR_GRADIENT_TYPE, ATTR_SPREAD_METHOD, ATTR_TRANSFORM, Color};
-use graphic_types::vector_types::gradient::{Gradient, GradientType};
+use glam::{DAffine2, DVec2};
+use graphic_types::Graphic;
+use graphic_types::graphic::fill_to_paint;
+use graphic_types::vector_types::gradient::GradientType;
 use graphic_types::vector_types::vector::style::{Fill, PaintOrder, PathStyle, Stroke, StrokeAlign, StrokeCap, StrokeJoin};
 use std::fmt::Write;
+use vector_types::GradientStops;
 use vector_types::gradient::GradientSpreadMethod;
 
 pub trait RenderExt {
@@ -12,13 +17,42 @@ pub trait RenderExt {
 	fn render(&self, svg_defs: &mut String, element_transform: DAffine2, stroke_transform: DAffine2, bounds: DAffine2, transformed_bounds: DAffine2, render_params: &RenderParams) -> Self::Output;
 }
 
-impl RenderExt for Gradient {
+impl RenderExt for Table<Color> {
+	type Output = String;
+
+	fn render(
+		&self,
+		_svg_defs: &mut String,
+		_element_transform: DAffine2,
+		_stroke_transform: DAffine2,
+		_bounds: DAffine2,
+		_transformed_bounds: DAffine2,
+		_render_params: &RenderParams,
+	) -> Self::Output {
+		let Some(color) = self.element(0) else { return String::new() };
+
+		let mut result = format!(r##" fill="#{}""##, SRGBA8::from(*color).to_rgb_hex());
+		if color.a() < 1. {
+			let _ = write!(result, r#" fill-opacity="{}""#, (color.a() * 1000.).round() / 1000.);
+		}
+
+		result
+	}
+}
+
+impl RenderExt for Table<GradientStops> {
 	type Output = u64;
 
 	/// Adds the gradient def through mutating the first argument, returning the gradient ID.
 	fn render(&self, svg_defs: &mut String, element_transform: DAffine2, stroke_transform: DAffine2, bounds: DAffine2, transformed_bounds: DAffine2, _render_params: &RenderParams) -> Self::Output {
 		let mut stop = String::new();
-		for (position, color, original_midpoint) in self.stops.interpolated_samples() {
+
+		let Some(stops) = self.element(0) else { return 0 };
+		let gradient_type: GradientType = self.attribute_cloned_or_default(ATTR_GRADIENT_TYPE, 0);
+		let gradient_transform: DAffine2 = self.attribute_cloned_or_default(ATTR_TRANSFORM, 0);
+		let spread_method: GradientSpreadMethod = self.attribute_cloned_or_default(ATTR_SPREAD_METHOD, 0);
+
+		for (position, color, original_midpoint) in stops.interpolated_samples() {
 			stop.push_str("<stop");
 			if position != 0. {
 				let _ = write!(stop, r#" offset="{}""#, (position * 1_000_000.).round() / 1_000_000.);
@@ -33,9 +67,9 @@ impl RenderExt for Gradient {
 			stop.push_str(" />")
 		}
 
-		let transform_points = element_transform * stroke_transform * bounds;
+		let transform_points = element_transform * stroke_transform * bounds * gradient_transform;
-		let start = transform_points.transform_point2(self.start);
+		let start = transform_points.transform_point2(DVec2::ZERO);
-		let end = transform_points.transform_point2(self.end);
+		let end = transform_points.transform_point2(DVec2::X);
 
 		let gradient_transform = if transformed_bounds.matrix2.determinant() != 0. {
 			transformed_bounds.inverse()
@@ -49,15 +83,15 @@ impl RenderExt for Gradient {
 			format!(r#" gradientTransform="{gradient_transform}""#)
 		};
 
-		let spread_method = if self.spread_method == GradientSpreadMethod::Pad {
+		let spread_method = if spread_method == GradientSpreadMethod::Pad {
 			String::new()
 		} else {
-			format!(r#" spreadMethod="{}""#, self.spread_method.svg_name())
+			format!(r#" spreadMethod="{}""#, spread_method.svg_name())
 		};
 
 		let gradient_id = generate_uuid();
 
-		match self.gradient_type {
+		match gradient_type {
 			GradientType::Linear => {
 				let _ = write!(
 					svg_defs,
@@ -84,19 +118,18 @@ impl RenderExt for Fill {
 
 	/// Renders the fill, adding necessary defs through mutating the first argument.
 	fn render(&self, svg_defs: &mut String, element_transform: DAffine2, stroke_transform: DAffine2, bounds: DAffine2, transformed_bounds: DAffine2, render_params: &RenderParams) -> Self::Output {
-		match self {
+		let Some(paint_table) = fill_to_paint(self) else { return r#" fill="none""#.to_string() };
-			Self::None => r#" fill="none""#.to_string(),
+		let Some(paint) = paint_table.element(0) else { return String::new() };
-			Self::Solid(color) => {
+
-				let mut result = format!(r##" fill="#{}""##, SRGBA8::from(*color).to_rgb_hex());
+		match paint {
-				if color.a() < 1. {
+			Graphic::Color(color_table) => color_table.render(svg_defs, element_transform, stroke_transform, bounds, transformed_bounds, render_params),
-					let _ = write!(result, r#" fill-opacity="{}""#, (color.a() * 1000.).round() / 1000.);
+			Graphic::Gradient(stops_table) => {
-				}
+				let gradient_id = stops_table.render(svg_defs, element_transform, stroke_transform, bounds, transformed_bounds, render_params);
-				result
-			}
-			Self::Gradient(gradient) => {
-				let gradient_id = gradient.render(svg_defs, element_transform, stroke_transform, bounds, transformed_bounds, render_params);
 				format!(r##" fill="url('#{gradient_id}')""##)
 			}
+			_ => {
+				todo!()
+			}
 		}
 	}
 }