Add path-bool library

Cargo.toml

@@ -16,6 +16,7 @@ members = [
 	"node-graph/gpu-executor",
 	"node-graph/gpu-compiler/gpu-compiler-bin-wrapper",
 	"libraries/dyn-any",
+	"libraries/path-bool",
 	"libraries/bezier-rs",
 	"libraries/raw-rs",
 	"libraries/raw-rs/tag-derive",
@@ -32,6 +33,7 @@ graphene-core = { path = "node-graph/gcore" }
 graph-craft = { path = "node-graph/graph-craft", features = ["serde"] }
 wgpu-executor = { path = "node-graph/wgpu-executor" }
 bezier-rs = { path = "libraries/bezier-rs", features = ["dyn-any"] }
+path-bool = { path = "libraries/path-bool", features = ["parsing"] }
 node-macro = { path = "node-graph/node-macro" }
 
 # Workspace dependencies

editor/src/messages/portfolio/document/graph_operation/utility_types.rs

@@ -145,15 +145,15 @@ impl<'a> ModifyInputsContext<'a> {
 	}
 
 	pub fn insert_vector_data(&mut self, subpaths: Vec<Subpath<PointId>>, layer: LayerNodeIdentifier) {
-		let shape = resolve_document_node_type("Shape")
-			.expect("Shape node does not exist")
+		let path = resolve_document_node_type("Path")
+			.expect("Path node does not exist")
 			.node_template_input_override([Some(NodeInput::value(TaggedValue::Subpaths(subpaths), false))]);
 		let transform = resolve_document_node_type("Transform").expect("Transform node does not exist").default_node_template();
 		let fill = resolve_document_node_type("Fill").expect("Fill node does not exist").default_node_template();
 		let stroke = resolve_document_node_type("Stroke").expect("Stroke node does not exist").default_node_template();
 
 		let shape_id = NodeId(generate_uuid());
-		self.network_interface.insert_node(shape_id, shape, &[]);
+		self.network_interface.insert_node(shape_id, path, &[]);
 		self.network_interface.move_node_to_chain_start(&shape_id, layer, &[]);
 
 		let transform_id = NodeId(generate_uuid());

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

@@ -2159,12 +2159,13 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 							DocumentNode {
 								inputs: vec![NodeInput::network(concrete!(VectorData), 0), NodeInput::network(concrete!(vector::style::Fill), 1)],
 								implementation: DocumentNodeImplementation::ProtoNode(ProtoNodeIdentifier::new("graphene_std::vector::BooleanOperationNode")),
+								manual_composition: Some(generic!(T)),
 								..Default::default()
 							},
 							DocumentNode {
 								inputs: vec![NodeInput::node(NodeId(0), 0)],
 								implementation: DocumentNodeImplementation::ProtoNode(ProtoNodeIdentifier::new("graphene_core::memo::ImpureMemoNode")),
-								manual_composition: Some(concrete!(Footprint)),
+								manual_composition: Some(generic!(T)),
 								..Default::default()
 							},
 						]

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

@@ -2268,17 +2268,10 @@ pub(crate) fn generate_node_properties(document_node: &DocumentNode, node_id: No
 }
 
 pub(crate) fn boolean_operation_properties(document_node: &DocumentNode, node_id: NodeId, _context: &mut NodePropertiesContext) -> Vec<LayoutGroup> {
-	let group_of_paths_index = 0;
 	let operation_index = 1;
-
-	let mut widgets = start_widgets(document_node, node_id, group_of_paths_index, "Group of Paths", FrontendGraphDataType::Graphic, true);
-
-	widgets.push(Separator::new(SeparatorType::Unrelated).widget_holder());
-	widgets.push(TextLabel::new("The output of a layer stack, which contains all elements to operate on").widget_holder());
-
 	let operation = boolean_operation_radio_buttons(document_node, node_id, operation_index, "Operation", true);
 
-	vec![LayoutGroup::Row { widgets }, operation]
+	vec![operation]
 }
 
 pub(crate) fn copy_to_points_properties(document_node: &DocumentNode, node_id: NodeId, _context: &mut NodePropertiesContext) -> Vec<LayoutGroup> {

libraries/bezier-rs/src/bezier/core.rs

@@ -113,16 +113,9 @@ impl Bezier {
 
 	/// Return the string argument used to create a curve in an SVG `path`, excluding the start point.
 	pub fn svg_curve_argument(&self) -> String {
-		let handle_args = match self.handles {
-			BezierHandles::Linear => SVG_ARG_LINEAR.to_string(),
-			BezierHandles::Quadratic { handle } => {
-				format!("{SVG_ARG_QUADRATIC}{} {}", handle.x, handle.y)
-			}
-			BezierHandles::Cubic { handle_start, handle_end } => {
-				format!("{SVG_ARG_CUBIC}{} {} {} {}", handle_start.x, handle_start.y, handle_end.x, handle_end.y)
-			}
-		};
-		format!("{handle_args} {} {}", self.end.x, self.end.y)
+		let mut out = String::new();
+		self.write_curve_argument(&mut out).unwrap();
+		out
 	}
 
 	/// Write the curve argument to the string

libraries/path-bool/.gitignore

@@ -0,0 +1,2 @@
+/target
+test-results

libraries/path-bool/Cargo.toml

@@ -0,0 +1,38 @@
+[package]
+name = "path-bool"
+version = "0.1.0"
+rust-version = "1.81"
+authors = ["Graphite Authors <contact@graphite.rs>"]
+edition = "2021"
+keywords = ["bezier", "boolean", "path", "ops", "operations", "2d"]
+categories = ["graphics", "mathematics"]
+license = "MIT OR Apache-2.0"
+
+
+[features]
+logging = ["parsing"]
+parsing = []
+default = ["parsing"]
+
+[dependencies]
+glam = "0.28.0"
+regex = "1.10.6"
+slotmap = "1.0.7"
+
+[dev-dependencies]
+glob = "0.3"
+svg = "0.13"
+resvg = "0.42"
+image = "0.24"
+
+# Required dependencies
+criterion = { version = "0.5", features = ["html_reports"]}
+
+# Benchmarks
+[[bench]]
+name = "painted_dreams"
+harness = false
+
+[[bench]]
+name = "path_segment_intersection"
+harness = false