diff --git a/editor/src/messages/message.rs b/editor/src/messages/message.rs index d8f59ca7bd..b654eb8840 100644 --- a/editor/src/messages/message.rs +++ b/editor/src/messages/message.rs @@ -69,7 +69,7 @@ mod test { fn print_tree_node(tree: &DebugMessageTree, prefix: &str, is_last: bool, file: &mut std::fs::File) { // Print the current node - let (branch, child_prefix) = if tree.has_message_handler_data_fields() || tree.has_message_handler_fields() { + let (branch, child_prefix) = if tree.message_handler_data_fields().is_some() || tree.message_handler_fields().is_some() { ("├── ", format!("{}│ ", prefix)) } else { if is_last { @@ -97,7 +97,7 @@ mod test { // Print handler field if any if let Some(data) = tree.message_handler_fields() { let len = data.fields().len(); - let (branch, child_prefix) = if tree.has_message_handler_data_fields() { + let (branch, child_prefix) = if tree.message_handler_data_fields().is_some() { ("├── ", format!("{}│ ", prefix)) } else { ("└── ", format!("{} ", prefix)) diff --git a/editor/src/messages/portfolio/document/data_panel/data_panel_message_handler.rs b/editor/src/messages/portfolio/document/data_panel/data_panel_message_handler.rs index f91b8b8e09..8f97c3d070 100644 --- a/editor/src/messages/portfolio/document/data_panel/data_panel_message_handler.rs +++ b/editor/src/messages/portfolio/document/data_panel/data_panel_message_handler.rs @@ -7,6 +7,7 @@ use crate::messages::tool::tool_messages::tool_prelude::*; use graph_craft::document::NodeId; use graphene_std::Color; use graphene_std::Context; +use graphene_std::gradient::GradientStops; use graphene_std::memo::IORecord; use graphene_std::raster_types::{CPU, GPU, Raster}; use graphene_std::table::Table; @@ -153,7 +154,6 @@ macro_rules! generate_layout_downcast { else { None } } } - // TODO: We simply try all these types sequentially. Find a better strategy. fn generate_layout(introspected_data: &Arc, data: &mut LayoutData) -> Option> { generate_layout_downcast!(introspected_data, data, [ @@ -163,6 +163,7 @@ fn generate_layout(introspected_data: &Arc>, Table>, Table, + Table, f64, u32, u64, @@ -263,6 +264,7 @@ impl TableRowLayout for Graphic { Self::RasterCPU(table) => table.identifier(), Self::RasterGPU(table) => table.identifier(), Self::Color(table) => table.identifier(), + Self::Gradient(table) => table.identifier(), } } // Don't put a breadcrumb for Graphic @@ -276,6 +278,7 @@ impl TableRowLayout for Graphic { Self::RasterCPU(table) => table.layout_with_breadcrumb(data), Self::RasterGPU(table) => table.layout_with_breadcrumb(data), Self::Color(table) => table.layout_with_breadcrumb(data), + Self::Gradient(table) => table.layout_with_breadcrumb(data), } } } @@ -335,10 +338,6 @@ impl TableRowLayout for Vector { TextLabel::new(format_dvec2(gradient.start)).widget_holder(), ]); table_rows.push(vec![TextLabel::new("Fill Gradient End").widget_holder(), TextLabel::new(format_dvec2(gradient.end)).widget_holder()]); - table_rows.push(vec![ - TextLabel::new("Fill Gradient Transform").widget_holder(), - TextLabel::new(format_transform_matrix(&gradient.transform)).widget_holder(), - ]); } } @@ -485,6 +484,25 @@ impl TableRowLayout for Color { } } +impl TableRowLayout for GradientStops { + fn type_name() -> &'static str { + "Gradient" + } + fn identifier(&self) -> String { + format!("Gradient ({} stops)", self.0.len()) + } + fn element_widget(&self, _index: usize) -> WidgetHolder { + ColorInput::new(FillChoice::Gradient(self.clone())) + .disabled(true) + .menu_direction(Some(MenuDirection::Top)) + .widget_holder() + } + fn element_page(&self, _data: &mut LayoutData) -> Vec { + let widgets = vec![self.element_widget(0)]; + vec![LayoutGroup::Row { widgets }] + } +} + impl TableRowLayout for f64 { fn type_name() -> &'static str { "Number (f64)" @@ -545,7 +563,7 @@ impl TableRowLayout for String { "String".to_string() } fn element_page(&self, _data: &mut LayoutData) -> Vec { - let widgets = vec![TextLabel::new(self.to_string()).widget_holder()]; + let widgets = vec![TextAreaInput::new(self.to_string()).disabled(true).widget_holder()]; vec![LayoutGroup::Row { widgets }] } } diff --git a/editor/src/messages/portfolio/document/graph_operation/graph_operation_message_handler.rs b/editor/src/messages/portfolio/document/graph_operation/graph_operation_message_handler.rs index c6ecabaa49..5bf6cce032 100644 --- a/editor/src/messages/portfolio/document/graph_operation/graph_operation_message_handler.rs +++ b/editor/src/messages/portfolio/document/graph_operation/graph_operation_message_handler.rs @@ -426,7 +426,6 @@ fn apply_usvg_fill(fill: &usvg::Fill, modify_inputs: &mut ModifyInputsContext, t Fill::Gradient(Gradient { start, end, - transform: DAffine2::IDENTITY, gradient_type: GradientType::Linear, stops, }) @@ -453,7 +452,6 @@ fn apply_usvg_fill(fill: &usvg::Fill, modify_inputs: &mut ModifyInputsContext, t Fill::Gradient(Gradient { start, end, - transform: DAffine2::IDENTITY, gradient_type: GradientType::Radial, stops, }) diff --git a/editor/src/messages/portfolio/document/node_graph/node_properties.rs b/editor/src/messages/portfolio/document/node_graph/node_properties.rs index d1998dbfa6..bdc63e4a11 100644 --- a/editor/src/messages/portfolio/document/node_graph/node_properties.rs +++ b/editor/src/messages/portfolio/document/node_graph/node_properties.rs @@ -182,6 +182,7 @@ pub(crate) fn property_from_type( // STRUCT TYPES // ============ Some(x) if x == TypeId::of::>() => color_widget(default_info, ColorInput::default().allow_none(true)), + Some(x) if x == TypeId::of::>() => color_widget(default_info, ColorInput::default().allow_none(false)), Some(x) if x == TypeId::of::() => color_widget(default_info, ColorInput::default().allow_none(false)), Some(x) if x == TypeId::of::() => font_widget(default_info), Some(x) if x == TypeId::of::() => curve_widget(default_info), @@ -922,6 +923,20 @@ pub fn color_widget(parameter_widgets_info: ParameterWidgetsInfo, color_button: .on_commit(commit_value) .widget_holder(), ), + TaggedValue::GradientTable(gradient_table) => widgets.push( + color_button + .value(match gradient_table.iter().next() { + Some(row) => FillChoice::Gradient(row.element.clone()), + None => FillChoice::None, + }) + .on_update(update_value( + |input: &ColorInput| TaggedValue::GradientTable(input.value.as_gradient().iter().map(|&gradient| TableRow::new_from_element(gradient.clone())).collect()), + node_id, + index, + )) + .on_commit(commit_value) + .widget_holder(), + ), TaggedValue::GradientStops(gradient_stops) => widgets.push( color_button .value(FillChoice::Gradient(gradient_stops.clone())) diff --git a/editor/src/messages/portfolio/document/node_graph/utility_types.rs b/editor/src/messages/portfolio/document/node_graph/utility_types.rs index 7b65793f94..8067ef2758 100644 --- a/editor/src/messages/portfolio/document/node_graph/utility_types.rs +++ b/editor/src/messages/portfolio/document/node_graph/utility_types.rs @@ -14,6 +14,8 @@ pub enum FrontendGraphDataType { Raster, Vector, Color, + Gradient, + Typography, } impl FrontendGraphDataType { @@ -32,6 +34,8 @@ impl FrontendGraphDataType { TaggedValue::Raster(_) => Self::Raster, TaggedValue::Vector(_) => Self::Vector, TaggedValue::Color(_) => Self::Color, + TaggedValue::Gradient(_) | TaggedValue::GradientStops(_) | TaggedValue::GradientTable(_) => Self::Gradient, + TaggedValue::String(_) => Self::Typography, _ => Self::General, } } diff --git a/editor/src/messages/tool/tool_messages/gradient_tool.rs b/editor/src/messages/tool/tool_messages/gradient_tool.rs index 41fdb09df0..7ad1573cda 100644 --- a/editor/src/messages/tool/tool_messages/gradient_tool.rs +++ b/editor/src/messages/tool/tool_messages/gradient_tool.rs @@ -204,7 +204,6 @@ impl SelectedGradient { /// Update the layer fill to the current gradient pub fn render_gradient(&mut self, responses: &mut VecDeque) { - self.gradient.transform = self.transform; if let Some(layer) = self.layer { responses.add(GraphOperationMessage::FillSet { layer, @@ -436,14 +435,7 @@ impl Fsm for GradientToolFsmState { gradient.clone() } else { // Generate a new gradient - Gradient::new( - DVec2::ZERO, - global_tool_data.secondary_color, - DVec2::ONE, - global_tool_data.primary_color, - DAffine2::IDENTITY, - tool_options.gradient_type, - ) + Gradient::new(DVec2::ZERO, global_tool_data.secondary_color, DVec2::ONE, global_tool_data.primary_color, tool_options.gradient_type) }; let selected_gradient = SelectedGradient::new(gradient, layer, document).with_gradient_start(input.mouse.position); diff --git a/editor/src/node_graph_executor.rs b/editor/src/node_graph_executor.rs index bcf629a6a8..300fb8208e 100644 --- a/editor/src/node_graph_executor.rs +++ b/editor/src/node_graph_executor.rs @@ -8,13 +8,10 @@ use graph_craft::proto::GraphErrors; use graph_craft::wasm_application_io::EditorPreferences; use graphene_std::application_io::TimingInformation; use graphene_std::application_io::{NodeGraphUpdateMessage, RenderConfig}; -use graphene_std::renderer::RenderSvgSegmentList; -use graphene_std::renderer::{Render, RenderParams, SvgRender}; use graphene_std::renderer::{RenderMetadata, format_transform_matrix}; use graphene_std::text::FontCache; use graphene_std::transform::Footprint; use graphene_std::vector::Vector; -use graphene_std::vector::style::ViewMode; use graphene_std::wasm_application_io::RenderOutputType; use interpreted_executor::dynamic_executor::ResolvedDocumentNodeTypesDelta; @@ -34,7 +31,6 @@ pub struct ExecutionResponse { execution_id: u64, result: Result, responses: VecDeque, - footprint: Footprint, vector_modify: HashMap, /// The resulting value from the temporary inspected during execution inspect_result: Option, @@ -131,6 +127,7 @@ impl NodeGraphExecutor { .send(GraphRuntimeRequest::GraphUpdate(GraphUpdate { network, node_to_inspect })) .map_err(|e| e.to_string())?; } + Ok(()) } @@ -252,6 +249,7 @@ impl NodeGraphExecutor { let size = (size * scale_factor).into(); responses.add(FrontendMessage::TriggerExportImage { svg, name, mime, size }); } + Ok(()) } @@ -264,7 +262,6 @@ impl NodeGraphExecutor { execution_id, result, responses: existing_responses, - footprint, vector_modify, inspect_result, } = execution_response; @@ -289,7 +286,7 @@ impl NodeGraphExecutor { // Special handling for exporting the artwork self.export(node_graph_output, export_config, responses)?; } else { - self.process_node_graph_output(node_graph_output, footprint, responses)?; + self.process_node_graph_output(node_graph_output, responses)?; } responses.add_front(DeferMessage::TriggerGraphRun(execution_id, execution_context.document_id)); @@ -330,73 +327,41 @@ impl NodeGraphExecutor { } } } + Ok(()) } - fn debug_render(render_object: impl Render, footprint: Footprint, responses: &mut VecDeque) { - // Setup rendering - let mut render = SvgRender::new(); - let render_params = RenderParams { - view_mode: ViewMode::Normal, - footprint, - thumbnail: false, - hide_artboards: false, - for_export: false, - for_mask: false, - alignment_parent_transform: None, + fn process_node_graph_output(&mut self, node_graph_output: TaggedValue, responses: &mut VecDeque) -> Result<(), String> { + let TaggedValue::RenderOutput(render_output) = node_graph_output else { + return Err(format!("Invalid node graph output type: {node_graph_output:#?}")); }; - // Render SVG - render_object.render_svg(&mut render, &render_params); - - // Concatenate the defs and the SVG into one string - render.wrap_with_transform(footprint.transform, None); - let svg = render.svg.to_svg_string(); - - // Send to frontend - responses.add(FrontendMessage::UpdateDocumentArtwork { svg }); - } - - fn process_node_graph_output(&mut self, node_graph_output: TaggedValue, footprint: Footprint, responses: &mut VecDeque) -> Result<(), String> { - let mut render_output_metadata = RenderMetadata::default(); - - match node_graph_output { - TaggedValue::RenderOutput(render_output) => { - match render_output.data { - RenderOutputType::Svg { svg, image_data } => { - // Send to frontend - responses.add(FrontendMessage::UpdateImageData { image_data }); - responses.add(FrontendMessage::UpdateDocumentArtwork { svg }); - } - RenderOutputType::CanvasFrame(frame) => { - let matrix = format_transform_matrix(frame.transform); - let transform = if matrix.is_empty() { String::new() } else { format!(" transform=\"{matrix}\"") }; - let svg = format!( - r#"
"#, - frame.resolution.x, frame.resolution.y, frame.surface_id.0 - ); - responses.add(FrontendMessage::UpdateDocumentArtwork { svg }); - } - RenderOutputType::Texture { .. } => {} - _ => return Err(format!("Invalid node graph output type: {:#?}", render_output.data)), - } - - render_output_metadata = render_output.metadata; + match render_output.data { + RenderOutputType::Svg { svg, image_data } => { + // Send to frontend + responses.add(FrontendMessage::UpdateImageData { image_data }); + responses.add(FrontendMessage::UpdateDocumentArtwork { svg }); } - TaggedValue::Bool(render_object) => Self::debug_render(render_object, footprint, responses), - TaggedValue::F64(render_object) => Self::debug_render(render_object, footprint, responses), - TaggedValue::DVec2(render_object) => Self::debug_render(render_object, footprint, responses), - TaggedValue::String(render_object) => Self::debug_render(render_object, footprint, responses), - _ => return Err(format!("Invalid node graph output type: {node_graph_output:#?}")), - }; + RenderOutputType::CanvasFrame(frame) => { + let matrix = format_transform_matrix(frame.transform); + let transform = if matrix.is_empty() { String::new() } else { format!(" transform=\"{matrix}\"") }; + let svg = format!( + r#"
"#, + frame.resolution.x, frame.resolution.y, frame.surface_id.0 + ); + responses.add(FrontendMessage::UpdateDocumentArtwork { svg }); + } + RenderOutputType::Texture { .. } => {} + _ => return Err(format!("Invalid node graph output type: {:#?}", render_output.data)), + } - let graphene_std::renderer::RenderMetadata { + let RenderMetadata { upstream_footprints, local_transforms, first_element_source_id, click_targets, clip_targets, - } = render_output_metadata; + } = render_output.metadata; // Run these update state messages immediately responses.add(DocumentMessage::UpdateUpstreamTransforms { @@ -409,6 +374,7 @@ impl NodeGraphExecutor { responses.add(DocumentMessage::RenderScrollbars); responses.add(DocumentMessage::RenderRulers); responses.add(OverlaysMessage::Draw); + Ok(()) } } diff --git a/editor/src/node_graph_executor/runtime.rs b/editor/src/node_graph_executor/runtime.rs index 55a262ab2c..ce1f292c4e 100644 --- a/editor/src/node_graph_executor/runtime.rs +++ b/editor/src/node_graph_executor/runtime.rs @@ -16,7 +16,6 @@ use graphene_std::table::{Table, TableRow}; use graphene_std::text::FontCache; use graphene_std::transform::RenderQuality; use graphene_std::vector::Vector; -use graphene_std::vector::style::ViewMode; use graphene_std::wasm_application_io::{RenderOutputType, WasmApplicationIo, WasmEditorApi}; use graphene_std::{Artboard, Context, Graphic}; use interpreted_executor::dynamic_executor::{DynamicExecutor, IntrospectError, ResolvedDocumentNodeTypesDelta}; @@ -228,7 +227,6 @@ impl NodeRuntime { execution_id, result, responses, - footprint: render_config.viewport, vector_modify: self.vector_modify.clone(), inspect_result, }); @@ -361,13 +359,9 @@ impl NodeRuntime { // Render the thumbnail from a `Graphic` into an SVG string let render_params = RenderParams { - view_mode: ViewMode::Normal, footprint, thumbnail: true, - hide_artboards: false, - for_export: false, - for_mask: false, - alignment_parent_transform: None, + ..Default::default() }; let mut render = SvgRender::new(); graphic.render_svg(&mut render, &render_params); diff --git a/editor/src/utility_types.rs b/editor/src/utility_types.rs index 6b5dc6de6b..fcc3c459a4 100644 --- a/editor/src/utility_types.rs +++ b/editor/src/utility_types.rs @@ -82,18 +82,4 @@ impl DebugMessageTree { pub fn message_handler_fields(&self) -> Option<&MessageData> { self.message_handler.as_ref() } - - pub fn has_message_handler_data_fields(&self) -> bool { - match self.message_handler_data_fields() { - Some(_) => true, - None => false, - } - } - - pub fn has_message_handler_fields(&self) -> bool { - match self.message_handler_fields() { - Some(_) => true, - None => false, - } - } } diff --git a/frontend/src/components/Editor.svelte b/frontend/src/components/Editor.svelte index 507de4c2c8..fb334c4a9e 100644 --- a/frontend/src/components/Editor.svelte +++ b/frontend/src/components/Editor.svelte @@ -123,8 +123,12 @@ --color-data-raster-dim: #9a7b43; --color-data-vector: #65bbe5; --color-data-vector-dim: #417892; - --color-data-color: #af81eb; - --color-data-color-dim: #6c489b; + --color-data-color: #ce6ea7; + --color-data-color-dim: #924071; + --color-data-gradient: #af81eb; + --color-data-gradient-dim: #6c489b; + --color-data-typography: #eea7a7; + --color-data-typography-dim: #955252; --color-none: white; --color-none-repeat: no-repeat; diff --git a/node-graph/gcore/src/artboard.rs b/node-graph/gcore/src/artboard.rs index 03f2c10917..a2fb0a779a 100644 --- a/node-graph/gcore/src/artboard.rs +++ b/node-graph/gcore/src/artboard.rs @@ -1,5 +1,6 @@ use crate::blending::AlphaBlending; use crate::bounds::{BoundingBox, RenderBoundingBox}; +use crate::gradient::GradientStops; use crate::math::quad::Quad; use crate::raster_types::{CPU, GPU, Raster}; use crate::table::{Table, TableRow}; @@ -98,6 +99,7 @@ async fn create_artboard> + 'n>( Context -> Table>, Context -> Table>, Context -> Table, + Context -> Table, Context -> DAffine2, )] content: impl Node, Output = T>, diff --git a/node-graph/gcore/src/blending_nodes.rs b/node-graph/gcore/src/blending_nodes.rs index 6e123c246d..a6c2c34e61 100644 --- a/node-graph/gcore/src/blending_nodes.rs +++ b/node-graph/gcore/src/blending_nodes.rs @@ -1,3 +1,4 @@ +use crate::gradient::GradientStops; use crate::raster_types::{CPU, Raster}; use crate::registry::types::Percentage; use crate::table::Table; @@ -41,6 +42,13 @@ impl MultiplyAlpha for Table { } } } +impl MultiplyAlpha for Table { + fn multiply_alpha(&mut self, factor: f64) { + for row in self.iter_mut() { + row.alpha_blending.opacity *= factor as f32; + } + } +} pub(super) trait MultiplyFill { fn multiply_fill(&mut self, factor: f64); @@ -78,6 +86,13 @@ impl MultiplyFill for Table { } } } +impl MultiplyFill for Table { + fn multiply_fill(&mut self, factor: f64) { + for row in self.iter_mut() { + row.alpha_blending.fill *= factor as f32; + } + } +} trait SetBlendMode { fn set_blend_mode(&mut self, blend_mode: BlendMode); @@ -111,6 +126,13 @@ impl SetBlendMode for Table { } } } +impl SetBlendMode for Table { + fn set_blend_mode(&mut self, blend_mode: BlendMode) { + for row in self.iter_mut() { + row.alpha_blending.blend_mode = blend_mode; + } + } +} trait SetClip { fn set_clip(&mut self, clip: bool); @@ -144,6 +166,13 @@ impl SetClip for Table { } } } +impl SetClip for Table { + fn set_clip(&mut self, clip: bool) { + for row in self.iter_mut() { + row.alpha_blending.clip = clip; + } + } +} #[node_macro::node(category("Style"))] fn blend_mode( @@ -153,6 +182,7 @@ fn blend_mode( Table, Table>, Table, + Table, )] mut value: T, blend_mode: BlendMode, @@ -170,6 +200,7 @@ fn opacity( Table, Table>, Table, + Table, )] mut value: T, #[default(100.)] opacity: Percentage, @@ -187,6 +218,7 @@ fn blending( Table, Table>, Table, + Table, )] mut value: T, blend_mode: BlendMode, diff --git a/node-graph/gcore/src/bounds.rs b/node-graph/gcore/src/bounds.rs index d59902ff0a..fb4b19cd42 100644 --- a/node-graph/gcore/src/bounds.rs +++ b/node-graph/gcore/src/bounds.rs @@ -1,4 +1,4 @@ -use crate::Color; +use crate::{Color, gradient::GradientStops}; use glam::{DAffine2, DVec2}; #[derive(Clone, Copy, Default, Debug, PartialEq)] @@ -33,3 +33,8 @@ impl BoundingBox for Color { RenderBoundingBox::Infinite } } +impl BoundingBox for GradientStops { + fn bounding_box(&self, _transform: DAffine2, _include_stroke: bool) -> RenderBoundingBox { + RenderBoundingBox::Infinite + } +} diff --git a/node-graph/gcore/src/gradient.rs b/node-graph/gcore/src/gradient.rs index 8034cc9876..0d51a8611f 100644 --- a/node-graph/gcore/src/gradient.rs +++ b/node-graph/gcore/src/gradient.rs @@ -126,7 +126,6 @@ pub struct Gradient { pub gradient_type: GradientType, pub start: DVec2, pub end: DVec2, - pub transform: DAffine2, } impl Default for Gradient { @@ -136,7 +135,6 @@ impl Default for Gradient { gradient_type: GradientType::Linear, start: DVec2::new(0., 0.5), end: DVec2::new(1., 0.5), - transform: DAffine2::IDENTITY, } } } @@ -147,7 +145,6 @@ impl std::hash::Hash for Gradient { [].iter() .chain(self.start.to_array().iter()) .chain(self.end.to_array().iter()) - .chain(self.transform.to_cols_array().iter()) .chain(self.stops.0.iter().map(|(position, _)| position)) .for_each(|x| x.to_bits().hash(state)); self.stops.0.iter().for_each(|(_, color)| color.hash(state)); @@ -171,20 +168,15 @@ impl std::fmt::Display for Gradient { impl Gradient { /// Constructs a new gradient with the colors at 0 and 1 specified. - pub fn new(start: DVec2, start_color: Color, end: DVec2, end_color: Color, transform: DAffine2, gradient_type: GradientType) -> Self { - Gradient { - start, - end, - stops: GradientStops::new(vec![(0., start_color.to_gamma_srgb()), (1., end_color.to_gamma_srgb())]), - transform, - gradient_type, - } + pub fn new(start: DVec2, start_color: Color, end: DVec2, end_color: Color, gradient_type: GradientType) -> Self { + let stops = GradientStops::new(vec![(0., start_color.to_gamma_srgb()), (1., end_color.to_gamma_srgb())]); + + Self { start, end, stops, gradient_type } } pub fn lerp(&self, other: &Self, time: f64) -> Self { let start = self.start + (other.start - self.start) * time; let end = self.end + (other.end - self.end) * time; - let transform = self.transform; let stops = self .stops .0 @@ -199,13 +191,7 @@ impl Gradient { let stops = GradientStops::new(stops); let gradient_type = if time < 0.5 { self.gradient_type } else { other.gradient_type }; - Self { - start, - end, - transform, - stops, - gradient_type, - } + Self { start, end, stops, gradient_type } } /// Insert a stop into the gradient, the index if successful diff --git a/node-graph/gcore/src/graphic.rs b/node-graph/gcore/src/graphic.rs index 2d21293deb..f902826c99 100644 --- a/node-graph/gcore/src/graphic.rs +++ b/node-graph/gcore/src/graphic.rs @@ -1,5 +1,6 @@ use crate::blending::AlphaBlending; use crate::bounds::{BoundingBox, RenderBoundingBox}; +use crate::gradient::GradientStops; use crate::raster_types::{CPU, GPU, Raster}; use crate::table::{Table, TableRow}; use crate::uuid::NodeId; @@ -17,6 +18,7 @@ pub enum Graphic { RasterCPU(Table>), RasterGPU(Table>), Color(Table), + Gradient(Table), } impl Default for Graphic { @@ -145,6 +147,28 @@ impl From> for Option { } } +// GradientStops +impl From for Graphic { + fn from(gradient: GradientStops) -> Self { + Graphic::Gradient(Table::new_from_element(gradient)) + } +} +impl From> for Graphic { + fn from(gradient: Table) -> Self { + Graphic::Gradient(gradient) + } +} +impl From for Table { + fn from(gradient: GradientStops) -> Self { + Table::new_from_element(Graphic::Gradient(Table::new_from_element(gradient))) + } +} +impl From> for Table { + fn from(gradient: Table) -> Self { + Table::new_from_element(Graphic::Gradient(gradient)) + } +} + // DAffine2 impl From for Graphic { fn from(_: DAffine2) -> Self { @@ -207,6 +231,7 @@ impl Graphic { Graphic::RasterCPU(raster) => raster.iter().all(|row| row.alpha_blending.clip), Graphic::RasterGPU(raster) => raster.iter().all(|row| row.alpha_blending.clip), Graphic::Color(color) => color.iter().all(|row| row.alpha_blending.clip), + Graphic::Gradient(gradient) => gradient.iter().all(|row| row.alpha_blending.clip), } } @@ -230,6 +255,7 @@ impl BoundingBox for Graphic { Graphic::RasterGPU(raster) => raster.bounding_box(transform, include_stroke), Graphic::Graphic(graphic) => graphic.bounding_box(transform, include_stroke), Graphic::Color(color) => color.bounding_box(transform, include_stroke), + Graphic::Gradient(gradient) => gradient.bounding_box(transform, include_stroke), } } } @@ -237,7 +263,7 @@ impl BoundingBox for Graphic { #[node_macro::node(category(""))] async fn source_node_id( _: impl Ctx, - #[implementations(Table, Table, Table, Table>, Table>, Table)] content: Table, + #[implementations(Table, Table, Table, Table>, Table>, Table, Table)] content: Table, node_path: Vec, ) -> Table { // Get the penultimate element of the node path, or None if the path is too short @@ -257,11 +283,11 @@ async fn source_node_id( async fn extend( _: impl Ctx, /// The table whose rows will appear at the start of the extended table. - #[implementations(Table, Table, Table, Table>, Table>, Table)] + #[implementations(Table, Table, Table, Table>, Table>, Table, Table)] base: Table, /// The table whose rows will appear at the end of the extended table. #[expose] - #[implementations(Table, Table, Table, Table>, Table>, Table)] + #[implementations(Table, Table, Table, Table>, Table>, Table, Table)] new: Table, ) -> Table { let mut base = base; @@ -274,9 +300,9 @@ async fn extend( #[node_macro::node(category(""))] async fn legacy_layer_extend( _: impl Ctx, - #[implementations(Table, Table, Table, Table>, Table>, Table)] base: Table, + #[implementations(Table, Table, Table, Table>, Table>, Table, Table)] base: Table, #[expose] - #[implementations(Table, Table, Table, Table>, Table>, Table)] + #[implementations(Table, Table, Table, Table>, Table>, Table, Table)] new: Table, nested_node_path: Vec, ) -> Table { @@ -302,6 +328,7 @@ async fn wrap_graphic + 'n>( Table>, Table>, Table, + Table, DAffine2, )] content: T, @@ -320,6 +347,7 @@ async fn to_graphic> + 'n>( Table>, Table>, Table, + Table, )] content: T, ) -> Table { @@ -427,6 +455,7 @@ fn index( Table>, Table>, Table, + Table, )] collection: T, /// The index of the item to retrieve, starting from 0 for the first item. diff --git a/node-graph/gcore/src/logic.rs b/node-graph/gcore/src/logic.rs index 7e37f99247..ee9d9c84e3 100644 --- a/node-graph/gcore/src/logic.rs +++ b/node-graph/gcore/src/logic.rs @@ -17,7 +17,7 @@ fn to_string(_: impl Ctx, #[implementations(bool, f64, u32, #[node_macro::node(category("Text"))] fn serialize( _: impl Ctx, - #[implementations(String, bool, f64, u32, u64, DVec2, DAffine2, Table, Table, Table, Table>, Table)] value: T, + #[implementations(String, bool, f64, u32, u64, DVec2, DAffine2, Table, Table, Table, Table>, Table, Table)] value: T, ) -> String { serde_json::to_string(&value).unwrap_or_else(|_| "Serialization Error".to_string()) } diff --git a/node-graph/gcore/src/render_complexity.rs b/node-graph/gcore/src/render_complexity.rs index 79caf35131..7920479377 100644 --- a/node-graph/gcore/src/render_complexity.rs +++ b/node-graph/gcore/src/render_complexity.rs @@ -1,8 +1,8 @@ +use crate::gradient::GradientStops; use crate::raster_types::{CPU, GPU, Raster}; use crate::table::Table; use crate::vector::Vector; use crate::{Artboard, Color, Graphic}; -use glam::DVec2; pub trait RenderComplexity { fn render_complexity(&self) -> usize { @@ -30,6 +30,7 @@ impl RenderComplexity for Graphic { Self::RasterCPU(table) => table.render_complexity(), Self::RasterGPU(table) => table.render_complexity(), Self::Color(table) => table.render_complexity(), + Self::Gradient(table) => table.render_complexity(), } } } @@ -59,8 +60,8 @@ impl RenderComplexity for Color { } } -impl RenderComplexity for String {} -impl RenderComplexity for bool {} -impl RenderComplexity for f32 {} -impl RenderComplexity for f64 {} -impl RenderComplexity for DVec2 {} +impl RenderComplexity for GradientStops { + fn render_complexity(&self) -> usize { + 1 + } +} diff --git a/node-graph/gcore/src/transform_nodes.rs b/node-graph/gcore/src/transform_nodes.rs index 71cdbd9f34..f6d7e8fcca 100644 --- a/node-graph/gcore/src/transform_nodes.rs +++ b/node-graph/gcore/src/transform_nodes.rs @@ -1,3 +1,4 @@ +use crate::gradient::GradientStops; use crate::raster_types::{CPU, GPU, Raster}; use crate::table::Table; use crate::transform::{ApplyTransform, Footprint, Transform}; @@ -17,6 +18,8 @@ async fn transform( Context -> Table, Context -> Table>, Context -> Table>, + Context -> Table, + Context -> Table, )] value: impl Node, Output = T>, translate: DVec2, @@ -44,7 +47,7 @@ async fn transform( #[node_macro::node(category(""))] fn replace_transform( _: impl Ctx, - #[implementations(Table, Table>, Table, Table)] mut data: Table, + #[implementations(Table, Table>, Table, Table, Table)] mut data: Table, #[implementations(DAffine2)] transform: TransformInput, ) -> Table { for data_transform in data.iter_mut() { @@ -62,6 +65,7 @@ async fn extract_transform( Table>, Table>, Table, + Table, )] vector: Table, ) -> DAffine2 { @@ -97,6 +101,7 @@ async fn boundless_footprint( Context -> Table>, Context -> Table>, Context -> Table, + Context -> Table, Context -> String, Context -> f64, )] @@ -116,6 +121,7 @@ async fn freeze_real_time( Context -> Table>, Context -> Table>, Context -> Table, + Context -> Table, Context -> String, Context -> f64, )] diff --git a/node-graph/gcore/src/vector/algorithms/instance.rs b/node-graph/gcore/src/vector/algorithms/instance.rs index f72aefd62b..1a08760a66 100644 --- a/node-graph/gcore/src/vector/algorithms/instance.rs +++ b/node-graph/gcore/src/vector/algorithms/instance.rs @@ -1,3 +1,4 @@ +use crate::gradient::GradientStops; use crate::raster_types::{CPU, Raster}; use crate::table::{Table, TableRowRef}; use crate::vector::Vector; @@ -14,6 +15,7 @@ async fn instance_on_points + Default + Send + Clone + 'static> Context -> Table, Context -> Table>, Context -> Table, + Context -> Table, )] instance: impl Node<'n, Context<'static>, Output = Table>, reverse: bool, @@ -56,6 +58,7 @@ async fn instance_repeat + Default + Send + Clone + 'static>( Context -> Table, Context -> Table>, Context -> Table, + Context -> Table, )] instance: impl Node<'n, Context<'static>, Output = Table>, #[default(1)] count: u64, diff --git a/node-graph/gcore/src/vector/style.rs b/node-graph/gcore/src/vector/style.rs index 02e3400039..7b3047fc69 100644 --- a/node-graph/gcore/src/vector/style.rs +++ b/node-graph/gcore/src/vector/style.rs @@ -127,6 +127,15 @@ impl From> for Fill { } } +impl From> for Fill { + fn from(gradient: Table) -> Fill { + Fill::Gradient(Gradient { + stops: gradient.iter().nth(0).map(|row| row.element.clone()).unwrap_or_default(), + ..Default::default() + }) + } +} + impl From for Fill { fn from(gradient: Gradient) -> Fill { Fill::Gradient(gradient) diff --git a/node-graph/gcore/src/vector/vector_nodes.rs b/node-graph/gcore/src/vector/vector_nodes.rs index 08957baf95..9dd95939af 100644 --- a/node-graph/gcore/src/vector/vector_nodes.rs +++ b/node-graph/gcore/src/vector/vector_nodes.rs @@ -113,6 +113,8 @@ async fn fill + 'n + Send, V: VectorTableIterMut + 'n + Send>( Table, Table, Table, + Table, + Table, Table, Table, Table, @@ -122,9 +124,11 @@ async fn fill + 'n + Send, V: VectorTableIterMut + 'n + Send>( #[implementations( Fill, Table, + Table, Gradient, Fill, Table, + Table, Gradient, )] #[default(Color::BLACK)] @@ -134,11 +138,7 @@ async fn fill + 'n + Send, V: VectorTableIterMut + 'n + Send>( ) -> V { let fill: Fill = fill.into(); for vector in content.vector_iter_mut() { - let mut fill = fill.clone(); - if let Fill::Gradient(gradient) = &mut fill { - gradient.transform *= *vector.transform; - } - vector.element.style.set_fill(fill); + vector.element.style.set_fill(fill.clone()); } content @@ -206,7 +206,7 @@ where async fn repeat( _: impl Ctx, // TODO: Implement other graphical types. - #[implementations(Table, Table, Table>, Table)] instance: Table, + #[implementations(Table, Table, Table>, Table, Table)] instance: Table, #[default(100., 100.)] // TODO: When using a custom Properties panel layout in document_node_definitions.rs and this default is set, the widget weirdly doesn't show up in the Properties panel. Investigation is needed. direction: PixelSize, @@ -242,7 +242,7 @@ async fn repeat( async fn circular_repeat( _: impl Ctx, // TODO: Implement other graphical types. - #[implementations(Table, Table, Table>, Table)] instance: Table, + #[implementations(Table, Table, Table>, Table, Table)] instance: Table, angle_offset: Angle, #[unit(" px")] #[default(5)] @@ -278,7 +278,7 @@ async fn copy_to_points( points: Table, /// Artwork to be copied and placed at each point. #[expose] - #[implementations(Table, Table, Table>, Table)] + #[implementations(Table, Table, Table>, Table, Table)] instance: Table, /// Minimum range of randomized sizes given to each instance. #[default(1)] @@ -353,7 +353,7 @@ async fn copy_to_points( #[node_macro::node(category("Instancing"), path(graphene_core::vector))] async fn mirror( _: impl Ctx, - #[implementations(Table, Table, Table>, Table)] content: Table, + #[implementations(Table, Table, Table>, Table, Table)] content: Table, #[default(ReferencePoint::Center)] relative_to_bounds: ReferencePoint, #[unit(" px")] offset: f64, #[range((-90., 90.))] angle: Angle, @@ -1888,7 +1888,7 @@ fn point_inside(_: impl Ctx, source: Table, point: DVec2) -> bool { } #[node_macro::node(category("General"), path(graphene_core::vector))] -async fn count_elements(_: impl Ctx, #[implementations(Table, Table, Table>, Table>, Table)] source: Table) -> u64 { +async fn count_elements(_: impl Ctx, #[implementations(Table, Table, Table>, Table>, Table, Table)] source: Table) -> u64 { source.len() as u64 } diff --git a/node-graph/gmath-nodes/src/lib.rs b/node-graph/gmath-nodes/src/lib.rs index 0c9b34224f..caf2e19c5b 100644 --- a/node-graph/gmath-nodes/src/lib.rs +++ b/node-graph/gmath-nodes/src/lib.rs @@ -664,6 +664,18 @@ fn color_value(_: impl Ctx, _primary: (), #[default(Color::RED)] color: Table GradientStops { + gradient +} + +/// Constructs a gradient value which may be set to any sequence of color stops to represent the transition between colors. +#[node_macro::node(category("Value"))] +fn gradient_table_value(_: impl Ctx, _primary: (), gradient: GradientStops) -> Table { + Table::new_from_element(gradient) +} + /// Gets the color at the specified position along the gradient, given a position from 0 (left) to 1 (right). #[node_macro::node(category("Color"))] fn sample_gradient(_: impl Ctx, _primary: (), gradient: GradientStops, position: Fraction) -> Table { @@ -672,12 +684,6 @@ fn sample_gradient(_: impl Ctx, _primary: (), gradient: GradientStops, position: Table::new_from_element(color) } -/// Constructs a gradient value which may be set to any sequence of color stops to represent the transition between colors. -#[node_macro::node(category("Value"))] -fn gradient_value(_: impl Ctx, _primary: (), gradient: GradientStops) -> GradientStops { - gradient -} - /// Constructs a string value which may be set to any plain text. #[node_macro::node(category("Value"))] fn string_value(_: impl Ctx, _primary: (), string: TextArea) -> String { diff --git a/node-graph/gpath-bool/src/lib.rs b/node-graph/gpath-bool/src/lib.rs index f9931b30dc..6baf9da11d 100644 --- a/node-graph/gpath-bool/src/lib.rs +++ b/node-graph/gpath-bool/src/lib.rs @@ -295,6 +295,24 @@ fn flatten_vector(graphic_table: &Table) -> Table { } }) .collect::>(), + Graphic::Gradient(gradient) => gradient + .into_iter() + .map(|row| { + let mut element = Vector::default(); + element.style.set_fill(Fill::Gradient(graphene_core::gradient::Gradient { + stops: row.element, + ..Default::default() + })); + element.style.set_stroke_transform(DAffine2::IDENTITY); + + TableRow { + element, + transform: row.transform, + alpha_blending: row.alpha_blending, + source_node_id: row.source_node_id, + } + }) + .collect::>(), } }) .collect() diff --git a/node-graph/graph-craft/src/document/value.rs b/node-graph/graph-craft/src/document/value.rs index 7105f1e0c4..3bd200e922 100644 --- a/node-graph/graph-craft/src/document/value.rs +++ b/node-graph/graph-craft/src/document/value.rs @@ -14,6 +14,7 @@ use graphene_core::transform::ReferencePoint; use graphene_core::uuid::NodeId; use graphene_core::vector::Vector; use graphene_core::vector::style::Fill; +use graphene_core::vector::style::GradientStops; use graphene_core::{Artboard, Color, Graphic, MemoHash, Node, Type}; use graphene_svg_renderer::RenderMetadata; use std::fmt::Display; @@ -196,6 +197,7 @@ tagged_value! { #[cfg_attr(target_family = "wasm", serde(deserialize_with = "graphene_core::misc::migrate_color"))] // TODO: Eventually remove this migration document upgrade code #[serde(alias = "ColorTable", alias = "OptionalColor")] Color(Table), + GradientTable(Table), // ============ // STRUCT TYPES // ============ @@ -205,7 +207,7 @@ tagged_value! { Stroke(graphene_core::vector::style::Stroke), Gradient(graphene_core::vector::style::Gradient), #[serde(alias = "GradientPositions")] // TODO: Eventually remove this alias document upgrade code - GradientStops(graphene_core::vector::style::GradientStops), + GradientStops(GradientStops), Font(graphene_core::text::Font), BrushStrokes(Vec), BrushCache(BrushCache), diff --git a/node-graph/graster-nodes/src/adjust.rs b/node-graph/graster-nodes/src/adjust.rs index 16f235a662..1b95f97d41 100644 --- a/node-graph/graster-nodes/src/adjust.rs +++ b/node-graph/graster-nodes/src/adjust.rs @@ -27,8 +27,15 @@ mod adjust_std { } impl Adjust for Table { fn adjust(&mut self, map_fn: impl Fn(&Color) -> Color) { - for color in self.iter_mut() { - *color.element = map_fn(color.element); + for row in self.iter_mut() { + *row.element = map_fn(row.element); + } + } + } + impl Adjust for Table { + fn adjust(&mut self, map_fn: impl Fn(&Color) -> Color) { + for row in self.iter_mut() { + row.element.adjust(&map_fn); } } } diff --git a/node-graph/graster-nodes/src/adjustments.rs b/node-graph/graster-nodes/src/adjustments.rs index fbee45b61f..fdfae312d4 100644 --- a/node-graph/graster-nodes/src/adjustments.rs +++ b/node-graph/graster-nodes/src/adjustments.rs @@ -46,6 +46,7 @@ fn luminance>( #[implementations( Table>, Table, + Table, GradientStops, )] mut input: T, @@ -70,6 +71,7 @@ fn gamma_correction>( #[implementations( Table>, Table, + Table, GradientStops, )] mut input: T, @@ -90,6 +92,7 @@ fn extract_channel>( #[implementations( Table>, Table, + Table, GradientStops, )] mut input: T, @@ -113,6 +116,7 @@ fn make_opaque>( #[implementations( Table>, Table, + Table, GradientStops, )] mut input: T, @@ -138,6 +142,7 @@ fn brightness_contrast>( #[implementations( Table>, Table, + Table, GradientStops, )] mut input: T, @@ -227,6 +232,7 @@ fn levels>( #[implementations( Table>, Table, + Table, GradientStops, )] mut image: T, @@ -294,6 +300,7 @@ async fn black_and_white>( #[implementations( Table>, Table, + Table, GradientStops, )] mut image: T, @@ -369,6 +376,7 @@ async fn hue_saturation>( #[implementations( Table>, Table, + Table, GradientStops, )] mut input: T, @@ -403,6 +411,7 @@ async fn invert>( #[implementations( Table>, Table, + Table, GradientStops, )] mut input: T, @@ -425,6 +434,7 @@ async fn threshold>( #[implementations( Table>, Table, + Table, GradientStops, )] mut image: T, @@ -470,6 +480,7 @@ async fn vibrance>( #[implementations( Table>, Table, + Table, GradientStops, )] mut image: T, @@ -635,6 +646,7 @@ async fn channel_mixer>( #[implementations( Table>, Table, + Table, GradientStops, )] mut image: T, @@ -763,6 +775,7 @@ async fn selective_color>( #[implementations( Table>, Table, + Table, GradientStops, )] mut image: T, @@ -905,6 +918,7 @@ async fn posterize>( #[implementations( Table>, Table, + Table, GradientStops, )] mut input: T, @@ -938,6 +952,7 @@ async fn exposure>( #[implementations( Table>, Table, + Table, GradientStops, )] mut input: T, diff --git a/node-graph/graster-nodes/src/blending_nodes.rs b/node-graph/graster-nodes/src/blending_nodes.rs index 1fb9fc6482..f02bb06c79 100644 --- a/node-graph/graster-nodes/src/blending_nodes.rs +++ b/node-graph/graster-nodes/src/blending_nodes.rs @@ -51,6 +51,15 @@ mod blend_std { result_table } } + impl Blend for Table { + fn blend(&self, under: &Self, blend_fn: impl Fn(Color, Color) -> Color) -> Self { + let mut result_table = self.clone(); + for (over, under) in result_table.iter_mut().zip(under.iter()) { + *over.element = over.element.blend(under.element, &blend_fn); + } + result_table + } + } impl Blend for GradientStops { fn blend(&self, under: &Self, blend_fn: impl Fn(Color, Color) -> Color) -> Self { let mut combined_stops = self.iter().map(|(position, _)| position).chain(under.iter().map(|(position, _)| position)).collect::>(); @@ -128,6 +137,7 @@ async fn blend + Send>( #[implementations( Table>, Table, + Table, GradientStops, )] over: T, @@ -135,6 +145,7 @@ async fn blend + Send>( #[implementations( Table>, Table, + Table, GradientStops, )] under: T, @@ -150,6 +161,7 @@ fn color_overlay>( #[implementations( Table>, Table, + Table, GradientStops, )] mut image: T, diff --git a/node-graph/graster-nodes/src/gradient_map.rs b/node-graph/graster-nodes/src/gradient_map.rs index a3df8fb734..82082d984a 100644 --- a/node-graph/graster-nodes/src/gradient_map.rs +++ b/node-graph/graster-nodes/src/gradient_map.rs @@ -15,6 +15,7 @@ async fn gradient_map>( #[implementations( Table>, Table, + Table, GradientStops, )] mut image: T, diff --git a/node-graph/gstd/src/wasm_application_io.rs b/node-graph/gstd/src/wasm_application_io.rs index b74dea531a..80b73abbb4 100644 --- a/node-graph/gstd/src/wasm_application_io.rs +++ b/node-graph/gstd/src/wasm_application_io.rs @@ -3,6 +3,7 @@ pub use graph_craft::document::value::RenderOutputType; pub use graph_craft::wasm_application_io::*; use graphene_application_io::{ApplicationIo, ExportFormat, RenderConfig}; use graphene_core::Artboard; +use graphene_core::gradient::GradientStops; #[cfg(target_family = "wasm")] use graphene_core::math::bbox::Bbox; use graphene_core::raster::image::Image; @@ -221,6 +222,7 @@ async fn rasterize( Table>, Table, Table, + Table, )] mut data: Table, footprint: Footprint, @@ -291,10 +293,7 @@ async fn render<'a: 'n, T: 'n + Render + WasmNotSend>( Context -> Table, Context -> Table>, Context -> Table, - Context -> bool, - Context -> f32, - Context -> f64, - Context -> String, + Context -> Table, )] data: impl Node, Output = T>, _surface_handle: impl Node, Output = Option>, @@ -307,15 +306,12 @@ async fn render<'a: 'n, T: 'n + Render + WasmNotSend>( .into_context(); ctx.footprint(); - let RenderConfig { hide_artboards, for_export, .. } = render_config; let render_params = RenderParams { view_mode: render_config.view_mode, + hide_artboards: render_config.hide_artboards, + for_export: render_config.for_export, footprint, - thumbnail: false, - hide_artboards, - for_export, - for_mask: false, - alignment_parent_transform: None, + ..Default::default() }; let data = data.eval(ctx.clone()).await; diff --git a/node-graph/gsvg-renderer/src/render_ext.rs b/node-graph/gsvg-renderer/src/render_ext.rs index d0d7c16cc8..47655a26af 100644 --- a/node-graph/gsvg-renderer/src/render_ext.rs +++ b/node-graph/gsvg-renderer/src/render_ext.rs @@ -1,5 +1,5 @@ use crate::renderer::{RenderParams, format_transform_matrix}; -use glam::{DAffine2, DVec2}; +use glam::DAffine2; use graphene_core::consts::{LAYER_OUTLINE_STROKE_COLOR, LAYER_OUTLINE_STROKE_WEIGHT}; use graphene_core::gradient::{Gradient, GradientType}; use graphene_core::uuid::generate_uuid; @@ -8,39 +8,14 @@ use std::fmt::Write; pub trait RenderExt { type Output; - fn render( - &self, - svg_defs: &mut String, - element_transform: DAffine2, - stroke_transform: DAffine2, - bounds: [DVec2; 2], - transformed_bounds: [DVec2; 2], - aligned_strokes: bool, - override_paint_order: bool, - render_params: &RenderParams, - ) -> Self::Output; + 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 { 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: [DVec2; 2], - transformed_bounds: [DVec2; 2], - _aligned_strokes: bool, - _override_paint_order: bool, - _render_params: &RenderParams, - ) -> Self::Output { - // TODO: Figure out how to use `self.transform` as part of the gradient transform, since that field (`Gradient::transform`) is currently never read from, it's only written to. - - let bound_transform = DAffine2::from_scale_angle_translation(bounds[1] - bounds[0], 0., bounds[0]); - let transformed_bound_transform = element_transform * DAffine2::from_scale_angle_translation(transformed_bounds[1] - transformed_bounds[0], 0., transformed_bounds[0]); - + 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) in self.stops.0.iter() { stop.push_str("") } - let mod_gradient = if transformed_bound_transform.matrix2.determinant() != 0. { - transformed_bound_transform.inverse() + let transform_points = element_transform * stroke_transform * bounds; + let start = transform_points.transform_point2(self.start); + let end = transform_points.transform_point2(self.end); + + let gradient_transform = if transformed_bounds.matrix2.determinant() != 0. { + transformed_bounds.inverse() } else { DAffine2::IDENTITY // Ignore if the transform cannot be inverted (the bounds are zero). See issue #1944. }; - let mod_points = element_transform * stroke_transform * bound_transform; - - let start = mod_points.transform_point2(self.start); - let end = mod_points.transform_point2(self.end); + let gradient_transform = format_transform_matrix(gradient_transform); + let gradient_transform = if gradient_transform.is_empty() { + String::new() + } else { + format!(r#" gradientTransform="{gradient_transform}""#) + }; let gradient_id = generate_uuid(); - let matrix = format_transform_matrix(mod_gradient); - let gradient_transform = if matrix.is_empty() { String::new() } else { format!(r#" gradientTransform="{}""#, matrix) }; - match self.gradient_type { GradientType::Linear => { let _ = write!( svg_defs, - r#"{}"#, - gradient_id, start.x, end.x, start.y, end.y, stop + r#"{}"#, + gradient_id, start.x, start.y, end.x, end.y, stop ); } GradientType::Radial => { @@ -95,17 +73,7 @@ impl RenderExt for Fill { type Output = String; /// 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: [DVec2; 2], - transformed_bounds: [DVec2; 2], - aligned_strokes: bool, - override_paint_order: bool, - render_params: &RenderParams, - ) -> Self::Output { + 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 { Self::None => r#" fill="none""#.to_string(), Self::Solid(color) => { @@ -116,16 +84,7 @@ impl RenderExt for Fill { result } Self::Gradient(gradient) => { - let gradient_id = gradient.render( - svg_defs, - element_transform, - stroke_transform, - bounds, - transformed_bounds, - aligned_strokes, - override_paint_order, - render_params, - ); + let gradient_id = gradient.render(svg_defs, element_transform, stroke_transform, bounds, transformed_bounds, render_params); format!(r##" fill="url('#{gradient_id}')""##) } } @@ -141,11 +100,9 @@ impl RenderExt for Stroke { _svg_defs: &mut String, _element_transform: DAffine2, _stroke_transform: DAffine2, - _bounds: [DVec2; 2], - _transformed_bounds: [DVec2; 2], - aligned_strokes: bool, - override_paint_order: bool, - _render_params: &RenderParams, + _bounds: DAffine2, + _transformed_bounds: DAffine2, + render_params: &RenderParams, ) -> Self::Output { // Don't render a stroke at all if it would be invisible let Some(color) = self.color else { return String::new() }; @@ -161,7 +118,7 @@ impl RenderExt for Stroke { let stroke_join = (self.join != StrokeJoin::Miter).then_some(self.join); let stroke_join_miter_limit = (self.join_miter_limit != 4.).then_some(self.join_miter_limit); let stroke_align = (self.align != StrokeAlign::Center).then_some(self.align); - let paint_order = (self.paint_order != PaintOrder::StrokeAbove || override_paint_order).then_some(PaintOrder::StrokeBelow); + let paint_order = (self.paint_order != PaintOrder::StrokeAbove || render_params.override_paint_order).then_some(PaintOrder::StrokeBelow); // Render the needed stroke attributes let mut attributes = format!(r##" stroke="#{}""##, color.to_rgb_hex_srgb_from_gamma()); @@ -169,16 +126,16 @@ impl RenderExt for Stroke { let _ = write!(&mut attributes, r#" stroke-opacity="{}""#, (color.a() * 1000.).round() / 1000.); } if let Some(mut weight) = weight { - if stroke_align.is_some() && aligned_strokes { + if stroke_align.is_some() && render_params.aligned_strokes { weight *= 2.; } - let _ = write!(&mut attributes, r#" stroke-width="{}""#, weight); + let _ = write!(&mut attributes, r#" stroke-width="{weight}""#); } if let Some(dash_array) = dash_array { - let _ = write!(&mut attributes, r#" stroke-dasharray="{}""#, dash_array); + let _ = write!(&mut attributes, r#" stroke-dasharray="{dash_array}""#); } if let Some(dash_offset) = dash_offset { - let _ = write!(&mut attributes, r#" stroke-dashoffset="{}""#, dash_offset); + let _ = write!(&mut attributes, r#" stroke-dashoffset="{dash_offset}""#); } if let Some(stroke_cap) = stroke_cap { let _ = write!(&mut attributes, r#" stroke-linecap="{}""#, stroke_cap.svg_name()); @@ -187,7 +144,7 @@ impl RenderExt for Stroke { let _ = write!(&mut attributes, r#" stroke-linejoin="{}""#, stroke_join.svg_name()); } if let Some(stroke_join_miter_limit) = stroke_join_miter_limit { - let _ = write!(&mut attributes, r#" stroke-miterlimit="{}""#, stroke_join_miter_limit); + let _ = write!(&mut attributes, r#" stroke-miterlimit="{stroke_join_miter_limit}""#); } // Add vector-effect attribute to make strokes non-scaling if self.non_scaling { @@ -205,71 +162,23 @@ impl RenderExt for PathStyle { /// Renders the shape's fill and stroke attributes as a string with them concatenated together. #[allow(clippy::too_many_arguments)] - fn render( - &self, - svg_defs: &mut String, - element_transform: DAffine2, - stroke_transform: DAffine2, - bounds: [DVec2; 2], - transformed_bounds: [DVec2; 2], - aligned_strokes: bool, - override_paint_order: bool, - render_params: &RenderParams, - ) -> String { + fn render(&self, svg_defs: &mut String, element_transform: DAffine2, stroke_transform: DAffine2, bounds: DAffine2, transformed_bounds: DAffine2, render_params: &RenderParams) -> String { let view_mode = render_params.view_mode; match view_mode { ViewMode::Outline => { - let fill_attribute = Fill::None.render( - svg_defs, - element_transform, - stroke_transform, - bounds, - transformed_bounds, - aligned_strokes, - override_paint_order, - render_params, - ); + let fill_attribute = Fill::None.render(svg_defs, element_transform, stroke_transform, bounds, transformed_bounds, render_params); let mut outline_stroke = Stroke::new(Some(LAYER_OUTLINE_STROKE_COLOR), LAYER_OUTLINE_STROKE_WEIGHT); // Outline strokes should be non-scaling by default outline_stroke.non_scaling = true; - let stroke_attribute = outline_stroke.render( - svg_defs, - element_transform, - stroke_transform, - bounds, - transformed_bounds, - aligned_strokes, - override_paint_order, - render_params, - ); + let stroke_attribute = outline_stroke.render(svg_defs, element_transform, stroke_transform, bounds, transformed_bounds, render_params); format!("{fill_attribute}{stroke_attribute}") } _ => { - let fill_attribute = self.fill.render( - svg_defs, - element_transform, - stroke_transform, - bounds, - transformed_bounds, - aligned_strokes, - override_paint_order, - render_params, - ); + let fill_attribute = self.fill.render(svg_defs, element_transform, stroke_transform, bounds, transformed_bounds, render_params); let stroke_attribute = self .stroke .as_ref() - .map(|stroke| { - stroke.render( - svg_defs, - element_transform, - stroke_transform, - bounds, - transformed_bounds, - aligned_strokes, - override_paint_order, - render_params, - ) - }) + .map(|stroke| stroke.render(svg_defs, element_transform, stroke_transform, bounds, transformed_bounds, render_params)) .unwrap_or_default(); format!("{fill_attribute}{stroke_attribute}") } diff --git a/node-graph/gsvg-renderer/src/renderer.rs b/node-graph/gsvg-renderer/src/renderer.rs index 857bd436c1..00cea396a9 100644 --- a/node-graph/gsvg-renderer/src/renderer.rs +++ b/node-graph/gsvg-renderer/src/renderer.rs @@ -7,6 +7,8 @@ use graphene_core::blending::BlendMode; use graphene_core::bounds::BoundingBox; use graphene_core::bounds::RenderBoundingBox; use graphene_core::color::Color; +use graphene_core::gradient::GradientStops; +use graphene_core::gradient::GradientType; use graphene_core::math::quad::Quad; use graphene_core::raster::BitmapMut; use graphene_core::raster::Image; @@ -154,7 +156,7 @@ pub struct RenderContext { } /// Static state used whilst rendering -#[derive(Default)] +#[derive(Default, Clone)] pub struct RenderParams { pub view_mode: ViewMode, pub footprint: Footprint, @@ -167,6 +169,8 @@ pub struct RenderParams { pub for_mask: bool, /// Are we generating a mask for alignment? Used to prevent unnecessary transforms in masks pub alignment_parent_transform: Option, + pub aligned_strokes: bool, + pub override_paint_order: bool, } impl RenderParams { @@ -236,6 +240,251 @@ pub trait Render: BoundingBox + RenderComplexity { fn new_ids_from_hash(&mut self, _reference: Option) {} } +impl Render for Graphic { + fn render_svg(&self, render: &mut SvgRender, render_params: &RenderParams) { + match self { + Graphic::Graphic(table) => table.render_svg(render, render_params), + Graphic::Vector(table) => table.render_svg(render, render_params), + Graphic::RasterCPU(table) => table.render_svg(render, render_params), + Graphic::RasterGPU(_) => (), + Graphic::Color(table) => table.render_svg(render, render_params), + Graphic::Gradient(table) => table.render_svg(render, render_params), + } + } + + #[cfg(feature = "vello")] + fn render_to_vello(&self, scene: &mut Scene, transform: DAffine2, context: &mut RenderContext, render_params: &RenderParams) { + match self { + Graphic::Graphic(table) => table.render_to_vello(scene, transform, context, render_params), + Graphic::Vector(table) => table.render_to_vello(scene, transform, context, render_params), + Graphic::RasterCPU(table) => table.render_to_vello(scene, transform, context, render_params), + Graphic::RasterGPU(table) => table.render_to_vello(scene, transform, context, render_params), + Graphic::Color(table) => table.render_to_vello(scene, transform, context, render_params), + Graphic::Gradient(table) => table.render_to_vello(scene, transform, context, render_params), + } + } + + fn collect_metadata(&self, metadata: &mut RenderMetadata, footprint: Footprint, element_id: Option) { + if let Some(element_id) = element_id { + match self { + Graphic::Graphic(_) => { + metadata.upstream_footprints.insert(element_id, footprint); + } + Graphic::Vector(table) => { + metadata.upstream_footprints.insert(element_id, footprint); + // TODO: Find a way to handle more than the first row + if let Some(row) = table.iter().next() { + metadata.first_element_source_id.insert(element_id, *row.source_node_id); + metadata.local_transforms.insert(element_id, *row.transform); + } + } + Graphic::RasterCPU(table) => { + metadata.upstream_footprints.insert(element_id, footprint); + + // TODO: Find a way to handle more than the first row + if let Some(row) = table.iter().next() { + metadata.local_transforms.insert(element_id, *row.transform); + } + } + Graphic::RasterGPU(table) => { + metadata.upstream_footprints.insert(element_id, footprint); + + // TODO: Find a way to handle more than the first row + if let Some(row) = table.iter().next() { + metadata.local_transforms.insert(element_id, *row.transform); + } + } + Graphic::Color(table) => { + metadata.upstream_footprints.insert(element_id, footprint); + + // TODO: Find a way to handle more than the first row + if let Some(row) = table.iter().next() { + metadata.local_transforms.insert(element_id, *row.transform); + } + } + Graphic::Gradient(table) => { + metadata.upstream_footprints.insert(element_id, footprint); + + // TODO: Find a way to handle more than the first row + if let Some(row) = table.iter().next() { + metadata.local_transforms.insert(element_id, *row.transform); + } + } + } + } + + match self { + Graphic::Graphic(table) => table.collect_metadata(metadata, footprint, element_id), + Graphic::Vector(table) => table.collect_metadata(metadata, footprint, element_id), + Graphic::RasterCPU(table) => table.collect_metadata(metadata, footprint, element_id), + Graphic::RasterGPU(table) => table.collect_metadata(metadata, footprint, element_id), + Graphic::Color(table) => table.collect_metadata(metadata, footprint, element_id), + Graphic::Gradient(table) => table.collect_metadata(metadata, footprint, element_id), + } + } + + fn add_upstream_click_targets(&self, click_targets: &mut Vec) { + match self { + Graphic::Graphic(table) => table.add_upstream_click_targets(click_targets), + Graphic::Vector(table) => table.add_upstream_click_targets(click_targets), + Graphic::RasterCPU(table) => table.add_upstream_click_targets(click_targets), + Graphic::RasterGPU(table) => table.add_upstream_click_targets(click_targets), + Graphic::Color(table) => table.add_upstream_click_targets(click_targets), + Graphic::Gradient(table) => table.add_upstream_click_targets(click_targets), + } + } + + fn contains_artboard(&self) -> bool { + match self { + Graphic::Graphic(table) => table.contains_artboard(), + Graphic::Vector(table) => table.contains_artboard(), + Graphic::RasterCPU(table) => table.contains_artboard(), + Graphic::RasterGPU(table) => table.contains_artboard(), + Graphic::Color(table) => table.contains_artboard(), + Graphic::Gradient(table) => table.contains_artboard(), + } + } + + fn new_ids_from_hash(&mut self, reference: Option) { + match self { + Graphic::Graphic(table) => table.new_ids_from_hash(reference), + Graphic::Vector(table) => table.new_ids_from_hash(reference), + Graphic::RasterCPU(_) => (), + Graphic::RasterGPU(_) => (), + Graphic::Color(_) => (), + Graphic::Gradient(_) => (), + } + } +} + +impl Render for Artboard { + fn render_svg(&self, render: &mut SvgRender, render_params: &RenderParams) { + // Rectangle for the artboard + if !render_params.hide_artboards { + // Background + render.leaf_tag("rect", |attributes| { + attributes.push("fill", format!("#{}", self.background.to_rgb_hex_srgb_from_gamma())); + if self.background.a() < 1. { + attributes.push("fill-opacity", ((self.background.a() * 1000.).round() / 1000.).to_string()); + } + attributes.push("x", self.location.x.min(self.location.x + self.dimensions.x).to_string()); + attributes.push("y", self.location.y.min(self.location.y + self.dimensions.y).to_string()); + attributes.push("width", self.dimensions.x.abs().to_string()); + attributes.push("height", self.dimensions.y.abs().to_string()); + }); + } + + // Artwork + render.parent_tag( + // SVG group tag + "g", + // Group tag attributes + |attributes| { + let matrix = format_transform_matrix(self.transform()); + if !matrix.is_empty() { + attributes.push("transform", matrix); + } + + if self.clip { + let id = format!("artboard-{}", generate_uuid()); + let selector = format!("url(#{id})"); + + write!( + &mut attributes.0.svg_defs, + r##""##, + self.dimensions.x, self.dimensions.y, + ) + .unwrap(); + attributes.push("clip-path", selector); + } + }, + // Artwork content + |render| { + self.content.render_svg(render, render_params); + }, + ); + } + + #[cfg(feature = "vello")] + fn render_to_vello(&self, scene: &mut Scene, transform: DAffine2, context: &mut RenderContext, render_params: &RenderParams) { + use vello::peniko; + + // Render background + let color = peniko::Color::new([self.background.r(), self.background.g(), self.background.b(), self.background.a()]); + let [a, b] = [self.location.as_dvec2(), self.location.as_dvec2() + self.dimensions.as_dvec2()]; + let rect = kurbo::Rect::new(a.x.min(b.x), a.y.min(b.y), a.x.max(b.x), a.y.max(b.y)); + + scene.push_layer(peniko::Mix::Normal, 1., kurbo::Affine::new(transform.to_cols_array()), &rect); + scene.fill(peniko::Fill::NonZero, kurbo::Affine::new(transform.to_cols_array()), color, None, &rect); + scene.pop_layer(); + + if self.clip { + let blend_mode = peniko::BlendMode::new(peniko::Mix::Clip, peniko::Compose::SrcOver); + scene.push_layer(blend_mode, 1., kurbo::Affine::new(transform.to_cols_array()), &rect); + } + // Since the content's transform is right multiplied in when rendering the content, we just need to right multiply by the artboard offset here. + let child_transform = transform * DAffine2::from_translation(self.location.as_dvec2()); + self.content.render_to_vello(scene, child_transform, context, render_params); + if self.clip { + scene.pop_layer(); + } + } + + fn collect_metadata(&self, metadata: &mut RenderMetadata, mut footprint: Footprint, element_id: Option) { + if let Some(element_id) = element_id { + let subpath = Subpath::new_rect(DVec2::ZERO, self.dimensions.as_dvec2()); + metadata.click_targets.insert(element_id, vec![ClickTarget::new_with_subpath(subpath, 0.)]); + metadata.upstream_footprints.insert(element_id, footprint); + metadata.local_transforms.insert(element_id, DAffine2::from_translation(self.location.as_dvec2())); + if self.clip { + metadata.clip_targets.insert(element_id); + } + } + footprint.transform *= self.transform(); + self.content.collect_metadata(metadata, footprint, None); + } + + fn add_upstream_click_targets(&self, click_targets: &mut Vec) { + let subpath_rectangle = Subpath::new_rect(DVec2::ZERO, self.dimensions.as_dvec2()); + click_targets.push(ClickTarget::new_with_subpath(subpath_rectangle, 0.)); + } + + fn contains_artboard(&self) -> bool { + true + } +} + +impl Render for Table { + fn render_svg(&self, render: &mut SvgRender, render_params: &RenderParams) { + for artboard in self.iter() { + artboard.element.render_svg(render, render_params); + } + } + + #[cfg(feature = "vello")] + fn render_to_vello(&self, scene: &mut Scene, transform: DAffine2, context: &mut RenderContext, render_params: &RenderParams) { + for row in self.iter() { + row.element.render_to_vello(scene, transform, context, render_params); + } + } + + fn collect_metadata(&self, metadata: &mut RenderMetadata, footprint: Footprint, _element_id: Option) { + for row in self.iter() { + row.element.collect_metadata(metadata, footprint, *row.source_node_id); + } + } + + fn add_upstream_click_targets(&self, click_targets: &mut Vec) { + for row in self.iter() { + row.element.add_upstream_click_targets(click_targets); + } + } + + fn contains_artboard(&self) -> bool { + self.iter().count() > 0 + } +} + impl Render for Table { fn render_svg(&self, render: &mut SvgRender, render_params: &RenderParams) { let mut iter = self.iter().peekable(); @@ -425,41 +674,41 @@ impl Render for Table { let layer_bounds = vector.bounding_box().unwrap_or_default(); let transformed_bounds = vector.bounding_box_with_transform(applied_stroke_transform).unwrap_or_default(); - let mut path = String::new(); + let bounds_matrix = DAffine2::from_scale_angle_translation(layer_bounds[1] - layer_bounds[0], 0., layer_bounds[0]); + let transformed_bounds_matrix = element_transform * DAffine2::from_scale_angle_translation(transformed_bounds[1] - transformed_bounds[0], 0., transformed_bounds[0]); + let mut path = String::new(); for subpath in row.element.stroke_bezier_paths() { let _ = subpath.subpath_to_svg(&mut path, applied_stroke_transform); } - let connected = vector.stroke_bezier_paths().all(|path| path.closed()); - let can_draw_aligned_stroke = vector.style.stroke().is_some_and(|stroke| stroke.has_renderable_stroke() && stroke.align.is_not_centered()) && connected; - let mut push_id = None; - - if can_draw_aligned_stroke { - let mask_type = if vector.style.stroke().unwrap().align == StrokeAlign::Inside { - MaskType::Clip - } else { - MaskType::Mask - }; + let mask_type = if vector.style.stroke().map(|x| x.align) == Some(StrokeAlign::Inside) { + MaskType::Clip + } else { + MaskType::Mask + }; + let path_is_closed = vector.stroke_bezier_paths().all(|path| path.closed()); + let can_draw_aligned_stroke = path_is_closed && vector.style.stroke().is_some_and(|stroke| stroke.has_renderable_stroke() && stroke.align.is_not_centered()); + let can_use_paint_order = !(row.element.style.fill().is_none() || mask_type == MaskType::Clip); - let can_use_order = !row.element.style.fill().is_none() && mask_type == MaskType::Mask; - if !can_use_order { - let id = format!("alignment-{}", generate_uuid()); + let push_id = if can_draw_aligned_stroke && !can_use_paint_order { + let id = format!("alignment-{}", generate_uuid()); - let mut element = row.element.clone(); - element.style.clear_stroke(); - element.style.set_fill(Fill::solid(Color::BLACK)); + let mut element = row.element.clone(); + element.style.clear_stroke(); + element.style.set_fill(Fill::solid(Color::BLACK)); - let vector_row = Table::new_from_row(TableRow { - element, - alpha_blending: *row.alpha_blending, - transform: *row.transform, - source_node_id: None, - }); + let vector_row = Table::new_from_row(TableRow { + element, + alpha_blending: *row.alpha_blending, + transform: *row.transform, + source_node_id: None, + }); - push_id = Some((id, mask_type, vector_row)); - } - } + Some((id, mask_type, vector_row)) + } else { + None + }; render.leaf_tag("path", |attributes| { attributes.push("d", path); @@ -485,16 +734,14 @@ impl Render for Table { } } - let fill_and_stroke = row.element.style.render( - defs, - element_transform, - applied_stroke_transform, - layer_bounds, - transformed_bounds, - can_draw_aligned_stroke, - can_draw_aligned_stroke && push_id.is_none(), - render_params, - ); + let mut render_params = render_params.clone(); + render_params.aligned_strokes = can_draw_aligned_stroke; + render_params.override_paint_order = can_draw_aligned_stroke && can_use_paint_order; + + let fill_and_stroke = row + .element + .style + .render(defs, element_transform, applied_stroke_transform, bounds_matrix, transformed_bounds_matrix, &render_params); if let Some((id, mask_type, _)) = push_id { let selector = format!("url(#{id})"); @@ -813,134 +1060,6 @@ impl Render for Table { } } -impl Render for Artboard { - fn render_svg(&self, render: &mut SvgRender, render_params: &RenderParams) { - // Rectangle for the artboard - if !render_params.hide_artboards { - // Background - render.leaf_tag("rect", |attributes| { - attributes.push("fill", format!("#{}", self.background.to_rgb_hex_srgb_from_gamma())); - if self.background.a() < 1. { - attributes.push("fill-opacity", ((self.background.a() * 1000.).round() / 1000.).to_string()); - } - attributes.push("x", self.location.x.min(self.location.x + self.dimensions.x).to_string()); - attributes.push("y", self.location.y.min(self.location.y + self.dimensions.y).to_string()); - attributes.push("width", self.dimensions.x.abs().to_string()); - attributes.push("height", self.dimensions.y.abs().to_string()); - }); - } - - // Artwork - render.parent_tag( - // SVG group tag - "g", - // Group tag attributes - |attributes| { - let matrix = format_transform_matrix(self.transform()); - if !matrix.is_empty() { - attributes.push("transform", matrix); - } - - if self.clip { - let id = format!("artboard-{}", generate_uuid()); - let selector = format!("url(#{id})"); - - write!( - &mut attributes.0.svg_defs, - r##""##, - self.dimensions.x, self.dimensions.y, - ) - .unwrap(); - attributes.push("clip-path", selector); - } - }, - // Artwork content - |render| { - self.content.render_svg(render, render_params); - }, - ); - } - - #[cfg(feature = "vello")] - fn render_to_vello(&self, scene: &mut Scene, transform: DAffine2, context: &mut RenderContext, render_params: &RenderParams) { - use vello::peniko; - - // Render background - let color = peniko::Color::new([self.background.r(), self.background.g(), self.background.b(), self.background.a()]); - let [a, b] = [self.location.as_dvec2(), self.location.as_dvec2() + self.dimensions.as_dvec2()]; - let rect = kurbo::Rect::new(a.x.min(b.x), a.y.min(b.y), a.x.max(b.x), a.y.max(b.y)); - - scene.push_layer(peniko::Mix::Normal, 1., kurbo::Affine::new(transform.to_cols_array()), &rect); - scene.fill(peniko::Fill::NonZero, kurbo::Affine::new(transform.to_cols_array()), color, None, &rect); - scene.pop_layer(); - - if self.clip { - let blend_mode = peniko::BlendMode::new(peniko::Mix::Clip, peniko::Compose::SrcOver); - scene.push_layer(blend_mode, 1., kurbo::Affine::new(transform.to_cols_array()), &rect); - } - // Since the content's transform is right multiplied in when rendering the content, we just need to right multiply by the artboard offset here. - let child_transform = transform * DAffine2::from_translation(self.location.as_dvec2()); - self.content.render_to_vello(scene, child_transform, context, render_params); - if self.clip { - scene.pop_layer(); - } - } - - fn collect_metadata(&self, metadata: &mut RenderMetadata, mut footprint: Footprint, element_id: Option) { - if let Some(element_id) = element_id { - let subpath = Subpath::new_rect(DVec2::ZERO, self.dimensions.as_dvec2()); - metadata.click_targets.insert(element_id, vec![ClickTarget::new_with_subpath(subpath, 0.)]); - metadata.upstream_footprints.insert(element_id, footprint); - metadata.local_transforms.insert(element_id, DAffine2::from_translation(self.location.as_dvec2())); - if self.clip { - metadata.clip_targets.insert(element_id); - } - } - footprint.transform *= self.transform(); - self.content.collect_metadata(metadata, footprint, None); - } - - fn add_upstream_click_targets(&self, click_targets: &mut Vec) { - let subpath_rectangle = Subpath::new_rect(DVec2::ZERO, self.dimensions.as_dvec2()); - click_targets.push(ClickTarget::new_with_subpath(subpath_rectangle, 0.)); - } - - fn contains_artboard(&self) -> bool { - true - } -} - -impl Render for Table { - fn render_svg(&self, render: &mut SvgRender, render_params: &RenderParams) { - for artboard in self.iter() { - artboard.element.render_svg(render, render_params); - } - } - - #[cfg(feature = "vello")] - fn render_to_vello(&self, scene: &mut Scene, transform: DAffine2, context: &mut RenderContext, render_params: &RenderParams) { - for row in self.iter() { - row.element.render_to_vello(scene, transform, context, render_params); - } - } - - fn collect_metadata(&self, metadata: &mut RenderMetadata, footprint: Footprint, _element_id: Option) { - for row in self.iter() { - row.element.collect_metadata(metadata, footprint, *row.source_node_id); - } - } - - fn add_upstream_click_targets(&self, click_targets: &mut Vec) { - for row in self.iter() { - row.element.add_upstream_click_targets(click_targets); - } - } - - fn contains_artboard(&self) -> bool { - self.iter().count() > 0 - } -} - impl Render for Table> { fn render_svg(&self, render: &mut SvgRender, render_params: &RenderParams) { for row in self.iter() { @@ -1142,110 +1261,71 @@ impl Render for Table> { } } -impl Render for Graphic { +impl Render for Table { fn render_svg(&self, render: &mut SvgRender, render_params: &RenderParams) { - match self { - Graphic::Graphic(graphic) => graphic.render_svg(render, render_params), - Graphic::Vector(vector) => vector.render_svg(render, render_params), - Graphic::RasterCPU(raster) => raster.render_svg(render, render_params), - Graphic::RasterGPU(_) => (), - Graphic::Color(color) => color.render_svg(render, render_params), - } - } - - #[cfg(feature = "vello")] - fn render_to_vello(&self, scene: &mut Scene, transform: DAffine2, context: &mut RenderContext, render_params: &RenderParams) { - match self { - Graphic::Graphic(graphic) => graphic.render_to_vello(scene, transform, context, render_params), - Graphic::Vector(vector) => vector.render_to_vello(scene, transform, context, render_params), - Graphic::RasterCPU(raster) => raster.render_to_vello(scene, transform, context, render_params), - Graphic::RasterGPU(raster) => raster.render_to_vello(scene, transform, context, render_params), - Graphic::Color(color) => color.render_to_vello(scene, transform, context, render_params), - } - } + for row in self.iter() { + render.leaf_tag("rect", |attributes| { + attributes.push("width", render_params.footprint.resolution.x.to_string()); + attributes.push("height", render_params.footprint.resolution.y.to_string()); - fn collect_metadata(&self, metadata: &mut RenderMetadata, footprint: Footprint, element_id: Option) { - if let Some(element_id) = element_id { - match self { - Graphic::Graphic(_) => { - metadata.upstream_footprints.insert(element_id, footprint); - } - Graphic::Vector(vector) => { - metadata.upstream_footprints.insert(element_id, footprint); - // TODO: Find a way to handle more than one row of the vector table - if let Some(vector) = vector.iter().next() { - metadata.first_element_source_id.insert(element_id, *vector.source_node_id); - metadata.local_transforms.insert(element_id, *vector.transform); - } + let matrix = format_transform_matrix(render_params.footprint.transform.inverse()); + if !matrix.is_empty() { + attributes.push("transform", matrix); } - Graphic::RasterCPU(raster) => { - metadata.upstream_footprints.insert(element_id, footprint); - // TODO: Find a way to handle more than one row of images - if let Some(raster) = raster.iter().next() { - metadata.local_transforms.insert(element_id, *raster.transform); - } + let color = row.element; + attributes.push("fill", format!("#{}", color.to_rgb_hex_srgb_from_gamma())); + if color.a() < 1. { + attributes.push("fill-opacity", ((color.a() * 1000.).round() / 1000.).to_string()); } - Graphic::RasterGPU(raster) => { - metadata.upstream_footprints.insert(element_id, footprint); - // TODO: Find a way to handle more than one row of images - if let Some(raster) = raster.iter().next() { - metadata.local_transforms.insert(element_id, *raster.transform); - } + let opacity = row.alpha_blending.opacity(render_params.for_mask); + if opacity < 1. { + attributes.push("opacity", opacity.to_string()); } - Graphic::Color(color) => { - metadata.upstream_footprints.insert(element_id, footprint); - // TODO: Find a way to handle more than one row of images - if let Some(color) = color.iter().next() { - metadata.local_transforms.insert(element_id, *color.transform); - } + if row.alpha_blending.blend_mode != BlendMode::default() { + attributes.push("style", row.alpha_blending.blend_mode.render()); } - } - } - - match self { - Graphic::Graphic(graphic) => graphic.collect_metadata(metadata, footprint, element_id), - Graphic::Vector(vector) => vector.collect_metadata(metadata, footprint, element_id), - Graphic::RasterCPU(raster) => raster.collect_metadata(metadata, footprint, element_id), - Graphic::RasterGPU(raster) => raster.collect_metadata(metadata, footprint, element_id), - Graphic::Color(color) => color.collect_metadata(metadata, footprint, element_id), + }); } } - fn add_upstream_click_targets(&self, click_targets: &mut Vec) { - match self { - Graphic::Graphic(graphic) => graphic.add_upstream_click_targets(click_targets), - Graphic::Vector(vector) => vector.add_upstream_click_targets(click_targets), - Graphic::RasterCPU(raster) => raster.add_upstream_click_targets(click_targets), - Graphic::RasterGPU(raster) => raster.add_upstream_click_targets(click_targets), - Graphic::Color(color) => color.add_upstream_click_targets(click_targets), - } - } + #[cfg(feature = "vello")] + fn render_to_vello(&self, scene: &mut Scene, parent_transform: DAffine2, _context: &mut RenderContext, render_params: &RenderParams) { + use vello::peniko; - fn contains_artboard(&self) -> bool { - match self { - Graphic::Graphic(graphic) => graphic.contains_artboard(), - Graphic::Vector(vector) => vector.contains_artboard(), - Graphic::RasterCPU(raster) => raster.contains_artboard(), - Graphic::RasterGPU(raster) => raster.contains_artboard(), - Graphic::Color(color) => color.contains_artboard(), - } - } + for row in self.iter() { + let alpha_blending = *row.alpha_blending; + let blend_mode = alpha_blending.blend_mode.to_peniko(); + let opacity = alpha_blending.opacity(render_params.for_mask); - fn new_ids_from_hash(&mut self, reference: Option) { - match self { - Graphic::Graphic(graphic) => graphic.new_ids_from_hash(reference), - Graphic::Vector(vector) => vector.new_ids_from_hash(reference), - Graphic::RasterCPU(_) => (), - Graphic::RasterGPU(_) => (), - Graphic::Color(_) => (), + let transform = parent_transform * render_params.footprint.transform.inverse(); + let color = row.element; + let vello_color = peniko::Color::new([color.r(), color.g(), color.b(), color.a()]); + + let rect = kurbo::Rect::from_origin_size( + kurbo::Point::ZERO, + kurbo::Size::new(render_params.footprint.resolution.x as f64, render_params.footprint.resolution.y as f64), + ); + + let mut layer = false; + if opacity < 1. || alpha_blending.blend_mode != BlendMode::default() { + let blending = peniko::BlendMode::new(blend_mode, peniko::Compose::SrcOver); + scene.push_layer(blending, opacity, kurbo::Affine::IDENTITY, &rect); + layer = true; + } + + scene.fill(peniko::Fill::NonZero, kurbo::Affine::new(transform.to_cols_array()), vello_color, None, &rect); + + if layer { + scene.pop_layer(); + } } } } -impl Render for Table { +impl Render for Table { fn render_svg(&self, render: &mut SvgRender, render_params: &RenderParams) { for row in self.iter() { render.leaf_tag("rect", |attributes| { @@ -1257,12 +1337,48 @@ impl Render for Table { attributes.push("transform", matrix); } - let color = row.element; - attributes.push("fill", format!("#{}", color.to_rgb_hex_srgb_from_gamma())); - if color.a() < 1. { - attributes.push("fill-opacity", ((color.a() * 1000.).round() / 1000.).to_string()); + let mut stop_string = String::new(); + for (position, color) in row.element.0.iter() { + let _ = write!(stop_string, r##""); + } + + let gradient_transform = render_params.footprint.transform * *row.transform; + let gradient_transform_matrix = format_transform_matrix(gradient_transform); + let gradient_transform_attribute = if gradient_transform_matrix.is_empty() { + String::new() + } else { + format!(r#" gradientTransform="{gradient_transform_matrix}""#) + }; + + let gradient_id = generate_uuid(); + let start = DVec2::ZERO; + let end = DVec2::X; + + match GradientType::Radial { + GradientType::Linear => { + let (x1, y1) = (start.x, start.y); + let (x2, y2) = (end.x, end.y); + let _ = write!( + &mut attributes.0.svg_defs, + r#"{stop_string}"# + ); + } + GradientType::Radial => { + let (cx, cy) = (start.x, start.y); + let r = start.distance(end); + let _ = write!( + &mut attributes.0.svg_defs, + r#"{stop_string}"# + ); + } } + attributes.push("fill", format!("url('#{gradient_id}')")); + let opacity = row.alpha_blending.opacity(render_params.for_mask); if opacity < 1. { attributes.push("opacity", opacity.to_string()); @@ -1285,7 +1401,7 @@ impl Render for Table { let opacity = alpha_blending.opacity(render_params.for_mask); let transform = parent_transform * render_params.footprint.transform.inverse(); - let color = row.element; + let color = row.element.0.first().map(|stop| stop.1).unwrap_or(Color::MAGENTA); let vello_color = peniko::Color::new([color.r(), color.g(), color.b(), color.a()]); let rect = kurbo::Rect::from_origin_size( @@ -1309,28 +1425,6 @@ impl Render for Table { } } -trait Primitive: std::fmt::Display + BoundingBox + RenderComplexity {} -impl Primitive for bool {} -impl Primitive for f32 {} -impl Primitive for f64 {} -impl Primitive for DVec2 {} -impl Primitive for String {} - -fn text_attributes(attributes: &mut SvgRenderAttrs) { - attributes.push("fill", "white"); - attributes.push("y", "30"); - attributes.push("font-size", "30"); -} - -impl Render for P { - fn render_svg(&self, render: &mut SvgRender, _render_params: &RenderParams) { - render.parent_tag("text", text_attributes, |render| render.leaf_node(format!("{self}"))); - } - - #[cfg(feature = "vello")] - fn render_to_vello(&self, _scene: &mut Scene, _transform: DAffine2, _context: &mut RenderContext, _render_params: &RenderParams) {} -} - #[derive(Debug, Clone, PartialEq, Eq)] pub enum SvgSegment { Slice(&'static str), diff --git a/node-graph/interpreted-executor/src/node_registry.rs b/node-graph/interpreted-executor/src/node_registry.rs index 5ac1c97a4e..673b481efc 100644 --- a/node-graph/interpreted-executor/src/node_registry.rs +++ b/node-graph/interpreted-executor/src/node_registry.rs @@ -20,6 +20,7 @@ use graphene_std::any::{ComposeTypeErased, DynAnyNode, IntoTypeErasedNode}; use graphene_std::application_io::{ImageTexture, SurfaceFrame}; use graphene_std::brush::brush_cache::BrushCache; use graphene_std::brush::brush_stroke::BrushStroke; +use graphene_std::gradient::GradientStops; use graphene_std::table::Table; use graphene_std::uuid::NodeId; use graphene_std::vector::Vector; @@ -63,6 +64,7 @@ fn node_registry() -> HashMap, input: Context, fn_params: [Context => Table>]), async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => Table]), + async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => Table]), async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => String]), async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => IVec2]), async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => DVec2]), @@ -83,7 +85,7 @@ fn node_registry() -> HashMap, input: Context, fn_params: [Context => graphene_core::vector::style::StrokeAlign]), async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => graphene_core::vector::style::Stroke]), async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => graphene_core::vector::style::Gradient]), - async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => graphene_core::vector::style::GradientStops]), + async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => GradientStops]), async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => Vec]), async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => Box]), async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => graphene_std::vector::misc::CentroidType]), @@ -130,6 +132,7 @@ fn node_registry() -> HashMap, input: Context, fn_params: [Context => Table>]), async_node!(graphene_core::memo::MemoNode<_, _>, input: Context, fn_params: [Context => Table]), async_node!(graphene_core::memo::MemoNode<_, _>, input: Context, fn_params: [Context => Image]), + async_node!(graphene_core::memo::MemoNode<_, _>, input: Context, fn_params: [Context => Table]), async_node!(graphene_core::memo::MemoNode<_, _>, input: Context, fn_params: [Context => Vec]), #[cfg(feature = "gpu")] async_node!(graphene_core::memo::MemoNode<_, _>, input: Context, fn_params: [Context => Arc]), @@ -154,6 +157,7 @@ fn node_registry() -> HashMap, input: Context, fn_params: [Context => Table>]), async_node!(graphene_core::memo::ImpureMemoNode<_, _, _>, input: Context, fn_params: [Context => Table]), + async_node!(graphene_core::memo::ImpureMemoNode<_, _, _>, input: Context, fn_params: [Context => Table]), async_node!(graphene_core::memo::ImpureMemoNode<_, _, _>, input: Context, fn_params: [Context => WgpuSurface]), async_node!(graphene_core::memo::ImpureMemoNode<_, _, _>, input: Context, fn_params: [Context => Option]), async_node!(graphene_core::memo::ImpureMemoNode<_, _, _>, input: Context, fn_params: [Context => ImageTexture]), diff --git a/node-graph/node-macro/src/parsing.rs b/node-graph/node-macro/src/parsing.rs index 3c54fc87b5..9d5122bb2a 100644 --- a/node-graph/node-macro/src/parsing.rs +++ b/node-graph/node-macro/src/parsing.rs @@ -1276,9 +1276,11 @@ mod tests { #[implementations( () -> Table>, () -> Table, + () -> Table, () -> GradientStops, Footprint -> Table>, Footprint -> Table, + Footprint -> Table, Footprint -> GradientStops, )] image: impl Node,