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/gstd/src/brush.rs

@@ -1,7 +1,7 @@
 use std::marker::PhantomData;
 
 use glam::{DAffine2, DVec2};
-use graphene_core::raster::{Alpha, Color, Pixel, Sample};
+use graphene_core::raster::{Alpha, Color, ImageFrame, Pixel, Sample};
 use graphene_core::transform::{Transform, TransformMut};
 use graphene_core::vector::VectorData;
 use graphene_core::Node;
@@ -21,6 +21,22 @@ where
 	iter.fold(initial, |a, x| lambda.eval((a, x)))
 }
 
+#[derive(Clone, Debug, PartialEq)]
+pub struct ChainApplyNode<Value> {
+	pub value: Value,
+}
+
+#[node_fn(ChainApplyNode)]
+async fn chain_apply<I: Iterator, T>(iter: I, mut value: T) -> T
+where
+	I::Item: for<'a> Node<'a, T, Output = T>,
+{
+	for lambda in iter {
+		value = lambda.eval(value);
+	}
+	value
+}
+
 #[derive(Clone, Debug, PartialEq)]
 pub struct IntoIterNode<T> {
 	_t: PhantomData<T>,
@@ -100,7 +116,7 @@ pub struct EraseNode<Flow> {
 #[node_fn(EraseNode)]
 fn erase(input: (Color, Color), flow: f64) -> Color {
 	let (input, brush) = input;
-	let alpha = input.a() * (1.0 - flow as f32 * brush.a());
+	let alpha = input.a() * (1. - flow as f32 * brush.a());
 	Color::from_unassociated_alpha(input.r(), input.g(), input.b(), alpha)
 }
 
@@ -134,6 +150,54 @@ fn translate_node<Data: TransformMut>(offset: DVec2, mut translatable: Data) ->
 	translatable
 }
 
+#[derive(Debug, Clone, Copy)]
+pub struct BlitNode<P, Texture, Positions, BlendFn> {
+	texture: Texture,
+	positions: Positions,
+	blend_mode: BlendFn,
+	_p: PhantomData<P>,
+}
+
+#[node_fn(BlitNode<_P>)]
+fn blit_node<_P: Alpha + Pixel + std::fmt::Debug, BlendFn>(mut target: ImageFrame<_P>, texture: ImageFrame<_P>, positions: Vec<DVec2>, blend_mode: BlendFn) -> ImageFrame<_P>
+where
+	BlendFn: for<'any_input> Node<'any_input, (_P, _P), Output = _P>,
+{
+	for position in positions {
+		let target_size = DVec2::new(target.image.width as f64, target.image.height as f64);
+		let texture_size = DVec2::new(texture.image.width as f64, texture.image.height as f64);
+		let document_to_target = target.transform.inverse();
+		let start = document_to_target.transform_point2(position) * target_size - texture_size / 2.;
+		let stop = start + texture_size;
+
+		// Half-open integer ranges [start, stop).
+		let clamp_start = start.clamp(DVec2::ZERO, target_size).as_uvec2();
+		let clamp_stop = stop.clamp(DVec2::ZERO, target_size).as_uvec2();
+
+		let blit_area_offset = (clamp_start.as_dvec2() - start).as_uvec2().min(texture_size.as_uvec2());
+		let blit_area_dimensions = (clamp_stop - clamp_start).min(texture_size.as_uvec2() - blit_area_offset);
+
+		// Tight blitting loop. Eagerly assert bounds to hopefully eliminate bounds check inside loop.
+		let texture_index = |x: u32, y: u32| -> usize { (y as usize * texture.image.width as usize) + (x as usize) };
+		let target_index = |x: u32, y: u32| -> usize { (y as usize * target.image.width as usize) + (x as usize) };
+
+		let max_y = (blit_area_offset.y + blit_area_dimensions.y).saturating_sub(1);
+		let max_x = (blit_area_offset.x + blit_area_dimensions.x).saturating_sub(1);
+		assert!(texture_index(max_x, max_y) < texture.image.data.len());
+		assert!(target_index(max_x, max_y) < target.image.data.len());
+
+		for y in blit_area_offset.y..blit_area_offset.y + blit_area_dimensions.y {
+			for x in blit_area_offset.x..blit_area_offset.x + blit_area_dimensions.x {
+				let src_pixel = texture.image.data[texture_index(x, y)];
+				let dst_pixel = &mut target.image.data[target_index(x + clamp_start.x, y + clamp_start.y)];
+				*dst_pixel = blend_mode.eval((src_pixel, *dst_pixel));
+			}
+		}
+	}
+
+	target
+}
+
 #[cfg(test)]
 mod test {
 	use super::*;
@@ -152,10 +216,10 @@ mod test {
 	fn test_translate_node() {
 		let image = Image::new(10, 10, Color::TRANSPARENT);
 		let mut image = ImageFrame { image, transform: DAffine2::IDENTITY };
-		image.translate(DVec2::new(1.0, 2.0));
+		image.translate(DVec2::new(1., 2.));
 		let translate_node = TranslateNode::new(ClonedNode::new(image));
-		let image = translate_node.eval(DVec2::new(1.0, 2.0));
-		assert_eq!(image.transform(), DAffine2::from_translation(DVec2::new(2.0, 4.0)));
+		let image = translate_node.eval(DVec2::new(1., 2.));
+		assert_eq!(image.transform(), DAffine2::from_translation(DVec2::new(2., 4.)));
 	}
 
 	#[test]
@@ -177,9 +241,9 @@ mod test {
 
 	#[test]
 	fn test_brush() {
-		let brush_texture_node = BrushStampGeneratorNode::new(ClonedNode::new(Color::BLACK), ClonedNode::new(1.0), ClonedNode::new(1.0));
+		let brush_texture_node = BrushStampGeneratorNode::new(ClonedNode::new(Color::BLACK), ClonedNode::new(1.), ClonedNode::new(1.));
 		let image = brush_texture_node.eval(20.);
-		let trace = vec![DVec2::new(0.0, 0.0), DVec2::new(10.0, 0.0)];
+		let trace = vec![DVec2::new(0., 0.), DVec2::new(10., 0.)];
 		let trace = ClonedNode::new(trace.into_iter());
 		let translate_node = TranslateNode::new(ClonedNode::new(image));
 		let frames = MapNode::new(ValueNode::new(translate_node));
@@ -189,7 +253,7 @@ mod test {
 		let background_bounds = background_bounds.eval(frames.clone().into_iter());
 		let background_bounds = ClonedNode::new(background_bounds.unwrap().to_transform());
 		let background_image = background_bounds.then(EmptyImageNode::new(ClonedNode::new(Color::TRANSPARENT)));
-		let blend_node = graphene_core::raster::BlendNode::new(ClonedNode::new(BlendMode::Normal), ClonedNode::new(1.0));
+		let blend_node = graphene_core::raster::BlendNode::new(ClonedNode::new(BlendMode::Normal), ClonedNode::new(1.));
 		let final_image = ReduceNode::new(background_image, ValueNode::new(BlendImageTupleNode::new(ValueNode::new(blend_node))));
 		let final_image = final_image.eval(frames.into_iter());
 		assert_eq!(final_image.image.height, 20);