WIP

Author: timon-schelling

editor/src/node_graph_executor/runtime.rs

@@ -345,13 +345,13 @@ impl NodeRuntime {
 		None
 	}
 
-	async fn update_network(&mut self, mut graph: NodeNetwork) -> Result<ResolvedDocumentNodeTypesDelta, (ResolvedDocumentNodeTypesDelta, String)> {
-		if let Err(e) = self.preprocessor.expand_network(&mut graph, &self.resources) {
+	async fn update_network(&mut self, graph: NodeNetwork) -> Result<ResolvedDocumentNodeTypesDelta, (ResolvedDocumentNodeTypesDelta, String)> {
+		let mut scoped_network = wrap_network_in_scope(graph, self.editor_api.clone());
+
+		if let Err(e) = self.preprocessor.expand_network(&mut scoped_network, &self.resources) {
 			return Err((ResolvedDocumentNodeTypesDelta::default(), e.to_string()));
 		}
 
-		let scoped_network = wrap_network_in_scope(graph, self.editor_api.clone());
-
 		// We assume only one output
 		assert_eq!(scoped_network.exports.len(), 1, "Graph with multiple outputs not yet handled");
 

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

@@ -785,15 +785,21 @@ impl NodeNetwork {
 	}
 
 	pub fn resolve_scope_inputs(&mut self) {
+		let mut import_ids = Vec::new();
 		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");
+
+					import_ids.push(*import_id);
 					// TODO use correct output index
 					*input = NodeInput::node(*import_id, 0);
 				}
 			}
 		}
+		if !import_ids.iter().all(|id| self.nodes.contains_key(id)) {
+			log::error!("Scope injections refer to non existent node ids {import_ids:?}");
+		}
 	}
 
 	/// Remove all nodes that contain [`DocumentNodeImplementation::Network`] by moving the nested nodes into the parent network.

node-graph/graphene-cli/src/main.rs

@@ -242,10 +242,9 @@ fn compile_graph(document_string: String, editor_api: Arc<PlatformEditorApi>) ->
 	let mut network = load_network(&document_string);
 	fix_nodes(&mut network);
 
+	let mut wrapped_network = wrap_network_in_scope(network, editor_api);
 	let preprocessor = preprocessor::Preprocessor::new();
-	preprocessor.expand_network(&mut network, &ResourceRegistry::default()).expect("Failed to expand network"); // TODO: actually load the resources from the document
-
-	let wrapped_network = wrap_network_in_scope(network.clone(), editor_api);
+	preprocessor.expand_network(&mut wrapped_network, &ResourceRegistry::default()).expect("Failed to expand network"); // TODO: actually load the resources from the document
 
 	let compiler = Compiler {};
 	compiler.compile_single(wrapped_network).map_err(|x| x.into())

node-graph/interpreted-executor/benches/benchmark_util.rs

@@ -9,11 +9,11 @@ use interpreted_executor::dynamic_executor::DynamicExecutor;
 use interpreted_executor::util::wrap_network_in_scope;
 
 pub fn setup_network(name: &str) -> (DynamicExecutor, ProtoNetwork) {
-	let mut network = load_from_name(name);
+	let network = load_from_name(name);
 	let editor_api = std::sync::Arc::new(EditorApi::default());
+	let mut network = wrap_network_in_scope(network, editor_api);
 	let preprocessor = preprocessor::Preprocessor::new();
 	preprocessor.expand_network(&mut network, &ResourceRegistry::default()).unwrap();
-	let network = wrap_network_in_scope(network, editor_api);
 	let proto_network = compile(network);
 	let executor = block_on(DynamicExecutor::new(proto_network.clone())).unwrap();
 	(executor, proto_network)

node-graph/interpreted-executor/src/node_registry.rs

@@ -202,7 +202,7 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 		async_node!(graphene_core::context_modification::ContextModificationNode<_, _>, input: Context, fn_params: [Context => CanvasHandle, Context => graphene_std::ContextFeatures]),
 		async_node!(graphene_core::context_modification::ContextModificationNode<_, _>, input: Context, fn_params: [Context => wgpu_executor::WgpuPipelineCache<graphene_std::render_pixel_preview::PixelPreview>, Context => graphene_std::ContextFeatures]),
 		async_node!(graphene_core::context_modification::ContextModificationNode<_, _>, input: Context, fn_params: [Context => wgpu_executor::WgpuPipelineCache<graphene_std::render_background::BackgroundCompositor>, Context => graphene_std::ContextFeatures]),
-		async_node!(graphene_core::context_modification::ContextModificationNode<_, _>, input: Context, fn_params: [Context => wgpu_executor::WgpuExecutor, Context => graphene_std::ContextFeatures]),
+		async_node!(graphene_core::context_modification::ContextModificationNode<_, _>, input: Context, fn_params: [Context => &wgpu_executor::WgpuExecutor, Context => graphene_std::ContextFeatures]),
 		// ==========
 		// MEMO NODES
 		// ==========
@@ -290,7 +290,7 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 		async_node!(graphene_core::memo::MemoizeNode<_, _>, input: Context, fn_params: [Context => RenderIntermediate]),
 		async_node!(graphene_core::memo::MemoizeNode<_, _>, input: Context, fn_params: [Context => wgpu_executor::WgpuPipelineCache<graphene_std::render_pixel_preview::PixelPreview>]),
 		async_node!(graphene_core::memo::MemoizeNode<_, _>, input: Context, fn_params: [Context => wgpu_executor::WgpuPipelineCache<graphene_std::render_background::BackgroundCompositor>]),
-		async_node!(graphene_core::memo::MemoizeNode<_, _>, input: Context, fn_params: [Context => wgpu_executor::WgpuExecutor]),
+		async_node!(graphene_core::memo::MemoizeNode<_, _>, input: Context, fn_params: [Context => &wgpu_executor::WgpuExecutor]),
 	];
 	// =============
 	// CONVERT NODES

node-graph/nodes/gstd/src/platform_application_io.rs

@@ -270,6 +270,6 @@ pub async fn resource<'a: 'n>(_: impl Ctx, hash: ResourceHash, #[scope("editor-a
 }
 
 #[node_macro::node(category(""), inject_scope)]
-pub async fn wgpu_executor<'a: 'n>(_: impl Ctx, #[scope("editor-api")] editor_api: &'a PlatformEditorApi) -> ::wgpu_executor::WgpuExecutor {
-	editor_api.application_io.as_ref().unwrap().gpu_executor().expect("GPU executor not available").clone()
+pub async fn wgpu_executor<'a: 'n>(_: impl Ctx, #[scope("editor-api")] editor_api: &'a PlatformEditorApi) -> &'a ::wgpu_executor::WgpuExecutor {
+	editor_api.application_io.as_ref().unwrap().gpu_executor().expect("GPU executor not available")
 }

node-graph/nodes/gstd/src/render_background.rs

@@ -118,9 +118,9 @@ async fn render_background<'a: 'n>(
 }
 
 #[node_macro::node(category(""), inject_scope)]
-async fn background_compositor_pipeline(
+async fn background_compositor_pipeline<'a: 'n>(
 	_ctx: impl Ctx,
-	#[scope(crate::platform_application_io::wgpu_executor::IDENTIFIER)] executor: WgpuExecutor,
+	#[scope(crate::platform_application_io::wgpu_executor::IDENTIFIER)] executor: &'a WgpuExecutor,
 	#[data] pipeline: WgpuPipelineCache<BackgroundCompositor>,
 ) -> WgpuPipelineCache<BackgroundCompositor> {
 	executor.pipeline_init(pipeline);

node-graph/nodes/gstd/src/render_cache.rs

@@ -326,7 +326,7 @@ fn flood_fill(start: &TileCoord, tile_set: &HashSet<TileCoord>, visited: &mut Ha
 #[node_macro::node(category(""))]
 pub async fn render_output_cache<'a: 'n>(
 	ctx: impl Ctx + ExtractAll + CloneVarArgs + ExtractRealTime + ExtractAnimationTime + ExtractPointerPosition + Sync,
-	#[scope(crate::platform_application_io::wgpu_executor::IDENTIFIER)] executor: WgpuExecutor,
+	#[scope(crate::platform_application_io::wgpu_executor::IDENTIFIER)] executor: &'a WgpuExecutor,
 	#[scope("editor-api")] editor_api: &'a PlatformEditorApi,
 	data: impl Node<Context<'static>, Output = RenderOutput> + Send + Sync,
 	#[data] tile_cache: TileCache,

node-graph/nodes/gstd/src/render_node.rs

@@ -75,7 +75,7 @@ async fn render_intermediate<'a: 'n, T: 'static + Render + WasmNotSend + Send +
 #[node_macro::node(category(""))]
 async fn render<'a: 'n>(
 	ctx: impl Ctx + ExtractFootprint + ExtractVarArgs,
-	#[scope(crate::platform_application_io::wgpu_executor::IDENTIFIER)] executor: WgpuExecutor,
+	#[scope(crate::platform_application_io::wgpu_executor::IDENTIFIER)] executor: &'a WgpuExecutor,
 	data: RenderIntermediate,
 ) -> RenderOutput {
 	let footprint = ctx.footprint();

node-graph/nodes/gstd/src/render_pixel_preview.rs

@@ -75,9 +75,9 @@ pub async fn render_pixel_preview<'a: 'n>(
 }
 
 #[node_macro::node(category(""), inject_scope)]
-async fn pixel_preview_pipeline(
+async fn pixel_preview_pipeline<'a: 'n>(
 	_ctx: impl Ctx,
-	#[scope(crate::platform_application_io::wgpu_executor::IDENTIFIER)] executor: WgpuExecutor,
+	#[scope(crate::platform_application_io::wgpu_executor::IDENTIFIER)] executor: &'a WgpuExecutor,
 	#[data] pipeline: WgpuPipelineCache<PixelPreview>,
 ) -> WgpuPipelineCache<PixelPreview> {
 	executor.pipeline_init(pipeline);