Deprecate LetNodes in favor of new scope API (#1814)

* WIP

* Start deprecating let nodes

* Replace WasmEditorApi network imports with new Scope input

* Add missing unwrap

* Add #[serde(default)] to scope_injections

* Restructure WasmEditorApi definition to be available as a TaggedValue

* Fix text node

* Use stable toolchain in nix shell again

* Code review

* FIx text node and remove all remaining warnings

* Require executor input to be 'static

---------

Co-authored-by: Keavon Chambers <keavon@keavon.com>

node-graph/graph-craft/Cargo.toml

@@ -8,6 +8,7 @@ license = "MIT OR Apache-2.0"
 default = ["dealloc_nodes"]
 serde = ["dep:serde", "graphene-core/serde", "glam/serde", "bezier-rs/serde"]
 dealloc_nodes = []
+wgpu = ["wgpu-executor"]
 
 [dependencies]
 # Local dependencies
@@ -27,6 +28,19 @@ bezier-rs = { workspace = true }
 specta = { workspace = true }
 bytemuck = { workspace = true }
 rustc-hash = { workspace = true }
+url = { workspace = true }
+reqwest = { workspace = true }
 
 # Optional workspace dependencies
+wgpu-executor = { workspace = true, optional = true }
 serde = { workspace = true, optional = true }
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+# Workspace dependencies
+web-sys = { workspace = true }
+js-sys = { workspace = true }
+wasm-bindgen = { workspace = true }
+
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+# Workspace dependencies
+winit = { workspace = true }

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

@@ -3,7 +3,7 @@ use crate::proto::{ConstructionArgs, ProtoNetwork, ProtoNode, ProtoNodeInput};
 
 use dyn_any::{DynAny, StaticType};
 pub use graphene_core::uuid::generate_uuid;
-use graphene_core::{ProtoNodeIdentifier, Type};
+use graphene_core::{Cow, ProtoNodeIdentifier, Type};
 
 use glam::IVec2;
 use std::collections::hash_map::DefaultHasher;
@@ -365,6 +365,7 @@ impl DocumentNode {
 				}
 				NodeInput::Network { import_type, .. } => (ProtoNodeInput::ManualComposition(import_type), ConstructionArgs::Nodes(vec![])),
 				NodeInput::Inline(inline) => (ProtoNodeInput::None, ConstructionArgs::Inline(inline)),
+				NodeInput::Scope(_) => unreachable!("Scope input was not resolved"),
 			}
 		};
 		assert!(!self.inputs.iter().any(|input| matches!(input, NodeInput::Network { .. })), "received non resolved parameter");
@@ -452,6 +453,9 @@ pub enum NodeInput {
 	/// Input that is provided by the parent network to this document node, instead of from a hardcoded value or another node within the same network.
 	Network { import_type: Type, import_index: usize },
 
+	/// Input that is extracted from the parent scopes the node resides in. The string argument is the key.
+	Scope(Cow<'static, str>),
+
 	/// A Rust source code string. Allows us to insert literal Rust code. Only used for GPU compilation.
 	/// We can use this whenever we spin up Rustc. Sort of like inline assembly, but because our language is Rust, it acts as inline Rust.
 	Inline(InlineRust),
@@ -474,15 +478,23 @@ impl NodeInput {
 	pub const fn node(node_id: NodeId, output_index: usize) -> Self {
 		Self::Node { node_id, output_index, lambda: false }
 	}
+
 	pub const fn lambda(node_id: NodeId, output_index: usize) -> Self {
 		Self::Node { node_id, output_index, lambda: true }
 	}
+
 	pub const fn value(tagged_value: TaggedValue, exposed: bool) -> Self {
 		Self::Value { tagged_value, exposed }
 	}
+
 	pub const fn network(import_type: Type, import_index: usize) -> Self {
 		Self::Network { import_type, import_index }
 	}
+
+	pub fn scope(key: impl Into<Cow<'static, str>>) -> Self {
+		Self::Scope(key.into())
+	}
+
 	fn map_ids(&mut self, f: impl Fn(NodeId) -> NodeId) {
 		if let &mut NodeInput::Node { node_id, output_index, lambda } = self {
 			*self = NodeInput::Node {
@@ -492,22 +504,27 @@ impl NodeInput {
 			}
 		}
 	}
+
 	pub fn is_exposed(&self) -> bool {
 		match self {
 			NodeInput::Node { .. } => true,
 			NodeInput::Value { exposed, .. } => *exposed,
 			NodeInput::Network { .. } => true,
 			NodeInput::Inline(_) => false,
+			NodeInput::Scope(_) => false,
 		}
 	}
+
 	pub fn ty(&self) -> Type {
 		match self {
 			NodeInput::Node { .. } => unreachable!("ty() called on NodeInput::Node"),
 			NodeInput::Value { tagged_value, .. } => tagged_value.ty(),
 			NodeInput::Network { import_type, .. } => import_type.clone(),
 			NodeInput::Inline(_) => panic!("ty() called on NodeInput::Inline"),
+			NodeInput::Scope(_) => unreachable!("ty() called on NodeInput::Scope"),
 		}
 	}
+
 	pub fn as_value(&self) -> Option<&TaggedValue> {
 		if let NodeInput::Value { tagged_value, .. } = self {
 			Some(tagged_value)
@@ -515,6 +532,7 @@ impl NodeInput {
 			None
 		}
 	}
+
 	pub fn as_node(&self) -> Option<NodeId> {
 		if let NodeInput::Node { node_id, .. } = self {
 			Some(*node_id)
@@ -666,6 +684,10 @@ pub struct NodeNetwork {
 	pub imports_metadata: (NodeId, IVec2),
 	#[serde(default = "default_export_metadata")]
 	pub exports_metadata: (NodeId, IVec2),
+
+	/// A network may expose nodes as constants which can by used by other nodes using a `NodeInput::Scope(key)`.
+	#[serde(default)]
+	pub scope_injections: HashMap<String, (NodeId, Type)>,
 }
 
 impl std::hash::Hash for NodeNetwork {
@@ -688,6 +710,7 @@ impl Default for NodeNetwork {
 			previewing: Default::default(),
 			imports_metadata: default_import_metadata(),
 			exports_metadata: default_export_metadata(),
+			scope_injections: Default::default(),
 		}
 	}
 }
@@ -963,7 +986,7 @@ impl<'a> Iterator for FlowIter<'a> {
 			let mut node_id = self.stack.pop()?;
 
 			// Special handling for iterating from ROOT_PARENT in load_structure`
-			if node_id == NodeId(std::u64::MAX) {
+			if node_id == NodeId(u64::MAX) {
 				if let Some(root_node) = self.network.get_root_node() {
 					node_id = root_node.id
 				} else {
@@ -1000,6 +1023,7 @@ impl NodeNetwork {
 				root_node_to_restore.id = f(root_node_to_restore.id);
 			}
 		}
+		self.scope_injections.values_mut().for_each(|(id, _ty)| *id = f(*id));
 		let nodes = std::mem::take(&mut self.nodes);
 		self.nodes = nodes
 			.into_iter()
@@ -1110,6 +1134,18 @@ impl NodeNetwork {
 		are_inputs_used
 	}
 
+	pub fn resolve_scope_inputs(&mut self) {
+		for node in self.nodes.values_mut() {
+			for input in node.inputs.iter_mut() {
+				if let NodeInput::Scope(key) = input {
+					let (import_id, _ty) = self.scope_injections.get(key.as_ref()).expect("Tried to import a non existent key from scope");
+					// TODO use correct output index
+					*input = NodeInput::node(*import_id, 0);
+				}
+			}
+		}
+	}
+
 	/// Remove all nodes that contain [`DocumentNodeImplementation::Network`] by moving the nested nodes into the parent network.
 	pub fn flatten(&mut self, node_id: NodeId) {
 		self.flatten_with_fns(node_id, merge_ids, || NodeId(generate_uuid()))
@@ -1204,6 +1240,17 @@ impl NodeNetwork {
 			inner_network.map_ids(|inner_id| map_ids(id, inner_id));
 			let new_nodes = inner_network.nodes.keys().cloned().collect::<Vec<_>>();
 
+			for (key, value) in inner_network.scope_injections.into_iter() {
+				match self.scope_injections.entry(key) {
+					std::collections::hash_map::Entry::Occupied(o) => {
+						log::warn!("Found duplicate scope injection for key {}, ignoring", o.key());
+					}
+					std::collections::hash_map::Entry::Vacant(v) => {
+						v.insert(value);
+					}
+				}
+			}
+
 			// Match the document node input and the inputs of the inner network
 			for (nested_node_id, mut nested_node) in inner_network.nodes.into_iter() {
 				if nested_node.name == "To Artboard" {
@@ -1232,6 +1279,12 @@ impl NodeNetwork {
 							}
 							NodeInput::Value { .. } => unreachable!("Value inputs should have been replaced with value nodes"),
 							NodeInput::Inline(_) => (),
+							NodeInput::Scope(ref key) => {
+								log::debug!("flattening scope: {}", key);
+								let (import_id, _ty) = self.scope_injections.get(key.as_ref()).expect("Tried to import a non existent key from scope");
+								// TODO use correct output index
+								nested_node.inputs[nested_input_index] = NodeInput::node(*import_id, 0);
+							}
 						}
 					}
 				}

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

@@ -2,6 +2,7 @@ use super::DocumentNode;
 use crate::graphene_compiler::Any;
 pub use crate::imaginate_input::{ImaginateCache, ImaginateController, ImaginateMaskStartingFill, ImaginateSamplingMethod};
 use crate::proto::{Any as DAny, FutureAny};
+use crate::wasm_application_io::WasmEditorApi;
 
 use graphene_core::raster::brush_cache::BrushCache;
 use graphene_core::raster::{BlendMode, LuminanceCalculation};
@@ -12,6 +13,7 @@ pub use dyn_any::StaticType;
 pub use glam::{DAffine2, DVec2, IVec2, UVec2};
 use std::fmt::Display;
 use std::hash::Hash;
+use std::marker::PhantomData;
 pub use std::sync::Arc;
 
 /// Macro to generate the tagged value enum.
@@ -25,6 +27,8 @@ macro_rules! tagged_value {
 			$( $(#[$meta] ) *$identifier( $ty ), )*
 			RenderOutput(RenderOutput),
 			SurfaceFrame(graphene_core::SurfaceFrame),
+			#[serde(skip)]
+			EditorApi(Arc<WasmEditorApi>)
 		}
 
 		// We must manually implement hashing because some values are floats and so do not reproducibly hash (see FakeHash below)
@@ -37,6 +41,7 @@ macro_rules! tagged_value {
 					$( Self::$identifier(x) => {x.hash(state)}),*
 					Self::RenderOutput(x) => x.hash(state),
 					Self::SurfaceFrame(x) => x.hash(state),
+					Self::EditorApi(x) => x.hash(state),
 				}
 			}
 		}
@@ -48,6 +53,7 @@ macro_rules! tagged_value {
 					$( Self::$identifier(x) => Box::new(x), )*
 					Self::RenderOutput(x) => Box::new(x),
 					Self::SurfaceFrame(x) => Box::new(x),
+					Self::EditorApi(x) => Box::new(x),
 				}
 			}
 			/// Creates a graphene_core::Type::Concrete(TypeDescriptor { .. }) with the type of the value inside the tagged value
@@ -57,6 +63,7 @@ macro_rules! tagged_value {
 					$( Self::$identifier(_) => concrete!($ty), )*
 					Self::RenderOutput(_) => concrete!(RenderOutput),
 					Self::SurfaceFrame(_) => concrete!(graphene_core::SurfaceFrame),
+					Self::EditorApi(_) => concrete!(&WasmEditorApi)
 				}
 			}
 			/// Attempts to downcast the dynamic type to a tagged value
@@ -172,6 +179,7 @@ tagged_value! {
 	VectorModification(graphene_core::vector::VectorModification),
 	CentroidType(graphene_core::vector::misc::CentroidType),
 	BooleanOperation(graphene_core::vector::misc::BooleanOperation),
+	FontCache(Arc<graphene_core::text::FontCache>),
 }
 
 impl TaggedValue {
@@ -218,6 +226,22 @@ impl UpcastNode {
 		Self { value }
 	}
 }
+#[derive(Default, Debug, Clone, Copy)]
+pub struct UpcastAsRefNode<T: AsRef<U>, U>(pub T, PhantomData<U>);
+
+impl<'i, T: 'i + AsRef<U>, U: 'i + StaticType> Node<'i, DAny<'i>> for UpcastAsRefNode<T, U> {
+	type Output = FutureAny<'i>;
+	#[inline(always)]
+	fn eval(&'i self, _: DAny<'i>) -> Self::Output {
+		Box::pin(async move { Box::new(self.0.as_ref()) as DAny<'i> })
+	}
+}
+
+impl<T: AsRef<U>, U> UpcastAsRefNode<T, U> {
+	pub const fn new(value: T) -> UpcastAsRefNode<T, U> {
+		UpcastAsRefNode(value, PhantomData)
+	}
+}
 
 #[derive(Debug, Clone, PartialEq, dyn_any::DynAny, Hash)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]

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

@@ -13,6 +13,7 @@ impl Compiler {
 		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();
@@ -40,3 +41,9 @@ pub type Any<'a> = Box<dyn DynAny<'a> + 'a>;
 pub trait Executor<I, O> {
 	fn execute(&self, input: I) -> LocalFuture<Result<O, Box<dyn Error>>>;
 }
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg(feature = "wgpu")]
+pub struct CompileRequest {
+	pub networks: Vec<ProtoNetwork>,
+	pub io: wgpu_executor::ShaderIO,
+}

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

@@ -10,3 +10,5 @@ pub mod proto;
 
 pub mod graphene_compiler;
 pub mod imaginate_input;
+
+pub mod wasm_application_io;

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

@@ -0,0 +1,228 @@
+use dyn_any::StaticType;
+#[cfg(target_arch = "wasm32")]
+use graphene_core::application_io::SurfaceHandleFrame;
+use graphene_core::application_io::{ApplicationError, ApplicationIo, ResourceFuture, SurfaceHandle, SurfaceId};
+#[cfg(feature = "wgpu")]
+use wgpu_executor::WgpuExecutor;
+
+use core::future::Future;
+#[cfg(target_arch = "wasm32")]
+use js_sys::{Object, Reflect};
+use std::collections::HashMap;
+use std::pin::Pin;
+#[cfg(target_arch = "wasm32")]
+use std::sync::atomic::AtomicU64;
+use std::sync::Arc;
+#[cfg(not(target_arch = "wasm32"))]
+use std::sync::Mutex;
+#[cfg(feature = "tokio")]
+use tokio::io::AsyncReadExt;
+#[cfg(target_arch = "wasm32")]
+use wasm_bindgen::JsCast;
+#[cfg(target_arch = "wasm32")]
+use wasm_bindgen::JsValue;
+#[cfg(target_arch = "wasm32")]
+use web_sys::window;
+#[cfg(target_arch = "wasm32")]
+use web_sys::HtmlCanvasElement;
+
+#[derive(Debug, Default)]
+pub struct WasmApplicationIo {
+	#[cfg(target_arch = "wasm32")]
+	ids: AtomicU64,
+	#[cfg(feature = "wgpu")]
+	pub(crate) gpu_executor: Option<WgpuExecutor>,
+	#[cfg(not(target_arch = "wasm32"))]
+	windows: Mutex<Vec<Arc<winit::window::Window>>>,
+	pub resources: HashMap<String, Arc<[u8]>>,
+}
+
+impl WasmApplicationIo {
+	pub async fn new() -> Self {
+		#[cfg(all(feature = "wgpu", target_arch = "wasm32"))]
+		let executor = if let Some(gpu) = web_sys::window().map(|w| w.navigator().gpu()) {
+			let request_adapter = || {
+				let request_adapter = js_sys::Reflect::get(&gpu, &wasm_bindgen::JsValue::from_str("requestAdapter")).ok()?;
+				let function = request_adapter.dyn_ref::<js_sys::Function>()?;
+				Some(function.call0(&gpu).ok())
+			};
+			let result = request_adapter();
+			match result {
+				None => None,
+				Some(_) => WgpuExecutor::new().await,
+			}
+		} else {
+			None
+		};
+		#[cfg(all(feature = "wgpu", not(target_arch = "wasm32")))]
+		let executor = WgpuExecutor::new().await;
+		let mut io = Self {
+			#[cfg(target_arch = "wasm32")]
+			ids: AtomicU64::new(0),
+			#[cfg(feature = "wgpu")]
+			gpu_executor: executor,
+			#[cfg(not(target_arch = "wasm32"))]
+			windows: Vec::new().into(),
+			resources: HashMap::new(),
+		};
+		io.resources.insert("null".to_string(), Arc::from(include_bytes!("null.png").to_vec()));
+		io
+	}
+}
+
+unsafe impl StaticType for WasmApplicationIo {
+	type Static = WasmApplicationIo;
+}
+
+impl<'a> From<&'a WasmEditorApi> for &'a WasmApplicationIo {
+	fn from(editor_api: &'a WasmEditorApi) -> Self {
+		editor_api.application_io.as_ref().unwrap()
+	}
+}
+#[cfg(feature = "wgpu")]
+impl<'a> From<&'a WasmApplicationIo> for &'a WgpuExecutor {
+	fn from(app_io: &'a WasmApplicationIo) -> Self {
+		app_io.gpu_executor.as_ref().unwrap()
+	}
+}
+
+pub type WasmEditorApi = graphene_core::application_io::EditorApi<WasmApplicationIo>;
+
+impl ApplicationIo for WasmApplicationIo {
+	#[cfg(target_arch = "wasm32")]
+	type Surface = HtmlCanvasElement;
+	#[cfg(not(target_arch = "wasm32"))]
+	type Surface = Arc<winit::window::Window>;
+	#[cfg(feature = "wgpu")]
+	type Executor = WgpuExecutor;
+	#[cfg(not(feature = "wgpu"))]
+	type Executor = ();
+
+	#[cfg(target_arch = "wasm32")]
+	fn create_surface(&self) -> SurfaceHandle<Self::Surface> {
+		let wrapper = || {
+			let document = window().expect("should have a window in this context").document().expect("window should have a document");
+
+			let canvas: HtmlCanvasElement = document.create_element("canvas")?.dyn_into::<HtmlCanvasElement>()?;
+			let id = self.ids.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
+			// store the canvas in the global scope so it doesn't get garbage collected
+			let window = window().expect("should have a window in this context");
+			let window = Object::from(window);
+
+			let image_canvases_key = JsValue::from_str("imageCanvases");
+
+			let mut canvases = Reflect::get(&window, &image_canvases_key);
+			if canvases.is_err() {
+				Reflect::set(&JsValue::from(web_sys::window().unwrap()), &image_canvases_key, &Object::new()).unwrap();
+				canvases = Reflect::get(&window, &image_canvases_key);
+			}
+
+			// Convert key and value to JsValue
+			let js_key = JsValue::from_str(format!("canvas{}", id).as_str());
+			let js_value = JsValue::from(canvas.clone());
+
+			let canvases = Object::from(canvases.unwrap());
+
+			// Use Reflect API to set property
+			Reflect::set(&canvases, &js_key, &js_value)?;
+			Ok::<_, JsValue>(SurfaceHandle {
+				surface_id: graphene_core::SurfaceId(id),
+				surface: canvas,
+			})
+		};
+
+		wrapper().expect("should be able to set canvas in global scope")
+	}
+	#[cfg(not(target_arch = "wasm32"))]
+	fn create_surface(&self) -> SurfaceHandle<Self::Surface> {
+		#[cfg(feature = "wayland")]
+		use winit::platform::wayland::EventLoopBuilderExtWayland;
+
+		#[cfg(feature = "wayland")]
+		let event_loop = winit::event_loop::EventLoopBuilder::new().with_any_thread(true).build().unwrap();
+		#[cfg(not(feature = "wayland"))]
+		let event_loop = winit::event_loop::EventLoop::new().unwrap();
+		let window = winit::window::WindowBuilder::new()
+			.with_title("Graphite")
+			.with_inner_size(winit::dpi::PhysicalSize::new(800, 600))
+			.build(&event_loop)
+			.unwrap();
+		let window = Arc::new(window);
+		self.windows.lock().as_mut().unwrap().push(window.clone());
+		SurfaceHandle {
+			surface_id: SurfaceId(window.id().into()),
+			surface: window,
+		}
+	}
+
+	#[cfg(target_arch = "wasm32")]
+	fn destroy_surface(&self, surface_id: SurfaceId) {
+		let window = window().expect("should have a window in this context");
+		let window = Object::from(window);
+
+		let image_canvases_key = JsValue::from_str("imageCanvases");
+
+		let wrapper = || {
+			if let Ok(canvases) = Reflect::get(&window, &image_canvases_key) {
+				// Convert key and value to JsValue
+				let js_key = JsValue::from_str(format!("canvas{}", surface_id.0).as_str());
+
+				// Use Reflect API to set property
+				Reflect::delete_property(&canvases.into(), &js_key)?;
+			}
+			Ok::<_, JsValue>(())
+		};
+
+		wrapper().expect("should be able to set canvas in global scope")
+	}
+
+	#[cfg(not(target_arch = "wasm32"))]
+	fn destroy_surface(&self, _surface_id: SurfaceId) {}
+
+	#[cfg(feature = "wgpu")]
+	fn gpu_executor(&self) -> Option<&Self::Executor> {
+		self.gpu_executor.as_ref()
+	}
+
+	fn load_resource(&self, url: impl AsRef<str>) -> Result<ResourceFuture, ApplicationError> {
+		let url = url::Url::parse(url.as_ref()).map_err(|_| ApplicationError::InvalidUrl)?;
+		log::trace!("Loading resource: {url:?}");
+		match url.scheme() {
+			#[cfg(feature = "tokio")]
+			"file" => {
+				let path = url.to_file_path().map_err(|_| ApplicationError::NotFound)?;
+				let path = path.to_str().ok_or(ApplicationError::NotFound)?;
+				let path = path.to_owned();
+				Ok(Box::pin(async move {
+					let file = tokio::fs::File::open(path).await.map_err(|_| ApplicationError::NotFound)?;
+					let mut reader = tokio::io::BufReader::new(file);
+					let mut data = Vec::new();
+					reader.read_to_end(&mut data).await.map_err(|_| ApplicationError::NotFound)?;
+					Ok(Arc::from(data))
+				}) as Pin<Box<dyn Future<Output = Result<Arc<[u8]>, _>>>>)
+			}
+			"http" | "https" => {
+				let url = url.to_string();
+				Ok(Box::pin(async move {
+					let client = reqwest::Client::new();
+					let response = client.get(url).send().await.map_err(|_| ApplicationError::NotFound)?;
+					let data = response.bytes().await.map_err(|_| ApplicationError::NotFound)?;
+					Ok(Arc::from(data.to_vec()))
+				}) as Pin<Box<dyn Future<Output = Result<Arc<[u8]>, _>>>>)
+			}
+			"graphite" => {
+				let path = url.path();
+				let path = path.to_owned();
+				log::trace!("Loading local resource: {path}");
+				let data = self.resources.get(&path).ok_or(ApplicationError::NotFound)?.clone();
+				Ok(Box::pin(async move { Ok(data.clone()) }) as Pin<Box<dyn Future<Output = Result<Arc<[u8]>, _>>>>)
+			}
+			_ => Err(ApplicationError::NotFound),
+		}
+	}
+}
+
+#[cfg(target_arch = "wasm32")]
+pub type WasmSurfaceHandle = SurfaceHandle<HtmlCanvasElement>;
+#[cfg(target_arch = "wasm32")]
+pub type WasmSurfaceHandleFrame = SurfaceHandleFrame<HtmlCanvasElement>;