Start implementation of context invalidation

* Add inject trait variants
* Route Extract / Inject traits to the proto nodes

Author: TrueDoctor

Cargo.lock

@@ -43,6 +43,7 @@ pub(super) fn post_process_nodes(mut custom: Vec<DocumentNodeDefinition>) -> Vec
 			fields,
 			description,
 			properties,
+			context_features,
 		} = metadata;
 
 		let Some(implementations) = &node_registry.get(id) else { continue };
@@ -59,10 +60,11 @@ pub(super) fn post_process_nodes(mut custom: Vec<DocumentNodeDefinition>) -> Vec
 			node_template: NodeTemplate {
 				document_node: DocumentNode {
 					inputs,
-					call_argument: (input_type.clone()),
+					call_argument: input_type.clone(),
 					implementation: DocumentNodeImplementation::ProtoNode(id.clone()),
 					visible: true,
 					skip_deduplication: false,
+					context_features: ContextDependencies::from(context_features.as_slice()),
 					..Default::default()
 				},
 				persistent_node_metadata: DocumentNodePersistentMetadata {

editor/src/messages/portfolio/document/node_graph/document_node_definitions/document_node_derive.rs

@@ -18,6 +18,7 @@ dealloc_nodes = []
 graphene-core-shaders = { workspace = true, features = ["std"] }
 
 # Workspace dependencies
+bitflags = { workspace = true }
 bytemuck = { workspace = true }
 node-macro = { workspace = true }
 num-traits = { workspace = true }

node-graph/gcore/Cargo.toml

@@ -31,20 +31,99 @@ pub trait ExtractIndex {
 
 // Consider returning a slice or something like that
 pub trait ExtractVarArgs {
-	// Call this lifetime 'b so it is less likely to coflict when auto generating the function signature for implementation
 	fn vararg(&self, index: usize) -> Result<DynRef<'_>, VarArgsResult>;
 	fn varargs_len(&self) -> Result<usize, VarArgsResult>;
 }
+
 // Consider returning a slice or something like that
 pub trait CloneVarArgs: ExtractVarArgs {
 	// fn box_clone(&self) -> Vec<DynBox>;
 	fn arc_clone(&self) -> Option<Arc<dyn ExtractVarArgs + Send + Sync>>;
 }
 
+// Inject* traits for providing context features to downstream nodes
+pub trait InjectFootprint {}
+pub trait InjectTime {}
+pub trait InjectAnimationTime {}
+pub trait InjectIndex {}
+pub trait InjectVarArgs {}
+
+// Modify* marker traits for context-transparent nodes
+pub trait ModifyFootprint: ExtractFootprint + InjectFootprint {}
+pub trait ModifyTime: ExtractTime + InjectTime {}
+pub trait ModifyAnimationTime: ExtractAnimationTime + InjectAnimationTime {}
+pub trait ModifyIndex: ExtractIndex + InjectIndex {}
+pub trait ModifyVarArgs: ExtractVarArgs + InjectVarArgs {}
+
 pub trait ExtractAll: ExtractFootprint + ExtractIndex + ExtractTime + ExtractAnimationTime + ExtractVarArgs {}
 
 impl<T: ?Sized + ExtractFootprint + ExtractIndex + ExtractTime + ExtractAnimationTime + ExtractVarArgs> ExtractAll for T {}
 
+impl<T: Ctx> InjectFootprint for T {}
+impl<T: Ctx> InjectTime for T {}
+impl<T: Ctx> InjectAnimationTime for T {}
+impl<T: Ctx> InjectVarArgs for T {}
+
+// Public enum for flexible node macro codegen
+#[derive(Debug, Clone, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
+pub enum ContextFeature {
+	ExtractFootprint,
+	ExtractTime,
+	ExtractAnimationTime,
+	ExtractIndex,
+	ExtractVarArgs,
+	InjectFootprint,
+	InjectTime,
+	InjectAnimationTime,
+	InjectIndex,
+	InjectVarArgs,
+}
+
+// Internal bitflags for fast compiler analysis (only extract features)
+use bitflags::bitflags;
+bitflags! {
+	#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, dyn_any::DynAny, serde::Serialize, serde::Deserialize, Default)]
+	pub struct ContextFeatures: u32 {
+		const FOOTPRINT = 1 << 0;
+		const TIME = 1 << 1;
+		const ANIMATION_TIME = 1 << 2;
+		const INDEX = 1 << 3;
+		const VAR_ARGS = 1 << 4;
+	}
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, dyn_any::DynAny, serde::Serialize, serde::Deserialize, Default)]
+pub struct ContextDependencies {
+	extract: ContextFeatures,
+	inject: ContextFeatures,
+}
+
+impl From<&[ContextFeature]> for ContextDependencies {
+	fn from(features: &[ContextFeature]) -> Self {
+		let mut extract = ContextFeatures::empty();
+		let mut inject = ContextFeatures::empty();
+		for feature in features {
+			extract |= match feature {
+				ContextFeature::ExtractFootprint => ContextFeatures::FOOTPRINT,
+				ContextFeature::ExtractTime => ContextFeatures::TIME,
+				ContextFeature::ExtractAnimationTime => ContextFeatures::ANIMATION_TIME,
+				ContextFeature::ExtractIndex => ContextFeatures::INDEX,
+				ContextFeature::ExtractVarArgs => ContextFeatures::VAR_ARGS,
+				_ => ContextFeatures::empty(),
+			};
+			inject |= match feature {
+				ContextFeature::InjectFootprint => ContextFeatures::FOOTPRINT,
+				ContextFeature::InjectTime => ContextFeatures::TIME,
+				ContextFeature::InjectAnimationTime => ContextFeatures::ANIMATION_TIME,
+				ContextFeature::InjectIndex => ContextFeatures::INDEX,
+				ContextFeature::InjectVarArgs => ContextFeatures::VAR_ARGS,
+				_ => ContextFeatures::empty(),
+			};
+		}
+		Self { extract, inject }
+	}
+}
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum VarArgsResult {
 	IndexOutOfBounds,
@@ -279,21 +358,29 @@ impl std::hash::Hash for OwnedContextImpl {
 impl OwnedContextImpl {
 	#[track_caller]
 	pub fn from<T: ExtractAll + CloneVarArgs>(value: T) -> Self {
-		let footprint = value.try_footprint().copied();
-		let index = value.try_index();
-		let time = value.try_time();
-		let frame_time = value.try_animation_time();
-		let parent = match value.varargs_len() {
-			Ok(x) if x > 0 => value.arc_clone(),
-			_ => None,
-		};
+		OwnedContextImpl::from_flags(value, ContextFeatures::all())
+	}
+	#[track_caller]
+	pub fn from_flags<T: ExtractAll + CloneVarArgs>(value: T, bitflags: ContextFeatures) -> Self {
+		let footprint = bitflags.contains(ContextFeatures::FOOTPRINT).then(|| value.try_footprint().copied()).flatten();
+		let index = bitflags.contains(ContextFeatures::INDEX).then(|| value.try_index()).flatten();
+		let time = bitflags.contains(ContextFeatures::TIME).then(|| value.try_time()).flatten();
+		let animation_time = bitflags.contains(ContextFeatures::ANIMATION_TIME).then(|| value.try_animation_time()).flatten();
+		let parent = bitflags
+			.contains(ContextFeatures::VAR_ARGS)
+			.then(|| match value.varargs_len() {
+				Ok(x) if x > 0 => value.arc_clone(),
+				_ => None,
+			})
+			.flatten();
+
 		OwnedContextImpl {
 			footprint,
 			varargs: None,
 			parent,
 			index,
 			real_time: time,
-			animation_time: frame_time,
+			animation_time,
 		}
 	}
 	pub const fn empty() -> Self {

node-graph/gcore/src/context.rs

@@ -0,0 +1,37 @@
+use crate::context::{CloneVarArgs, Context, ContextFeatures, Ctx, ExtractAll};
+use crate::gradient::GradientStops;
+use crate::raster_types::{CPU, GPU, Raster};
+use crate::table::Table;
+use crate::vector::Vector;
+use crate::{Graphic, OwnedContextImpl};
+use core::f64;
+use glam::{DAffine2, DVec2};
+use graphene_core_shaders::color::Color;
+
+/// Node for filtering context features based on requirements
+/// This node is inserted by the compiler to "zero out" unused context parts
+#[node_macro::node(category("Internal"))]
+async fn context_modification<T>(
+	ctx: impl Ctx + CloneVarArgs + ExtractAll,
+	#[implementations(
+		Context -> (),
+		Context -> bool,
+		Context -> u32,
+		Context -> f32,
+		Context -> f64,
+		Context -> DAffine2,
+		Context -> DVec2,
+		Context -> Table<Vector>,
+		Context -> Table<Graphic>,
+		Context -> Table<Raster<CPU>>,
+		Context -> Table<Raster<GPU>>,
+		Context -> Table<Color>,
+		Context -> Table<GradientStops>,
+	)]
+	value: impl Node<Context<'static>, Output = T>,
+	features_to_keep: ContextFeatures,
+) -> T {
+	let new_context = OwnedContextImpl::from_flags(ctx, features_to_keep);
+
+	value.eval(Some(new_context.into())).await
+}

node-graph/gcore/src/context_modification.rs

@@ -7,6 +7,7 @@ pub mod blending_nodes;
 pub mod bounds;
 pub mod consts;
 pub mod context;
+pub mod context_modification;
 pub mod debug;
 pub mod extract_xy;
 pub mod generic;

node-graph/gcore/src/lib.rs

@@ -1,4 +1,4 @@
-use crate::{Node, NodeIO, NodeIOTypes, ProtoNodeIdentifier, Type, WasmNotSend};
+use crate::{ContextFeature, Node, NodeIO, NodeIOTypes, ProtoNodeIdentifier, Type, WasmNotSend};
 use dyn_any::{DynAny, StaticType};
 use std::collections::HashMap;
 use std::marker::PhantomData;
@@ -16,6 +16,7 @@ pub struct NodeMetadata {
 	pub fields: Vec<FieldMetadata>,
 	pub description: &'static str,
 	pub properties: Option<&'static str>,
+	pub context_features: Vec<ContextFeature>,
 }
 
 // Translation struct between macro and definition

node-graph/gcore/src/registry.rs

@@ -7,7 +7,7 @@ use glam::IVec2;
 use graphene_core::memo::MemoHashGuard;
 pub use graphene_core::uuid::NodeId;
 pub use graphene_core::uuid::generate_uuid;
-use graphene_core::{Context, Cow, MemoHash, ProtoNodeIdentifier, Type};
+use graphene_core::{Context, ContextDependencies, Cow, MemoHash, ProtoNodeIdentifier, Type};
 use log::Metadata;
 use rustc_hash::FxHashMap;
 use std::collections::HashMap;
@@ -129,6 +129,9 @@ pub struct DocumentNode {
 	/// The path to this node and its inputs and outputs as of when [`NodeNetwork::generate_node_paths`] was called.
 	#[serde(skip)]
 	pub original_location: OriginalLocation,
+	// List of Extract and Inject annotations for the Context
+	#[serde(default)]
+	pub context_features: ContextDependencies,
 }
 
 /// Represents the original location of a node input/output when [`NodeNetwork::generate_node_paths`] was called, allowing the types and errors to be derived.
@@ -163,6 +166,7 @@ impl Default for DocumentNode {
 			visible: true,
 			skip_deduplication: Default::default(),
 			original_location: OriginalLocation::default(),
+			context_features: Default::default(),
 		}
 	}
 }
@@ -231,6 +235,7 @@ impl DocumentNode {
 			construction_args: args,
 			original_location: self.original_location,
 			skip_deduplication: self.skip_deduplication,
+			context_features: self.context_features,
 		}
 	}
 }

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

@@ -132,6 +132,7 @@ pub struct ProtoNode {
 	pub identifier: ProtoNodeIdentifier,
 	pub original_location: OriginalLocation,
 	pub skip_deduplication: bool,
+	pub(crate) context_features: ContextDependencies,
 }
 
 impl Default for ProtoNode {
@@ -142,6 +143,7 @@ impl Default for ProtoNode {
 			call_argument: concrete!(()),
 			original_location: OriginalLocation::default(),
 			skip_deduplication: false,
+			context_features: Default::default(),
 		}
 	}
 }
@@ -181,6 +183,7 @@ impl ProtoNode {
 				..Default::default()
 			},
 			skip_deduplication: false,
+			context_features: Default::default(),
 		}
 	}
 
@@ -290,11 +293,63 @@ impl ProtoNetwork {
 		(inwards_edges, id_map)
 	}
 
+	/// Inserts context nullification nodes to optimize caching
+	/// This analysis is performed after topological sorting to ensure proper dependency tracking
+	pub fn insert_context_nullification_nodes(&mut self) -> Result<(), String> {
+		// TODO: Implement full context flow analysis with:
+		// 1. DFS traversal to track context feature requirements
+		// 2. Branch convergence analysis
+		// 3. Post-injection nullification
+		// 4. Insert ContextModificationNode instances where beneficial
+
+		Ok(())
+	}
+
 	/// Inserts a [`structural::ComposeNode`] for each node that has a [`ProtoNodeInput::Node`]. The compose node evaluates the first node, and then sends the result into the second node.
 	pub fn resolve_inputs(&mut self) -> Result<(), String> {
 		// Perform topological sort once
 		self.reorder_ids()?;
+		// Insert context nullification nodes after topological sort
+		self.insert_context_nullification_nodes()?;
+
+		// Collect outward edges once
+		let outwards_edges = self.collect_outwards_edges();
+
+		// // Iterate over nodes in topological order
+		// for node_id in 0..=max_id {
+		// 	let node_id = NodeId(node_id);
 
+		// 	let (_, node) = &mut self.nodes[node_id.0 as usize];
+
+		// 	if let ProtoNodeInput::Node(input_node_id) = node.input {
+		// 		// Create a new node that composes the current node and its input node
+		// 		let compose_node_id = NodeId(self.nodes.len() as u64);
+
+		// 		let (_, input_node_id_proto) = &self.nodes[input_node_id.0 as usize];
+
+		// 		let input = input_node_id_proto.input.clone();
+
+		// 		let mut path = input_node_id_proto.original_location.path.clone();
+		// 		if let Some(path) = &mut path {
+		// 			path.push(node_id);
+		// 		}
+
+		// 		self.nodes.push((
+		// 			compose_node_id,
+		// 			ProtoNode {
+		// 				identifier: ProtoNodeIdentifier::new("graphene_core::structural::ComposeNode"),
+		// 				construction_args: ConstructionArgs::Nodes(vec![(input_node_id, false), (node_id, true)]),
+		// 				call_argument,
+		// 				original_location: OriginalLocation { path, ..Default::default() },
+		// 				skip_deduplication: false,
+		// 				context_features: Default::default(),
+		// 			},
+		// 		));
+
+		// 		self.replace_node_id(&outwards_edges, node_id, compose_node_id);
+		// 	}
+		// }
+		self.reorder_ids()?;
 		Ok(())
 	}
 

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

@@ -41,6 +41,8 @@ pub(crate) fn generate_node_code(parsed: &ParsedNodeFn) -> syn::Result<TokenStre
 	let struct_generics: Vec<Ident> = fields.iter().enumerate().map(|(i, _)| format_ident!("Node{}", i)).collect();
 	let input_ident = &input.pat_ident;
 
+	let context_features = &input.context_features;
+
 	let field_idents: Vec<_> = fields.iter().map(|f| &f.pat_ident).collect();
 	let field_names: Vec<_> = field_idents.iter().map(|pat_ident| &pat_ident.ident).collect();
 
@@ -242,7 +244,7 @@ pub(crate) fn generate_node_code(parsed: &ParsedNodeFn) -> syn::Result<TokenStre
 					#name: #graphene_core::Node<'n, #input_type, Output = #fut_ident > + #graphene_core::WasmNotSync
 				)
 			}
-			(ParsedFieldType::Node { .. }, false) => unreachable!(),
+			(ParsedFieldType::Node { .. }, false) => unreachable!("Found node which takes an impl Node<> input but is not async"),
 		});
 	}
 	let where_clause = where_clause.clone().unwrap_or(WhereClause {
@@ -327,7 +329,7 @@ pub(crate) fn generate_node_code(parsed: &ParsedNodeFn) -> syn::Result<TokenStre
 		mod #mod_name {
 			use super::*;
 			use #graphene_core as gcore;
-			use gcore::{Node, NodeIOTypes, concrete, fn_type, fn_type_fut, future, ProtoNodeIdentifier, WasmNotSync, NodeIO};
+			use gcore::{Node, NodeIOTypes, concrete, fn_type, fn_type_fut, future, ProtoNodeIdentifier, WasmNotSync, NodeIO, ContextFeature};
 			use gcore::value::ClonedNode;
 			use gcore::ops::TypeNode;
 			use gcore::registry::{NodeMetadata, FieldMetadata, NODE_REGISTRY, NODE_METADATA, DynAnyNode, DowncastBothNode, DynFuture, TypeErasedBox, PanicNode, RegistryValueSource, RegistryWidgetOverride};
@@ -362,6 +364,7 @@ pub(crate) fn generate_node_code(parsed: &ParsedNodeFn) -> syn::Result<TokenStre
 					category: #category,
 					description: #description,
 					properties: #properties,
+					context_features: vec![#(ContextFeature::#context_features,)*],
 					fields: vec![
 						#(
 							FieldMetadata {