clean up

node-graph/gcore/src/lib.rs

@@ -17,6 +17,7 @@ pub mod logic;
 pub mod math;
 pub mod memo;
 pub mod misc;
+pub mod node_graph_overlay;
 pub mod ops;
 pub mod raster;
 pub mod raster_types;

node-graph/gcore/src/node_graph_overlay.rs

@@ -0,0 +1,47 @@
+use graphene_core_shaders::{Ctx, color::Color};
+use kurbo::{BezPath, Point};
+
+use crate::{ExtractFootprint, table::Table, vector::Vector};
+
+pub mod types;
+
+#[node_macro::node(category(""))]
+pub fn generate_nodes(_: impl Ctx, _node_graph_overlay_data: types::NodeGraphOverlayData) -> Table<Vector> {
+	Table::new()
+}
+
+#[node_macro::node(category(""))]
+pub fn transform_nodes(_ctx: impl Ctx + ExtractFootprint, nodes: Table<Vector>) -> Table<Vector> {
+	nodes
+}
+
+#[node_macro::node(category(""))]
+pub fn dot_grid_background(ctx: impl Ctx + ExtractFootprint, opacity: f64) -> Table<Vector> {
+	let Some(footprint) = ctx.try_footprint() else {
+		log::error!("Could not get footprint from context in dot_grid_background");
+		return Table::new();
+	};
+	// From --color-2-mildblack: --color-2-mildblack-rgb: 34, 34, 34;
+	let gray = (34. / 255.) as f32;
+	let Some(bg_color) = Color::from_rgbaf32(gray, gray, gray, opacity as f32) else {
+		log::error!("Could not create color in dot grid background");
+		return Table::new();
+	};
+
+	let mut bez_path = BezPath::new();
+	let p0 = Point::new(0., 0.); // bottom-left
+	let p1 = Point::new(footprint.resolution.x as f64, 0.); // bottom-right
+	let p2 = Point::new(footprint.resolution.x as f64, footprint.resolution.y as f64); // top-right
+	let p3 = Point::new(0., footprint.resolution.y as f64); // top-left
+
+	bez_path.move_to(p0);
+	bez_path.line_to(p1);
+	bez_path.line_to(p2);
+	bez_path.line_to(p3);
+	bez_path.close_path();
+
+	let mut vector = Vector::from_bezpath(bez_path);
+	vector.style.fill = crate::vector::style::Fill::Solid(bg_color);
+
+	Table::new_from_element(vector)
+}

node-graph/gcore/src/node_graph_overlay/types.rs

@@ -0,0 +1,170 @@
+use crate::uuid::NodeId;
+
+#[derive(Clone, Debug, Default, PartialEq, Hash, dyn_any::DynAny, serde::Serialize, serde::Deserialize, specta::Type)]
+
+pub struct NodeGraphOverlayData {
+	pub nodes_to_render: Vec<FrontendNodeToRender>,
+	pub open: bool,
+	pub in_selected_network: bool,
+	// Displays a dashed border around the node
+	pub previewed_node: Option<NodeId>,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Hash, dyn_any::DynAny, serde::Serialize, serde::Deserialize, specta::Type)]
+pub struct FrontendNodeToRender {
+	pub metadata: FrontendNodeMetadata,
+	#[serde(rename = "nodeOrLayer")]
+	pub node_or_layer: FrontendNodeOrLayer,
+	//TODO: Remove
+	pub wires: Vec<(String, bool, FrontendGraphDataType)>,
+}
+
+// Metadata that is common to nodes and layers
+#[derive(Clone, Debug, Default, PartialEq, Hash, dyn_any::DynAny, serde::Serialize, serde::Deserialize, specta::Type)]
+
+pub struct FrontendNodeMetadata {
+	#[serde(rename = "nodeId")]
+	pub node_id: NodeId,
+	// TODO: Remove and replace with popup manager system
+	#[serde(rename = "canBeLayer")]
+	pub can_be_layer: bool,
+	#[serde(rename = "displayName")]
+	pub display_name: String,
+	pub selected: bool,
+	// Used to get the description, which is stored in a global hashmap
+	pub reference: Option<String>,
+	// Reduces opacity of node/hidden eye icon
+	pub visible: bool,
+	// The svg string for each input
+	// pub wires: Vec<Option<String>>,
+	pub errors: Option<String>,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Hash, dyn_any::DynAny, serde::Serialize, serde::Deserialize, specta::Type)]
+
+pub struct FrontendNode {
+	// pub position: FrontendNodePosition,
+	pub position: FrontendXY,
+	pub inputs: Vec<Option<FrontendGraphInput>>,
+	pub outputs: Vec<Option<FrontendGraphOutput>>,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Hash, dyn_any::DynAny, serde::Serialize, serde::Deserialize, specta::Type)]
+
+pub struct FrontendLayer {
+	#[serde(rename = "bottomInput")]
+	pub bottom_input: FrontendGraphInput,
+	#[serde(rename = "sideInput")]
+	pub side_input: Option<FrontendGraphInput>,
+	pub output: FrontendGraphOutput,
+	// pub position: FrontendLayerPosition,
+	pub position: FrontendXY,
+	pub locked: bool,
+	#[serde(rename = "chainWidth")]
+	pub chain_width: u32,
+	#[serde(rename = "layerHasLeftBorderGap")]
+	pub layer_has_left_border_gap: bool,
+	#[serde(rename = "primaryInputConnectedToLayer")]
+	pub primary_input_connected_to_layer: bool,
+	#[serde(rename = "primaryOutputConnectedToLayer")]
+	pub primary_output_connected_to_layer: bool,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Hash, dyn_any::DynAny, serde::Serialize, serde::Deserialize, specta::Type)]
+
+pub struct FrontendXY {
+	pub x: i32,
+	pub y: i32,
+}
+
+// // Should be an enum but those are hard to serialize/deserialize to TS
+// #[derive(Clone, Debug, Default, PartialEq, Hash, dyn_any::DynAny, serde::Serialize, serde::Deserialize, specta::Type)]
+
+// pub struct FrontendNodePosition {
+// 	pub absolute: Option<FrontendXY>,
+// 	pub chain: Option<bool>,
+// }
+
+// // Should be an enum but those are hard to serialize/deserialize to TS
+// #[derive(Clone, Debug, Default, PartialEq, Hash, dyn_any::DynAny, serde::Serialize, serde::Deserialize, specta::Type)]
+
+// pub struct FrontendLayerPosition {
+// 	pub absolute: Option<FrontendXY>,
+// 	pub stack: Option<u32>,
+// }
+
+#[derive(Clone, Debug, Default, PartialEq, Hash, dyn_any::DynAny, serde::Serialize, serde::Deserialize, specta::Type)]
+
+pub struct FrontendNodeOrLayer {
+	pub node: Option<FrontendNode>,
+	pub layer: Option<FrontendLayer>,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Hash, dyn_any::DynAny, serde::Serialize, serde::Deserialize, specta::Type)]
+
+pub struct FrontendGraphInput {
+	#[serde(rename = "dataType")]
+	pub data_type: FrontendGraphDataType,
+	#[serde(rename = "resolvedType")]
+	pub resolved_type: String,
+	pub name: String,
+	pub description: String,
+	/// Either "nothing", "import index {index}", or "{node name} output {output_index}".
+	#[serde(rename = "connectedToString")]
+	pub connected_to: String,
+	/// Used to render the upstream node once this node is rendered
+	#[serde(rename = "connectedToNode")]
+	pub connected_to_node: Option<NodeId>,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Hash, dyn_any::DynAny, serde::Serialize, serde::Deserialize, specta::Type)]
+
+pub struct FrontendGraphOutput {
+	#[serde(rename = "dataType")]
+	pub data_type: FrontendGraphDataType,
+	pub name: String,
+	#[serde(rename = "resolvedType")]
+	pub resolved_type: String,
+	pub description: String,
+	/// If connected to an export, it is "export index {index}".
+	/// If connected to a node, it is "{node name} input {input_index}".
+	#[serde(rename = "connectedTo")]
+	pub connected_to: Vec<String>,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Hash, dyn_any::DynAny, serde::Serialize, serde::Deserialize, specta::Type)]
+
+pub struct FrontendExport {
+	pub port: FrontendGraphInput,
+	pub wire: Option<String>,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Hash, dyn_any::DynAny, serde::Serialize, serde::Deserialize, specta::Type)]
+
+pub struct FrontendExports {
+	/// If the primary export is not visible, then it is None.
+	pub exports: Vec<Option<FrontendExport>>,
+	#[serde(rename = "previewWire")]
+	pub preview_wire: Option<String>,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Hash, dyn_any::DynAny, serde::Serialize, serde::Deserialize, specta::Type)]
+
+pub struct FrontendImport {
+	pub port: FrontendGraphOutput,
+	pub wires: Vec<String>,
+}
+
+#[derive(Copy, Clone, Debug, Default, PartialEq, Hash, dyn_any::DynAny, serde::Serialize, serde::Deserialize, specta::Type)]
+pub enum FrontendGraphDataType {
+	#[default]
+	General,
+	Number,
+	Artboard,
+	Graphic,
+	Raster,
+	Vector,
+	Color,
+	Gradient,
+	Typography,
+}

node-graph/gcore/src/types.rs

@@ -126,7 +126,7 @@ impl std::fmt::Debug for NodeIOTypes {
 	}
 }
 
-#[derive(Clone, Debug, PartialEq, Eq, Hash, specta::Type, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
 pub struct ProtoNodeIdentifier {
 	pub name: Cow<'static, str>,
 }
@@ -230,7 +230,7 @@ impl PartialEq for TypeDescriptor {
 }
 
 /// Graph runtime type information used for type inference.
-#[derive(Clone, PartialEq, Eq, Hash, specta::Type, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
 pub enum Type {
 	/// A wrapper for some type variable used within the inference system. Resolved at inference time and replaced with a concrete type.
 	Generic(Cow<'static, str>),

node-graph/graph-craft/src/document/value.rs

@@ -262,6 +262,7 @@ tagged_value! {
 	CentroidType(graphene_core::vector::misc::CentroidType),
 	BooleanOperation(graphene_path_bool::BooleanOperation),
 	TextAlign(graphene_core::text::TextAlign),
+	NodeGraphOverlayData(graphene_core::node_graph_overlay::types::NodeGraphOverlayData),
 }
 
 impl TaggedValue {