graph-craft: make wgpu-executor properly optional

Author: Firestar99

node-graph/graph-craft/Cargo.toml

@@ -8,7 +8,7 @@ license = "MIT OR Apache-2.0"
 default = ["dealloc_nodes"]
 serde = ["dep:serde", "graphene-core/serde", "glam/serde", "bezier-rs/serde"]
 dealloc_nodes = ["graphene-core/dealloc_nodes"]
-wgpu = []
+wgpu = ["wgpu-executor"]
 tokio = ["dep:tokio"]
 wayland = []
 loading = ["serde_json", "serde"]
@@ -30,7 +30,7 @@ specta = { workspace = true }
 rustc-hash = { workspace = true }
 url = { workspace = true }
 reqwest = { workspace = true }
-wgpu-executor = { workspace = true }
+wgpu-executor = { workspace = true, optional = true }
 
 # Optional workspace dependencies
 serde = { workspace = true, optional = true }

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

@@ -1,12 +1,12 @@
 use dyn_any::StaticType;
-use graphene_core::application_io::SurfaceHandleFrame;
 use graphene_core::application_io::{ApplicationError, ApplicationIo, ResourceFuture, SurfaceHandle, SurfaceId};
 #[cfg(target_arch = "wasm32")]
 use js_sys::{Object, Reflect};
 use std::collections::HashMap;
 use std::sync::Arc;
 #[cfg(target_arch = "wasm32")]
 use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering;
 #[cfg(feature = "tokio")]
 use tokio::io::AsyncReadExt;
 #[cfg(target_arch = "wasm32")]
@@ -17,6 +17,7 @@ use wasm_bindgen::JsValue;
 use web_sys::HtmlCanvasElement;
 #[cfg(target_arch = "wasm32")]
 use web_sys::window;
+#[cfg(feature = "wgpu")]
 use wgpu_executor::WgpuExecutor;
 
 #[derive(Debug)]
@@ -76,7 +77,7 @@ pub fn wgpu_available() -> Option<bool> {
 		}
 	}
 
-	match WGPU_AVAILABLE.load(::std::sync::atomic::Ordering::SeqCst) {
+	match WGPU_AVAILABLE.load(Ordering::SeqCst) {
 		-1 => None,
 		0 => Some(false),
 		_ => Some(true),
@@ -85,7 +86,7 @@ pub fn wgpu_available() -> Option<bool> {
 
 impl WasmApplicationIo {
 	pub async fn new() -> Self {
-		#[cfg(target_arch = "wasm32")]
+		#[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()?;
@@ -101,9 +102,14 @@ impl WasmApplicationIo {
 			None
 		};
 
-		#[cfg(not(target_arch = "wasm32"))]
+		#[cfg(all(feature = "wgpu", not(target_arch = "wasm32")))]
 		let executor = WgpuExecutor::new().await;
-		WGPU_AVAILABLE.store(executor.is_some() as i8, ::std::sync::atomic::Ordering::SeqCst);
+
+		#[cfg(not(feature = "wgpu"))]
+		let wgpu_available = false;
+		#[cfg(feature = "wgpu")]
+		let wgpu_available = executor.is_some();
+		WGPU_AVAILABLE.store(wgpu_available as i8, Ordering::SeqCst);
 
 		let mut io = Self {
 			#[cfg(target_arch = "wasm32")]
@@ -121,9 +127,14 @@ impl WasmApplicationIo {
 	}
 
 	pub async fn new_offscreen() -> Self {
+		#[cfg(feature = "wgpu")]
 		let executor = WgpuExecutor::new().await;
 
-		WGPU_AVAILABLE.store(executor.is_some() as i8, ::std::sync::atomic::Ordering::SeqCst);
+		#[cfg(not(feature = "wgpu"))]
+		let wgpu_available = false;
+		#[cfg(feature = "wgpu")]
+		let wgpu_available = executor.is_some();
+		WGPU_AVAILABLE.store(wgpu_available as i8, Ordering::SeqCst);
 
 		// Always enable wgpu when running with Tauri
 		let mut io = Self {
@@ -175,7 +186,7 @@ impl ApplicationIo for WasmApplicationIo {
 			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);
+			let id = self.ids.fetch_add(1, 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);
@@ -299,8 +310,10 @@ impl ApplicationIo for WasmApplicationIo {
 	}
 }
 
+#[cfg(feature = "wgpu")]
 pub type WasmSurfaceHandle = SurfaceHandle<wgpu_executor::Window>;
-pub type WasmSurfaceHandleFrame = SurfaceHandleFrame<wgpu_executor::Window>;
+#[cfg(feature = "wgpu")]
+pub type WasmSurfaceHandleFrame = graphene_core::application_io::SurfaceHandleFrame<wgpu_executor::Window>;
 
 #[derive(Clone, Debug, PartialEq, Hash, specta::Type)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -330,6 +343,6 @@ impl Default for EditorPreferences {
 	}
 }
 
-unsafe impl dyn_any::StaticType for EditorPreferences {
+unsafe impl StaticType for EditorPreferences {
 	type Static = EditorPreferences;
 }

node-graph/gstd/src/wasm_application_io.rs

@@ -26,6 +26,7 @@ use wasm_bindgen::JsCast;
 #[cfg(target_arch = "wasm32")]
 use web_sys::{CanvasRenderingContext2d, HtmlCanvasElement};
 
+#[cfg(feature = "wgpu")]
 #[node_macro::node(category("Debug: GPU"))]
 async fn create_surface<'a: 'n>(_: impl Ctx, editor: &'a WasmEditorApi) -> Arc<WasmSurfaceHandle> {
 	Arc::new(editor.application_io.as_ref().unwrap().create_window())

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

@@ -73,6 +73,7 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 		async_node!(graphene_core::memo::MemoNode<_, _>, input: Context, fn_params: [Context => RasterDataTable<Color>]),
 		async_node!(graphene_core::memo::MemoNode<_, _>, input: Context, fn_params: [Context => GraphicGroupTable]),
 		async_node!(graphene_core::memo::MemoNode<_, _>, input: Context, fn_params: [Context => Vec<DVec2>]),
+		#[cfg(feature = "gpu")]
 		async_node!(graphene_core::memo::MemoNode<_, _>, input: Context, fn_params: [Context => Arc<WasmSurfaceHandle>]),
 		async_node!(graphene_core::memo::MemoNode<_, _>, input: Context, fn_params: [Context => WindowHandle]),
 		async_node!(graphene_core::memo::MemoNode<_, _>, input: Context, fn_params: [Context => Option<wgpu_executor::WgpuSurface>]),