Cut over to the graphene execution model

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

@@ -7,13 +7,13 @@ use document_format::{GddV1, GddV1Layout};
 use fern::colors::{Color, ColoredLevelConfig};
 use futures::executor::block_on;
 use graph_craft::application_io::EditorPreferences;
-use graph_craft::application_io::resource::ResourceRegistry;
 use graph_craft::application_io::{PlatformApplicationIo, PlatformEditorApi};
 use graph_craft::document::*;
 use graph_craft::graphene_compiler::Compiler;
 use graph_craft::proto::ProtoNetwork;
 use graph_craft::util::load_network;
 use graphene_std::application_io::{ApplicationIo, NodeGraphUpdateMessage, NodeGraphUpdateSender};
+use graphene_std::runtime::{DynGraphRuntime, DynSpawner, GraphRuntime, NoopSpawner, RuntimeHandle};
 use interpreted_executor::dynamic_executor::DynamicExecutor;
 use interpreted_executor::util::wrap_network_in_scope;
 use std::error::Error;
@@ -101,8 +101,7 @@ struct GlobalOpts {
 	verbose: u8,
 }
 
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn Error>> {
+fn main() -> Result<(), Box<dyn Error>> {
 	let app = App::parse();
 
 	let log_level = app.global_opts.verbose;
@@ -130,9 +129,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
 	let gdd = if is_gdd {
 		let archive = std::fs::read(document_path).map_err(|error| format!("Failed to read document {}: {error}", document_path.display()))?;
 		let container = AnyContainer::Memory(MemoryBackend::new());
-		let gdd = document_format::Gdd::open_from_archive(archive.as_ref(), container, GddV1Layout)
-			.await
-			.map_err(|error| format!("Failed to open document: {error}"))?;
+		let gdd = block_on(document_format::Gdd::open_from_archive(archive.as_ref(), container, GddV1Layout)).map_err(|error| format!("Failed to open document: {error}"))?;
 		Some(gdd)
 	} else {
 		None
@@ -140,7 +137,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
 
 	if let Command::ExtractLegacyDoc { ref document } = app.command {
 		let Some(gdd) = &gdd else { return Err("ExtractLegacyDoc requires a .gdd document".into()) };
-		let Some(legacy_doc) = gdd.read_legacy_document().await else {
+		let Some(legacy_doc) = block_on(gdd.read_legacy_document()) else {
 			return Err("gdd file did not contain a legacy .graphite document".into());
 		};
 		let mut new_path = document.clone();
@@ -153,7 +150,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
 	// Build the runtime network: from the `.gdd` registry, or by loading a legacy `.graphite` document.
 	let node_network = match &gdd {
 		Some(gdd) => {
-			let declarations = gdd.declarations(gdd).await;
+			let declarations = block_on(gdd.declarations(gdd));
 			let (node_network, _metadata) = gdd.registry().to_runtime_with_metadata(&declarations)?;
 			node_network
 		}
@@ -164,7 +161,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
 	};
 
 	log::info!("Creating GPU context");
-	let mut application_io = PlatformApplicationIo::new().await;
+	let mut application_io = block_on(PlatformApplicationIo::new());
 	if let Some(gdd) = &gdd {
 		application_io.inject_resource_proxy(Box::new(gdd.resource_proxy()));
 	}
@@ -176,16 +173,18 @@ async fn main() -> Result<(), Box<dyn Error>> {
 	let application_io_for_api = application_io_arc.clone();
 
 	// Get reference to wgpu executor and clone device handle
-	let wgpu_executor_ref = application_io_arc.gpu_executor().unwrap();
+	let wgpu_executor_ref = wgpu_executor::WgpuExecutorHandle(application_io_arc.gpu_executor_arc().unwrap());
 	let device = wgpu_executor_ref.context().device.clone();
 
 	let preferences = EditorPreferences {
 		max_render_region_size: EditorPreferences::default().max_render_region_size,
 	};
+	let graph_runtime: Arc<DynGraphRuntime> = Arc::new(GraphRuntime::new(Box::new(NoopSpawner) as Box<DynSpawner>));
 	let editor_api = Arc::new(PlatformEditorApi {
 		application_io: Some(application_io_for_api),
 		node_graph_message_sender: Box::new(UpdateLogger {}),
 		editor_preferences: Box::new(preferences),
+		runtime: RuntimeHandle(graph_runtime.clone()),
 	});
 	let proto_graph = compile_graph(node_network, editor_api, gdd.as_ref())?;
 
@@ -218,7 +217,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
 			let file_type = export::detect_file_type(&output)?;
 
 			// Create executor
-			let executor = create_executor(proto_graph)?;
+			let executor = create_executor(proto_graph, graph_runtime)?;
 
 			if fps <= 0. {
 				return Err("Fps number must be positive".into());
@@ -227,9 +226,9 @@ async fn main() -> Result<(), Box<dyn Error>> {
 			// Perform export based on file type
 			if file_type == export::FileType::Gif {
 				let animation = export::AnimationParams::new(fps, frames, duration);
-				export::export_gif(&executor, wgpu_executor_ref, output, scale, (width, height), animation).await?;
+				export::export_gif(&executor, wgpu_executor_ref.clone(), output, scale, (width, height), animation)?;
 			} else {
-				export::export_document(&executor, wgpu_executor_ref, output, file_type, scale, (width, height), transparent).await?;
+				export::export_document(&executor, wgpu_executor_ref.clone(), output, file_type, scale, (width, height), transparent)?;
 			}
 		}
 		_ => unreachable!("All other commands should be handled before this match statement is run"),
@@ -285,7 +284,8 @@ fn compile_graph(network: NodeNetwork, editor_api: Arc<PlatformEditorApi>, gdd:
 	compiler.compile_single(network).map_err(|x| x.into())
 }
 
-fn create_executor(proto_network: ProtoNetwork) -> Result<DynamicExecutor, Box<dyn Error>> {
-	let executor = block_on(DynamicExecutor::new(proto_network)).map_err(|errors| errors.iter().map(|e| format!("{e:?}")).reduce(|acc, e| format!("{acc}\n{e}")).unwrap_or_default())?;
+fn create_executor(proto_network: ProtoNetwork, runtime: Arc<DynGraphRuntime>) -> Result<DynamicExecutor, Box<dyn Error>> {
+	let mut executor = DynamicExecutor::new(proto_network).map_err(|errors| errors.iter().map(|e| format!("{e:?}")).reduce(|acc, e| format!("{acc}\n{e}")).unwrap_or_default())?;
+	executor.set_runtime(runtime);
 	Ok(executor)
 }