node-macro: add CrateIdent struct containing resolved crate paths

Author: Firestar99

Cargo.lock

@@ -35,6 +35,7 @@ glam = { workspace = true }
 half = { workspace = true, default-features = false }
 num-derive = { workspace = true }
 num-traits = { workspace = true }
+spirv-std = { workspace = true }
 
 # Workspace std dependencies
 serde = { workspace = true, optional = true }

node-graph/gcore-shaders/Cargo.toml

@@ -5,6 +5,7 @@ pub mod choice_type;
 pub mod color;
 pub mod context;
 pub mod registry;
+pub mod shaders;
 
 pub use context::Ctx;
 pub use glam;

node-graph/gcore-shaders/src/lib.rs

@@ -0,0 +1,5 @@
+pub mod __private {
+	pub use bytemuck;
+	pub use glam;
+	pub use spirv_std;
+}

node-graph/gcore-shaders/src/shaders/mod.rs

@@ -1,6 +1,5 @@
 use crate::parsing::*;
 use convert_case::{Case, Casing};
-use proc_macro_crate::FoundCrate;
 use proc_macro2::TokenStream as TokenStream2;
 use quote::{ToTokens, format_ident, quote, quote_spanned};
 use std::sync::atomic::AtomicU64;
@@ -10,7 +9,7 @@ use syn::token::Comma;
 use syn::{Error, Ident, PatIdent, Token, WhereClause, WherePredicate, parse_quote};
 static NODE_ID: AtomicU64 = AtomicU64::new(0);
 
-pub(crate) fn generate_node_code(parsed: &ParsedNodeFn) -> syn::Result<TokenStream2> {
+pub(crate) fn generate_node_code(crate_ident: &CrateIdent, parsed: &ParsedNodeFn) -> syn::Result<TokenStream2> {
 	let ParsedNodeFn {
 		vis,
 		attributes,
@@ -24,10 +23,10 @@ pub(crate) fn generate_node_code(parsed: &ParsedNodeFn) -> syn::Result<TokenStre
 		is_async,
 		fields,
 		body,
-		crate_name: graphene_core_crate,
 		description,
 		..
 	} = parsed;
+	let graphene_core = crate_ident.gcore()?;
 
 	let category = &attributes.category.as_ref().map(|value| quote!(Some(#value))).unwrap_or(quote!(None));
 	let mod_name = format_ident!("_{}_mod", mod_name);
@@ -60,14 +59,6 @@ pub(crate) fn generate_node_code(parsed: &ParsedNodeFn) -> syn::Result<TokenStre
 		quote! { pub(super) #name: #r#gen }
 	});
 
-	let graphene_core = match graphene_core_crate {
-		FoundCrate::Itself => quote!(crate),
-		FoundCrate::Name(name) => {
-			let ident = Ident::new(name, proc_macro2::Span::call_site());
-			quote!( #ident )
-		}
-	};
-
 	let mut future_idents = Vec::new();
 
 	let field_types: Vec<_> = fields
@@ -295,7 +286,7 @@ pub(crate) fn generate_node_code(parsed: &ParsedNodeFn) -> syn::Result<TokenStre
 
 	let cfg = crate::shader_nodes::modify_cfg(attributes);
 	let node_input_accessor = generate_node_input_references(parsed, fn_generics, &field_idents, &graphene_core, &identifier, &cfg);
-	let ShaderTokens { shader_entry_point, gpu_node } = attributes.shader_node.as_ref().map(|n| n.codegen(parsed)).unwrap_or(Ok(ShaderTokens::default()))?;
+	let ShaderTokens { shader_entry_point, gpu_node } = attributes.shader_node.as_ref().map(|n| n.codegen(crate_ident, parsed)).unwrap_or(Ok(ShaderTokens::default()))?;
 
 	Ok(quote! {
 		/// Underlying implementation for [#struct_name]
@@ -592,6 +583,7 @@ fn generate_register_node_impl(parsed: &ParsedNodeFn, field_names: &[&Ident], st
 	})
 }
 
+use crate::crate_ident::CrateIdent;
 use crate::shader_nodes::{ShaderCodegen, ShaderTokens};
 use syn::visit_mut::VisitMut;
 use syn::{GenericArgument, Lifetime, Type};

node-graph/node-macro/src/codegen.rs

@@ -0,0 +1,46 @@
+use proc_macro_crate::{FoundCrate, crate_name};
+use proc_macro2::{Span, TokenStream};
+use quote::{format_ident, quote};
+
+pub struct CrateIdent {
+	gcore: syn::Result<TokenStream>,
+	gcore_shaders: syn::Result<TokenStream>,
+	wgpu_executor: syn::Result<TokenStream>,
+}
+
+impl CrateIdent {
+	pub fn gcore(&self) -> syn::Result<&TokenStream> {
+		self.gcore.as_ref().map_err(Clone::clone)
+	}
+
+	pub fn gcore_shaders(&self) -> syn::Result<&TokenStream> {
+		self.gcore_shaders.as_ref().map_err(Clone::clone)
+	}
+
+	pub fn wgpu_executor(&self) -> syn::Result<&TokenStream> {
+		self.wgpu_executor.as_ref().map_err(Clone::clone)
+	}
+}
+
+impl Default for CrateIdent {
+	fn default() -> Self {
+		let find_crate = |orig_name| match crate_name(orig_name) {
+			Ok(FoundCrate::Itself) => Ok(quote!(crate)),
+			Ok(FoundCrate::Name(name)) => {
+				let name = format_ident!("{}", name);
+				Ok(quote!(::#name))
+			}
+			Err(e) => Err(syn::Error::new(Span::call_site(), &format!("Could not find dependency on `{orig_name}`:\n{e}"))),
+		};
+
+		let gcore = find_crate("graphene-core");
+		let gcore_shaders = find_crate("graphene-core-shaders").or_else(|eshaders| {
+			gcore
+				.as_ref()
+				.map(Clone::clone)
+				.map_err(|ecore| syn::Error::new(Span::call_site(), &format!("{ecore}\n\nFallback: {eshaders}")))
+		});
+		let wgpu_executor = find_crate("wgpu-executor");
+		Self { gcore, gcore_shaders, wgpu_executor }
+	}
+}

node-graph/node-macro/src/crate_ident.rs

@@ -3,6 +3,7 @@ use proc_macro_error2::proc_macro_error;
 use syn::GenericParam;
 
 mod codegen;
+mod crate_ident;
 mod derive_choice_type;
 mod parsing;
 mod shader_nodes;

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

@@ -12,6 +12,7 @@ use syn::{
 };
 
 use crate::codegen::generate_node_code;
+use crate::crate_ident::CrateIdent;
 use crate::shader_nodes::ShaderNodeType;
 
 #[derive(Clone, Debug)]
@@ -35,7 +36,6 @@ pub(crate) struct ParsedNodeFn {
 	pub(crate) is_async: bool,
 	pub(crate) fields: Vec<ParsedField>,
 	pub(crate) body: TokenStream2,
-	pub(crate) crate_name: proc_macro_crate::FoundCrate,
 	pub(crate) description: String,
 }
 
@@ -313,12 +313,6 @@ fn parse_node_fn(attr: TokenStream2, item: TokenStream2) -> syn::Result<ParsedNo
 	let output_type = parse_output(&input_fn.sig.output)?;
 	let where_clause = input_fn.sig.generics.where_clause;
 	let body = input_fn.block.to_token_stream();
-	let crate_name = proc_macro_crate::crate_name("graphene-core").map_err(|e| {
-		Error::new(
-			proc_macro2::Span::call_site(),
-			format!("Failed to find location of graphene_core. Make sure it is imported as a dependency: {e}"),
-		)
-	})?;
 	let description = input_fn
 		.attrs
 		.iter()
@@ -349,7 +343,6 @@ fn parse_node_fn(attr: TokenStream2, item: TokenStream2) -> syn::Result<ParsedNo
 		fields,
 		where_clause,
 		body,
-		crate_name,
 		description,
 	})
 }
@@ -643,10 +636,11 @@ fn extract_attribute<'a>(attrs: &'a [Attribute], name: &str) -> Option<&'a Attri
 
 // Modify the new_node_fn function to use the code generation
 pub fn new_node_fn(attr: TokenStream2, item: TokenStream2) -> syn::Result<TokenStream2> {
+	let crate_ident = CrateIdent::default();
 	let mut parsed_node = parse_node_fn(attr, item.clone()).map_err(|e| Error::new(e.span(), format!("Failed to parse node function: {e}")))?;
 	parsed_node.replace_impl_trait_in_input();
 	crate::validation::validate_node_fn(&parsed_node).map_err(|e| Error::new(e.span(), format!("Validation Error: {e}")))?;
-	generate_node_code(&parsed_node).map_err(|e| Error::new(e.span(), format!("Failed to generate node code: {e}")))
+	generate_node_code(&crate_ident, &parsed_node).map_err(|e| Error::new(e.span(), format!("Failed to generate node code: {e}")))
 }
 
 impl ParsedNodeFn {
@@ -829,7 +823,6 @@ mod tests {
 				unit: None,
 			}],
 			body: TokenStream2::new(),
-			crate_name: FoundCrate::Itself,
 			description: String::from("Multi\nLine\n"),
 		};
 
@@ -911,7 +904,6 @@ mod tests {
 				},
 			],
 			body: TokenStream2::new(),
-			crate_name: FoundCrate::Itself,
 			description: String::from("Hello\n\t\t\t\tWorld\n"),
 		};
 
@@ -974,7 +966,6 @@ mod tests {
 				unit: None,
 			}],
 			body: TokenStream2::new(),
-			crate_name: FoundCrate::Itself,
 			description: "Test\n".into(),
 		};
 
@@ -1041,7 +1032,6 @@ mod tests {
 				unit: None,
 			}],
 			body: TokenStream2::new(),
-			crate_name: FoundCrate::Itself,
 			description: String::new(),
 		};
 
@@ -1110,7 +1100,6 @@ mod tests {
 				unit: None,
 			}],
 			body: TokenStream2::new(),
-			crate_name: FoundCrate::Itself,
 			description: String::new(),
 		};
 
@@ -1172,7 +1161,6 @@ mod tests {
 				unit: None,
 			}],
 			body: TokenStream2::new(),
-			crate_name: FoundCrate::Itself,
 			description: String::new(),
 		};
 
@@ -1214,7 +1202,6 @@ mod tests {
 			is_async: false,
 			fields: vec![],
 			body: TokenStream2::new(),
-			crate_name: FoundCrate::Itself,
 			description: String::new(),
 		};
 

node-graph/node-macro/src/parsing.rs

@@ -1,3 +1,4 @@
+use crate::crate_ident::CrateIdent;
 use crate::parsing::{NodeFnAttributes, ParsedNodeFn};
 use crate::shader_nodes::per_pixel_adjust::PerPixelAdjust;
 use proc_macro2::{Ident, TokenStream};
@@ -50,11 +51,11 @@ impl Parse for ShaderNodeType {
 }
 
 pub trait ShaderCodegen {
-	fn codegen(&self, parsed: &ParsedNodeFn) -> syn::Result<ShaderTokens>;
+	fn codegen(&self, crate_ident: &CrateIdent, parsed: &ParsedNodeFn) -> syn::Result<ShaderTokens>;
 }
 
 impl ShaderCodegen for ShaderNodeType {
-	fn codegen(&self, parsed: &ParsedNodeFn) -> syn::Result<ShaderTokens> {
+	fn codegen(&self, crate_ident: &CrateIdent, parsed: &ParsedNodeFn) -> syn::Result<ShaderTokens> {
 		match self {
 			ShaderNodeType::None | ShaderNodeType::ShaderNode => (),
 			_ => {
@@ -66,7 +67,7 @@ impl ShaderCodegen for ShaderNodeType {
 
 		match self {
 			ShaderNodeType::None | ShaderNodeType::ShaderNode => Ok(ShaderTokens::default()),
-			ShaderNodeType::PerPixelAdjust(x) => x.codegen(parsed),
+			ShaderNodeType::PerPixelAdjust(x) => x.codegen(crate_ident, parsed),
 		}
 	}
 }