Unify feature dependencies with workspace dependencies (#2736)

* graph-craft: fix direct wasm build

* graph-craft: fix no serde feature failing to compile

* graph-craft: make wgpu-executor properly optional

* workspace: unify `image` formats in workspace

* workspace: turn most dependencies into workspace deps, no actual changes

* workspace: unify dependency features in workspace dep

node-graph/gcore/Cargo.toml

@@ -24,50 +24,42 @@ serde = [
 ]
 
 [dependencies]
+# Local dependencies
+math-parser = { workspace = true }
+
 # Workspace dependencies
-bytemuck = { workspace = true, features = ["derive"] }
+bytemuck = { workspace = true }
 node-macro = { workspace = true }
 num-derive = { workspace = true }
-num-traits = { workspace = true, default-features = false, features = ["i128"] }
+num-traits = { workspace = true }
 usvg = { workspace = true }
-rand = { workspace = true, default-features = false, features = ["std_rng"] }
-glam = { workspace = true, default-features = false, features = [
-	"scalar-math",
-] }
+rand = { workspace = true }
+glam = { workspace = true }
 serde_json = { workspace = true }
-petgraph = { workspace = true, default-features = false, features = [
-	"graphmap",
-] }
+petgraph = { workspace = true }
 rustc-hash = { workspace = true }
-math-parser = { path = "../../libraries/math-parser" }
 dyn-any = { workspace = true }
 ctor = { workspace = true }
 rand_chacha = { workspace = true }
 bezier-rs = { workspace = true }
 specta = { workspace = true }
 rustybuzz = { workspace = true }
-image = { workspace = true, default-features = false, features = [
-	"png",
-] }
-
-# Required dependencies
-half = { version = "2.4.1", default-features = false, features = ["bytemuck"] }
-tinyvec = { version = "1" }
+image = { workspace = true }
+half = { workspace = true }
+tinyvec = { workspace = true }
 kurbo = { workspace = true }
 log = { workspace = true }
 
 # Optional workspace dependencies
-serde = { workspace = true, optional = true, features = ["derive"] }
+serde = { workspace = true, optional = true }
 base64 = { workspace = true, optional = true }
 vello = { workspace = true, optional = true }
 wgpu = { workspace = true, optional = true }
-web-sys = { workspace = true, optional = true, features = [
-	"HtmlCanvasElement",
-] }
+web-sys = { workspace = true, optional = true }
 
 [dev-dependencies]
 # Workspace dependencies
-tokio = { workspace = true, features = ["rt", "macros"] }
+tokio = { workspace = true }
 serde_json = { workspace = true }
 
 [lints.rust]

node-graph/graph-craft/Cargo.toml

@@ -8,21 +8,17 @@ 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"]
 
 [dependencies]
 # Local dependencies
-dyn-any = { path = "../../libraries/dyn-any", features = [
-	"log-bad-types",
-	"rc",
-	"glam",
-] }
+dyn-any = { workspace = true }
+graphene-core = { workspace = true }
 
 # Workspace dependencies
-graphene-core = { workspace = true }
 log = { workspace = true }
 glam = { workspace = true }
 bezier-rs = { workspace = true }
@@ -30,16 +26,19 @@ specta = { workspace = true }
 rustc-hash = { workspace = true }
 url = { workspace = true }
 reqwest = { workspace = true }
-wgpu-executor = { workspace = true }
 
 # Optional workspace dependencies
+wgpu-executor = { workspace = true, optional = true }
 serde = { workspace = true, optional = true }
 tokio = { workspace = true, optional = true }
 serde_json = { workspace = true, optional = true }
 
 # Workspace dependencies
 [target.'cfg(target_arch = "wasm32")'.dependencies]
-web-sys = { workspace = true }
+web-sys = { workspace = true, features = [
+	"Navigator",
+	"Gpu",
+] }
 js-sys = { workspace = true }
 wasm-bindgen = { workspace = true }
 
@@ -50,10 +49,8 @@ winit = { workspace = true }
 # Workspace dependencies
 graph-craft = { workspace = true, features = ["loading"] }
 pretty_assertions = { workspace = true }
-
-# Required dependencies
-criterion = { version = "0.5", features = ["html_reports"] }
-iai-callgrind = { version = "0.12.3" }
+criterion = { workspace = true }
+iai-callgrind = { workspace = true }
 
 # Benchmarks
 [[bench]]

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

@@ -676,10 +676,12 @@ fn migrate_layer_to_merge<'de, D: serde::Deserializer<'de>>(deserializer: D) ->
 	Ok(s)
 }
 // TODO: Eventually remove this document upgrade code
+#[cfg(feature = "serde")]
 fn default_import_metadata() -> (NodeId, IVec2) {
 	(NodeId::new(), IVec2::new(-25, -4))
 }
 // TODO: Eventually remove this document upgrade code
+#[cfg(feature = "serde")]
 fn default_export_metadata() -> (NodeId, IVec2) {
 	(NodeId::new(), IVec2::new(8, -4))
 }

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

@@ -532,7 +532,8 @@ impl ProtoNetwork {
 		Ok(())
 	}
 }
-#[derive(Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum GraphErrorType {
 	NodeNotFound(NodeId),
 	InputNodeNotFound(NodeId),
@@ -588,7 +589,8 @@ impl Debug for GraphErrorType {
 		}
 	}
 }
-#[derive(Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct GraphError {
 	pub node_path: Vec<NodeId>,
 	pub identifier: Cow<'static, str>,

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

@@ -1,5 +1,4 @@
 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};
@@ -7,6 +6,7 @@ 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/graphene-cli/Cargo.toml

@@ -20,18 +20,18 @@ gpu = [
 
 [dependencies]
 # Local dependencies
-graphene-std = { path = "../gstd", features = ["serde"] }
-interpreted-executor = { path = "../interpreted-executor" }
+graphene-core = { workspace = true }
+graphene-std = { workspace = true, features = ["serde"] }
+interpreted-executor = { workspace = true }
+graph-craft = { workspace = true, features = ["loading"] }
 
 # Workspace dependencies
 log = { workspace = true }
-graph-craft = { workspace = true, features = ["loading"] }
-graphene-core = { workspace = true }
 futures = { workspace = true }
 fern = { workspace = true }
 chrono = { workspace = true }
 wgpu = { workspace = true }
-tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
+tokio = { workspace = true, features = ["rt-multi-thread"] }
 
 # Required dependencies
 clap = { version = "4.5.31", features = ["cargo", "derive"] }

node-graph/gstd/Cargo.toml

@@ -19,39 +19,33 @@ wayland = ["graph-craft/wayland"]
 
 [dependencies]
 # Local dependencies
-dyn-any = { path = "../../libraries/dyn-any", features = ["derive", "reqwest"] }
-graph-craft = { path = "../graph-craft", features = ["serde"] }
-wgpu-executor = { path = "../wgpu-executor" }
-graphene-core = { path = "../gcore", default-features = false, features = ["serde"] }
+dyn-any = { workspace = true }
+graph-craft = { workspace = true, features = ["serde"] }
+wgpu-executor = { workspace = true }
+graphene-core = { workspace = true, features = ["serde"] }
 
 # Workspace dependencies
 fastnoise-lite = { workspace = true }
 log = { workspace = true }
-bezier-rs = { workspace = true, features = ["serde"] }
-path-bool = { workspace = true, features = ["parsing"] }
-glam = { workspace = true, features = ["serde"] }
+bezier-rs = { workspace = true }
+path-bool = { workspace = true }
+glam = { workspace = true }
 node-macro = { workspace = true }
 reqwest = { workspace = true }
 futures = { workspace = true }
 usvg = { workspace = true }
 rand_chacha = { workspace = true }
-rand = { workspace = true, default-features = false, features = [
-	"alloc",
-	"small_rng",
-] }
+rand = { workspace = true }
 bytemuck = { workspace = true }
-image = { workspace = true, default-features = false, features = [
-	"png",
-	"jpeg",
-] }
+image = { workspace = true }
 
 # Optional workspace dependencies
 base64 = { workspace = true, optional = true }
 wasm-bindgen = { workspace = true, optional = true }
 wasm-bindgen-futures = { workspace = true, optional = true }
-tokio = { workspace = true, optional = true, features = ["fs", "io-std"] }
+tokio = { workspace = true, optional = true }
 vello = { workspace = true, optional = true }
-serde = { workspace = true, optional = true, features = ["derive"] }
+serde = { workspace = true, optional = true }
 web-sys = { workspace = true, optional = true, features = [
 	"Window",
 	"CanvasRenderingContext2d",
@@ -68,4 +62,4 @@ web-sys = { workspace = true, optional = true, features = [
 ndarray = "0.16.1"
 
 [dev-dependencies]
-tokio = { workspace = true, features = ["macros"] }
+tokio = { workspace = true }

node-graph/gstd/src/wasm_application_io.rs

@@ -27,6 +27,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/Cargo.toml

@@ -11,13 +11,13 @@ gpu = ["graphene-std/gpu", "graphene-std/wgpu"]
 
 [dependencies]
 # Local dependencies
-graphene-std = { path = "../gstd", features = ["serde"] }
-graph-craft = { path = "../graph-craft" }
-wgpu-executor = { path = "../wgpu-executor" }
+graphene-std = { workspace = true, features = ["serde"] }
+graph-craft = { workspace = true }
+wgpu-executor = { workspace = true }
+graphene-core = { workspace = true }
+dyn-any = { workspace = true }
 
 # Workspace dependencies
-graphene-core = { workspace = true }
-dyn-any = { workspace = true, features = ["log-bad-types", "glam"] }
 log = { workspace = true }
 glam = { workspace = true }
 futures = { workspace = true }
@@ -29,9 +29,7 @@ serde = { workspace = true, optional = true }
 [dev-dependencies]
 # Workspace dependencies
 graph-craft = { workspace = true, features = ["loading"] }
-
-# Required dependencies
-criterion = { version = "0.5", features = ["html_reports"]}
+criterion = { workspace = true }
 
 # Benchmarks
 [[bench]]

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

@@ -75,6 +75,7 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 		async_node!(graphene_core::memo::MemoNode<_, _>, input: Context, fn_params: [Context => RasterDataTable<CPU>]),
 		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<WgpuSurface>]),

node-graph/node-macro/Cargo.toml

@@ -15,8 +15,8 @@ proc-macro = true
 
 [dependencies]
 # Workspace dependencies
-syn = { workspace = true, features = [ "extra-traits", "full", "printing", "parsing", "clone-impls", "proc-macro", "visit-mut", "visit"] }
-proc-macro2 = { workspace = true, features = [ "span-locations" ] }
+syn = { workspace = true }
+proc-macro2 = { workspace = true }
 quote = { workspace = true }
 convert_case = { workspace = true }
 

node-graph/wgpu-executor/Cargo.toml

@@ -10,17 +10,16 @@ profiling = []
 passthrough = []
 
 [dependencies]
-# Workspace dependencies
+# Local dependencies
 graphene-core = { workspace = true, features = ["wgpu"] }
-dyn-any = { workspace = true, features = ["log-bad-types", "rc", "glam"] }
+dyn-any = { workspace = true }
 node-macro = { workspace = true }
+
+# Workspace dependencies
 glam = { workspace = true }
 anyhow = { workspace = true }
-wgpu = { workspace = true, features = [
-	"spirv",
-	"strict_asserts",
-] }
+wgpu = { workspace = true }
 futures = { workspace = true }
-web-sys = { workspace = true, features = ["HtmlCanvasElement"] }
+web-sys = { workspace = true }
 winit = { workspace = true }
 vello = { workspace = true }