Make Brush tool use per-stroke options and improve its performance (#1242)

* Laid groundwork for per-stroke brush parameters.

* Added new spacing parameter.

* Added back interpolation, using spacing parameter.

* Move bounding box code into core.

* Initial working prototype of per-stroke styles.

* Removed now useless brush node properties.

* Made default spacing 50% for performance comparison.

* Quick and dirty prototype for BlitNode copied from blend.

* Fixed error after rebase.

* Optimized the blitting loop.

* Pretty big optimization for into_flat_u8.

* Insert brush node for images

* Fix starting position transform

* UX polish

* Code review nits

---------

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

node-graph/gcore/src/raster/bbox.rs

@@ -0,0 +1,86 @@
+use dyn_any::{DynAny, StaticType};
+use glam::{DAffine2, DVec2};
+
+#[derive(Debug, Clone, DynAny)]
+pub struct AxisAlignedBbox {
+	pub start: DVec2,
+	pub end: DVec2,
+}
+
+impl AxisAlignedBbox {
+	pub const ZERO: Self = Self { start: DVec2::ZERO, end: DVec2::ZERO };
+
+	pub fn size(&self) -> DVec2 {
+		self.end - self.start
+	}
+
+	pub fn to_transform(&self) -> DAffine2 {
+		DAffine2::from_translation(self.start) * DAffine2::from_scale(self.size())
+	}
+
+	pub fn contains(&self, point: DVec2) -> bool {
+		point.x >= self.start.x && point.x <= self.end.x && point.y >= self.start.y && point.y <= self.end.y
+	}
+
+	pub fn intersects(&self, other: &AxisAlignedBbox) -> bool {
+		other.start.x <= self.end.x && other.end.x >= self.start.x && other.start.y <= self.end.y && other.end.y >= self.start.y
+	}
+
+	pub fn union(&self, other: &AxisAlignedBbox) -> AxisAlignedBbox {
+		AxisAlignedBbox {
+			start: DVec2::new(self.start.x.min(other.start.x), self.start.y.min(other.start.y)),
+			end: DVec2::new(self.end.x.max(other.end.x), self.end.y.max(other.end.y)),
+		}
+	}
+	pub fn union_non_empty(&self, other: &AxisAlignedBbox) -> Option<AxisAlignedBbox> {
+		match (self.size() == DVec2::ZERO, other.size() == DVec2::ZERO) {
+			(true, true) => None,
+			(true, _) => Some(other.clone()),
+			(_, true) => Some(self.clone()),
+			_ => Some(AxisAlignedBbox {
+				start: DVec2::new(self.start.x.min(other.start.x), self.start.y.min(other.start.y)),
+				end: DVec2::new(self.end.x.max(other.end.x), self.end.y.max(other.end.y)),
+			}),
+		}
+	}
+}
+
+#[derive(Debug, Clone)]
+pub struct Bbox {
+	pub top_left: DVec2,
+	pub top_right: DVec2,
+	pub bottom_left: DVec2,
+	pub bottom_right: DVec2,
+}
+
+impl Bbox {
+	pub fn unit() -> Self {
+		Self {
+			top_left: DVec2::new(0., 1.),
+			top_right: DVec2::new(1., 1.),
+			bottom_left: DVec2::new(0., 0.),
+			bottom_right: DVec2::new(1., 0.),
+		}
+	}
+
+	pub fn affine_transform(self, transform: DAffine2) -> Self {
+		Self {
+			top_left: transform.transform_point2(self.top_left),
+			top_right: transform.transform_point2(self.top_right),
+			bottom_left: transform.transform_point2(self.bottom_left),
+			bottom_right: transform.transform_point2(self.bottom_right),
+		}
+	}
+
+	pub fn to_axis_aligned_bbox(&self) -> AxisAlignedBbox {
+		let start_x = self.top_left.x.min(self.top_right.x).min(self.bottom_left.x).min(self.bottom_right.x);
+		let start_y = self.top_left.y.min(self.top_right.y).min(self.bottom_left.y).min(self.bottom_right.y);
+		let end_x = self.top_left.x.max(self.top_right.x).max(self.bottom_left.x).max(self.bottom_right.x);
+		let end_y = self.top_left.y.max(self.top_right.y).max(self.bottom_left.y).max(self.bottom_right.y);
+
+		AxisAlignedBbox {
+			start: DVec2::new(start_x, start_y),
+			end: DVec2::new(end_x, end_y),
+		}
+	}
+}

node-graph/gcore/src/raster/image.rs

@@ -143,25 +143,47 @@ where
 		let Image { width, height, data } = self;
 		assert!(data.len() == width as usize * height as usize);
 
-		let mut result = Vec::with_capacity(data.len() * 4);
+		// Cache the last sRGB value we computed, speeds up fills.
+		let mut last_r = 0.;
+		let mut last_r_srgb = 0u8;
+		let mut last_g = 0.;
+		let mut last_g_srgb = 0u8;
+		let mut last_b = 0.;
+		let mut last_b_srgb = 0u8;
+
+		let mut result = vec![0; data.len() * 4];
+		let mut i = 0;
 		for color in data {
 			let a = color.a().to_f32();
-			if a < 0.5 / 255.0 {
-				// This would map to fully transparent anyway, avoid expensive encoding.
-				result.push(0);
-				result.push(0);
-				result.push(0);
-				result.push(0);
-			} else {
-				let undo_premultiply = 1.0 / a;
-				let r = float_to_srgb_u8(color.r().to_f32() * undo_premultiply);
-				let g = float_to_srgb_u8(color.g().to_f32() * undo_premultiply);
-				let b = float_to_srgb_u8(color.b().to_f32() * undo_premultiply);
-				result.push(r);
-				result.push(g);
-				result.push(b);
-				result.push((a * 255.0 + 0.5) as u8);
+			// Smaller alpha values than this would map to fully transparent
+			// anyway, avoid expensive encoding.
+			if a >= 0.5 / 255. {
+				let undo_premultiply = 1. / a;
+				let r = color.r().to_f32() * undo_premultiply;
+				let g = color.g().to_f32() * undo_premultiply;
+				let b = color.b().to_f32() * undo_premultiply;
+
+				// Compute new sRGB value if necessary.
+				if r != last_r {
+					last_r = r;
+					last_r_srgb = float_to_srgb_u8(r);
+				}
+				if g != last_g {
+					last_g = g;
+					last_g_srgb = float_to_srgb_u8(g);
+				}
+				if b != last_b {
+					last_b = b;
+					last_b_srgb = float_to_srgb_u8(b);
+				}
+
+				result[i] = last_r_srgb;
+				result[i + 1] = last_g_srgb;
+				result[i + 2] = last_b_srgb;
+				result[i + 3] = (a * 255. + 0.5) as u8;
 			}
+
+			i += 4;
 		}
 
 		(result, width, height)