Migrate usage of the Hash trait for cache invalidation to the dedicated CacheHash trait

Cargo.toml

@@ -11,6 +11,7 @@ members = [
 	"frontend/wrapper",
 	"libraries/dyn-any",
 	"libraries/math-parser",
+	"node-graph/libraries/graphene-hash",
 	"node-graph/libraries/*",
 	"node-graph/nodes/*",
 	"node-graph/nodes/raster/shaders",
@@ -63,6 +64,7 @@ dyn-any = { path = "libraries/dyn-any", features = [
 	"log-bad-types",
 	"rc",
 ] }
+graphene-hash = { path = "node-graph/libraries/graphene-hash", features = ["derive"] }
 preprocessor = { path = "node-graph/preprocessor" }
 math-parser = { path = "libraries/math-parser" }
 graphene-application-io = { path = "node-graph/libraries/application-io" }

editor/src/messages/portfolio/document/utility_types/network_interface/memo_network.rs

@@ -1,6 +1,5 @@
 use graph_craft::document::NodeNetwork;
 use std::cell::Cell;
-use std::hash::{Hash, Hasher};
 
 #[derive(Debug, Default, Clone, PartialEq)]
 pub struct MemoNetwork {
@@ -26,9 +25,9 @@ impl serde::Serialize for MemoNetwork {
 	}
 }
 
-impl Hash for MemoNetwork {
-	fn hash<H: Hasher>(&self, state: &mut H) {
-		self.current_hash().hash(state);
+impl core_types::CacheHash for MemoNetwork {
+	fn cache_hash<H: ::core::hash::Hasher>(&self, state: &mut H) {
+		self.current_hash().cache_hash(state);
 	}
 }
 

editor/src/messages/tool/tool_messages/gradient_tool.rs

@@ -26,7 +26,7 @@ pub struct GradientOptions {
 
 #[impl_message(Message, ToolMessage, Gradient)]
 #[cfg_attr(feature = "wasm", derive(tsify::Tsify))]
-#[derive(PartialEq, Clone, Debug, Hash, serde::Serialize, serde::Deserialize)]
+#[derive(PartialEq, Clone, Debug, serde::Serialize, serde::Deserialize)]
 pub enum GradientToolMessage {
 	// Standard messages
 	Abort,

frontend/wrapper/src/editor_wrapper.rs

@@ -22,6 +22,7 @@ use editor::messages::portfolio::utility_types::{DockingSplitDirection, FontCata
 use editor::messages::prelude::*;
 use editor::messages::tool::tool_messages::tool_prelude::WidgetId;
 use graph_craft::document::NodeId;
+use graphene_std::graphene_hash::CacheHashWrapper;
 use graphene_std::raster::color::Color;
 use graphene_std::vector::GradientStops;
 use serde::Serialize;
@@ -131,7 +132,7 @@ impl EditorWrapper {
 	// Sends a FrontendMessage to JavaScript
 	pub(crate) fn send_frontend_message_to_js(&self, message: FrontendMessage) {
 		if let FrontendMessage::UpdateImageData { ref image_data } = message {
-			let new_hash = calculate_hash(image_data);
+			let new_hash = calculate_hash(&CacheHashWrapper(image_data));
 			let prev_hash = IMAGE_DATA_HASH.load(Ordering::Relaxed);
 
 			if new_hash != prev_hash {

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

@@ -9,7 +9,7 @@
 use dyn_any::DynAny;
 use glam::IVec2;
 use log::Metadata;
 use rustc_hash::{FxBuildHasher, FxHashMap};
 use std::collections::HashMap;
 use std::collections::hash_map::DefaultHasher;
 use std::hash::{Hash, Hasher};
@@ -298,7 +298,7 @@
 	/// This describes a (document) node built out of a subgraph of other (document) nodes.
 	///
 	/// A nested [`NodeNetwork`] that is flattened by the [`NodeNetwork::flatten`] function.
 	Network(NodeNetwork),
 	/// This describes a (document) node implemented as a proto node.
 	///
 	/// A proto node identifier which can be found in `node_registry.rs`.
@@ -546,29 +546,34 @@
 	pub generated: bool,
 }
 
-impl Hash for NodeNetwork {
-	fn hash<H: Hasher>(&self, state: &mut H) {
-		self.exports.hash(state);
+impl core_types::CacheHash for NodeNetwork {
+	fn cache_hash<H: ::core::hash::Hasher>(&self, state: &mut H) {
+		use core_types::CacheHash;
+		self.exports.cache_hash(state);
 		let mut nodes: Vec<_> = self.nodes.iter().collect();
 		nodes.sort_by_key(|(id, _)| *id);
 		for (id, node) in nodes {
-			id.hash(state);
-			node.hash(state);
+			id.cache_hash(state);
+			node.cache_hash(state);
 		}
 	}
 }
 
 impl PartialEq for NodeNetwork {
 	fn eq(&self, other: &Self) -> bool {
-		self.exports == other.exports
+		self.exports == other.exports && self.nodes == other.nodes && self.scope_injections == other.scope_injections
 	}
 }
 
 /// Graph modification functions
 impl NodeNetwork {
 	pub fn current_hash(&self) -> u64 {
-		use std::hash::BuildHasher;
-		FxBuildHasher.hash_one(self)
+		use core_types::graphene_hash::CacheHash;
+		use rustc_hash::FxHasher;
+		use std::hash::Hasher;
+		let mut hasher = FxHasher::default();
+		self.cache_hash(&mut hasher);
+		hasher.finish()
 	}
 
 	pub fn value_network(node: DocumentNode) -> Self {
@@ -1136,6 +1141,12 @@
 	})
 }
 
+impl core_types::graphene_hash::CacheHash for DocumentNode {
+	fn cache_hash<H: core::hash::Hasher>(&self, state: &mut H) {
+		core::hash::Hash::hash(self, state);
+	}
+}
+
 #[cfg(test)]
 mod test {
 	use super::*;

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

@@ -5,7 +5,7 @@ use brush_nodes::brush_cache::BrushCache;
 use brush_nodes::brush_stroke::BrushStroke;
 use core_types::table::Table;
 use core_types::uuid::NodeId;
-use core_types::{Color, ContextFeatures, MemoHash, Node, Type};
+use core_types::{CacheHash, Color, ContextFeatures, MemoHash, Node, Type};
 use dyn_any::DynAny;
 pub use dyn_any::StaticType;
 use glam::{Affine2, Vec2};
@@ -43,19 +43,18 @@ macro_rules! tagged_value {
 			EditorApi(Arc<PlatformEditorApi>)
 		}
 
-		// We must manually implement hashing because some values are floats and so do not reproducibly hash (see FakeHash below)
-		#[allow(clippy::derived_hash_with_manual_eq)]
-		impl Hash for TaggedValue {
-			fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+		impl CacheHash for TaggedValue {
+			fn cache_hash<H: core::hash::Hasher>(&self, state: &mut H) {
 				core::mem::discriminant(self).hash(state);
 				match self {
 					Self::None => {}
-					$( Self::$identifier(x) => {x.hash(state)}),*
-					Self::RenderOutput(x) => x.hash(state),
-					Self::EditorApi(x) => x.hash(state),
+					$( Self::$identifier(x) => { x.cache_hash(state) }),*
+					Self::RenderOutput(x) => x.cache_hash(state),
+					Self::EditorApi(x) => x.cache_hash(state),
 				}
 			}
 		}
+
 		impl<'a> TaggedValue {
 			/// Converts to a Box<dyn DynAny>
 			pub fn to_dynany(self) -> DAny<'a> {
@@ -495,96 +494,33 @@ pub enum RenderOutputType {
 	},
 }
 
-impl Hash for RenderOutputType {
-	fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+impl CacheHash for RenderOutputType {
+	fn cache_hash<H: core::hash::Hasher>(&self, state: &mut H) {
+		core::mem::discriminant(self).hash(state);
 		match self {
-			Self::Texture(texture) => {
-				texture.hash(state);
-			}
+			Self::Texture(texture) => texture.hash(state),
 			Self::Buffer { data, width, height } => {
-				data.hash(state);
-				width.hash(state);
-				height.hash(state);
+				data.cache_hash(state);
+				width.cache_hash(state);
+				height.cache_hash(state);
 			}
 			Self::Svg { svg, image_data } => {
-				svg.hash(state);
-				image_data.hash(state);
+				svg.cache_hash(state);
+				image_data.cache_hash(state);
 			}
 			#[cfg(target_family = "wasm")]
 			Self::CanvasFrame { canvas_id, resolution } => {
-				canvas_id.hash(state);
-				resolution.to_array().iter().for_each(|x| x.to_bits().hash(state));
+				canvas_id.cache_hash(state);
+				resolution.cache_hash(state);
 			}
 		}
 	}
 }
-impl Hash for RenderOutput {
-	fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-		self.data.hash(state)
-	}
-}
 
-/// We hash the floats and so-forth despite it not being reproducible because all inputs to the node graph must be hashed otherwise the graph execution breaks (so sorry about this hack)
-trait FakeHash {
-	fn hash<H: core::hash::Hasher>(&self, state: &mut H);
-}
-mod fake_hash {
-	use super::*;
-	impl FakeHash for f64 {
-		fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
-			self.to_bits().hash(state)
-		}
-	}
-	impl FakeHash for f32 {
-		fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
-			self.to_bits().hash(state)
-		}
-	}
-	impl FakeHash for DVec2 {
-		fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
-			self.to_array().iter().for_each(|x| x.to_bits().hash(state))
-		}
-	}
-	impl FakeHash for Vec2 {
-		fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
-			self.to_array().iter().for_each(|x| x.to_bits().hash(state))
-		}
-	}
-	impl FakeHash for DAffine2 {
-		fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
-			self.to_cols_array().iter().for_each(|x| x.to_bits().hash(state))
-		}
-	}
-	impl FakeHash for Affine2 {
-		fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
-			self.to_cols_array().iter().for_each(|x| x.to_bits().hash(state))
-		}
-	}
-	impl<T: FakeHash> FakeHash for Option<T> {
-		fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
-			if let Some(x) = self {
-				1.hash(state);
-				x.hash(state);
-			} else {
-				0.hash(state);
-			}
-		}
-	}
-	impl<T: FakeHash> FakeHash for Vec<T> {
-		fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
-			self.len().hash(state);
-			self.iter().for_each(|x| x.hash(state))
-		}
-	}
-	impl<T: FakeHash, const N: usize> FakeHash for [T; N] {
-		fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
-			self.iter().for_each(|x| x.hash(state))
-		}
-	}
-	impl FakeHash for (f64, Color) {
-		fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
-			self.0.to_bits().hash(state);
-			self.1.hash(state)
-		}
+// Metadata is excluded because it's editor-side auxiliary data (click targets, transforms)
+// that shouldn't affect render cache invalidation, and it contains HashMaps with non-deterministic iteration order
+impl CacheHash for RenderOutput {
+	fn cache_hash<H: core::hash::Hasher>(&self, state: &mut H) {
+		self.data.cache_hash(state);
 	}
 }

node-graph/libraries/application-io/src/lib.rs

@@ -164,6 +164,12 @@ impl<Io> Hash for EditorApi<Io> {
 	}
 }
 
+impl<Io> core_types::graphene_hash::CacheHash for EditorApi<Io> {
+	fn cache_hash<H: core::hash::Hasher>(&self, state: &mut H) {
+		core::hash::Hash::hash(self, state);
+	}
+}
+
 impl<Io> PartialEq for EditorApi<Io> {
 	fn eq(&self, other: &Self) -> bool {
 		self.font_cache == other.font_cache

node-graph/libraries/core-types/Cargo.toml

@@ -16,6 +16,7 @@ wasm = ["tsify", "wasm-bindgen", "no-std-types/wasm"]
 [dependencies]
 # Local dependencies
 no-std-types = { workspace = true, features = ["std"] }
+graphene-hash = { workspace = true, features = ["derive"] }
 
 # Workspace dependencies
 bitflags = { workspace = true }