merge onto master

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

@@ -108,6 +108,16 @@ macro_rules! tagged_value {
 					_ => Err(format!("Cannot convert {:?} to TaggedValue",std::any::type_name_of_val(input))),
 				}
 			}
+			// Check for equality between a dynamic type and a tagged value without cloning
+			pub fn compare_value_to_dyn_any(&self, any: Box<dyn std::any::Any + Send + Sync>) -> bool {
+				match self {
+					TaggedValue::None => any.downcast_ref::<()>().is_some(),
+					$(TaggedValue::$identifier(value) => {any.downcast_ref::<$ty>().map_or(false, |v| v==value)}, )*
+					TaggedValue::RenderOutput(value) => any.downcast_ref::<RenderOutput>().map_or(false, |v| v==value),
+					TaggedValue::SurfaceFrame(value) => any.downcast_ref::<SurfaceFrame>().map_or(false, |v| v==value),
+					TaggedValue::EditorApi(value) => any.downcast_ref::<Arc<WasmEditorApi>>().map_or(false, |v| v==value),
+				}
+			}
 			pub fn from_type(input: &Type) -> Option<Self> {
 				match input {
 					Type::Generic(_) => None,
@@ -372,6 +382,18 @@ impl TaggedValue {
 			_ => panic!("Passed value is not of type u32"),
 		}
 	}
+
+	pub fn as_renderable<'a>(value: &'a TaggedValue) -> Option<&'a dyn graphene_svg_renderer::GraphicElementRendered> {
+		match value {
+			TaggedValue::VectorData(v) => Some(v),
+			TaggedValue::RasterData(r) => Some(r),
+			TaggedValue::GraphicElement(e) => Some(e),
+			TaggedValue::GraphicGroup(g) => Some(g),
+			TaggedValue::ArtboardGroup(a) => Some(a),
+			TaggedValue::Artboard(a) => Some(a),
+			_ => None,
+		}
+	}
 }
 
 impl Display for TaggedValue {

node-graph/graph-craft/src/graphene_compiler.rs

@@ -1,36 +1 @@
-use crate::document::NodeNetwork;
-use crate::proto::{LocalFuture, ProtoNetwork};
-use std::error::Error;
 
-pub struct Compiler {}
-
-impl Compiler {
-	pub fn compile(&self, mut network: NodeNetwork) -> impl Iterator<Item = Result<ProtoNetwork, String>> {
-		let node_ids = network.nodes.keys().copied().collect::<Vec<_>>();
-		network.populate_dependants();
-		for id in node_ids {
-			network.flatten(id);
-		}
-		network.resolve_scope_inputs();
-		network.remove_redundant_id_nodes();
-		// network.remove_dead_nodes(0);
-		let proto_networks = network.into_proto_networks();
-
-		proto_networks.map(move |mut proto_network| {
-			proto_network.resolve_inputs()?;
-			proto_network.generate_stable_node_ids();
-			Ok(proto_network)
-		})
-	}
-	pub fn compile_single(&self, network: NodeNetwork) -> Result<ProtoNetwork, String> {
-		assert_eq!(network.exports.len(), 1, "Graph with multiple outputs not yet handled");
-		let Some(proto_network) = self.compile(network).next() else {
-			return Err("Failed to convert graph into proto graph".to_string());
-		};
-		proto_network
-	}
-}
-
-pub trait Executor<I, O> {
-	fn execute(&self, input: I) -> LocalFuture<'_, Result<O, Box<dyn Error>>>;
-}

node-graph/graph-craft/src/util.rs

@@ -1,6 +1,5 @@
 use crate::document::NodeNetwork;
 use crate::graphene_compiler::Compiler;
-use crate::proto::ProtoNetwork;
 
 pub fn load_network(document_string: &str) -> NodeNetwork {
 	let document: serde_json::Value = serde_json::from_str(document_string).expect("Failed to parse document");
@@ -8,11 +7,6 @@ pub fn load_network(document_string: &str) -> NodeNetwork {
 	serde_json::from_str::<NodeNetwork>(&document).expect("Failed to parse document")
 }
 
-pub fn compile(network: NodeNetwork) -> ProtoNetwork {
-	let compiler = Compiler {};
-	compiler.compile_single(network).unwrap()
-}
-
 pub fn load_from_name(name: &str) -> NodeNetwork {
 	let content = std::fs::read(format!("../../demo-artwork/{name}.graphite")).expect("failed to read file");
 	let content = std::str::from_utf8(&content).unwrap();