Fix brush bounding boxes by making BrushCacheImpl's hash not shared between different instances (#2845)

* fix: add cache to each layer

* fix: warning

* fix: tests

* Clean up code

---------

Co-authored-by: Keavon Chambers <keavon@keavon.com>

node-graph/gbrush/src/brush.rs

@@ -403,7 +403,7 @@ mod test {
 					blend_mode: BlendMode::Normal,
 				},
 			}],
-			BrushCache::new_proto(),
+			BrushCache::default(),
 		)
 		.await;
 		assert_eq!(image.instance_ref_iter().next().unwrap().instance.width, 20);

node-graph/gbrush/src/brush_cache.rs

@@ -6,11 +6,16 @@ use graphene_core::raster_types::CPU;
 use graphene_core::raster_types::Raster;
 use std::collections::HashMap;
 use std::hash::Hash;
-use std::sync::Arc;
-use std::sync::Mutex;
+use std::hash::Hasher;
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::{Arc, Mutex};
 
-#[derive(Clone, Debug, PartialEq, DynAny, Default, serde::Serialize, serde::Deserialize)]
+// TODO: This is a temporary hack, be sure to not reuse this when the brush is being rewritten.
+static NEXT_BRUSH_CACHE_IMPL_ID: AtomicU64 = AtomicU64::new(0);
+
+#[derive(Clone, Debug, DynAny, serde::Serialize, serde::Deserialize)]
 struct BrushCacheImpl {
+	unique_id: u64,
 	// The full previous input that was cached.
 	prev_input: Vec<BrushStroke>,
 
@@ -90,9 +95,29 @@ impl BrushCacheImpl {
 	}
 }
 
+impl Default for BrushCacheImpl {
+	fn default() -> Self {
+		Self {
+			unique_id: NEXT_BRUSH_CACHE_IMPL_ID.fetch_add(1, Ordering::SeqCst),
+			prev_input: Vec::new(),
+			background: Default::default(),
+			blended_image: Default::default(),
+			last_stroke_texture: Default::default(),
+			brush_texture_cache: HashMap::new(),
+		}
+	}
+}
+
+impl PartialEq for BrushCacheImpl {
+	fn eq(&self, other: &Self) -> bool {
+		self.unique_id == other.unique_id
+	}
+}
+
 impl Hash for BrushCacheImpl {
-	// Zero hash.
-	fn hash<H: std::hash::Hasher>(&self, _state: &mut H) {}
+	fn hash<H: Hasher>(&self, state: &mut H) {
+		self.unique_id.hash(state);
+	}
 }
 
 #[derive(Clone, Debug, Default)]
@@ -103,46 +128,26 @@ pub struct BrushPlan {
 	pub first_stroke_point_skip: usize,
 }
 
-#[derive(Debug, DynAny, serde::Serialize, serde::Deserialize)]
-pub struct BrushCache {
-	inner: Arc<Mutex<BrushCacheImpl>>,
-	proto: bool,
-}
-
-impl Default for BrushCache {
-	fn default() -> Self {
-		Self::new_proto()
-	}
-}
+#[derive(Debug, Default, DynAny, serde::Serialize, serde::Deserialize)]
+pub struct BrushCache(Arc<Mutex<BrushCacheImpl>>);
 
 // A bit of a cursed implementation to work around the current node system.
 // The original object is a 'prototype' that when cloned gives you a independent
 // new object. Any further clones however are all the same underlying cache object.
 impl Clone for BrushCache {
 	fn clone(&self) -> Self {
-		if self.proto {
-			let inner_val = self.inner.lock().unwrap();
-			Self {
-				inner: Arc::new(Mutex::new(inner_val.clone())),
-				proto: false,
-			}
-		} else {
-			Self {
-				inner: Arc::clone(&self.inner),
-				proto: false,
-			}
-		}
+		Self(Arc::new(Mutex::new(self.0.lock().unwrap().clone())))
 	}
 }
 
 impl PartialEq for BrushCache {
 	fn eq(&self, other: &Self) -> bool {
-		if Arc::ptr_eq(&self.inner, &other.inner) {
+		if Arc::ptr_eq(&self.0, &other.0) {
 			return true;
 		}
 
-		let s = self.inner.lock().unwrap();
-		let o = other.inner.lock().unwrap();
+		let s = self.0.lock().unwrap();
+		let o = other.0.lock().unwrap();
 
 		*s == *o
 	}
@@ -150,35 +155,28 @@ impl PartialEq for BrushCache {
 
 impl Hash for BrushCache {
 	fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-		self.inner.lock().unwrap().hash(state);
+		self.0.lock().unwrap().hash(state);
 	}
 }
 
 impl BrushCache {
-	pub fn new_proto() -> Self {
-		Self {
-			inner: Default::default(),
-			proto: true,
-		}
-	}
-
 	pub fn compute_brush_plan(&self, background: Instance<Raster<CPU>>, input: &[BrushStroke]) -> BrushPlan {
-		let mut inner = self.inner.lock().unwrap();
+		let mut inner = self.0.lock().unwrap();
 		inner.compute_brush_plan(background, input)
 	}
 
 	pub fn cache_results(&self, input: Vec<BrushStroke>, blended_image: Instance<Raster<CPU>>, last_stroke_texture: Instance<Raster<CPU>>) {
-		let mut inner = self.inner.lock().unwrap();
+		let mut inner = self.0.lock().unwrap();
 		inner.cache_results(input, blended_image, last_stroke_texture)
 	}
 
 	pub fn get_cached_brush(&self, style: &BrushStyle) -> Option<Raster<CPU>> {
-		let inner = self.inner.lock().unwrap();
+		let inner = self.0.lock().unwrap();
 		inner.brush_texture_cache.get(style).cloned()
 	}
 
 	pub fn store_brush(&self, style: BrushStyle, brush: Raster<CPU>) {
-		let mut inner = self.inner.lock().unwrap();
+		let mut inner = self.0.lock().unwrap();
 		inner.brush_texture_cache.insert(style, brush);
 	}
 }