Brush blend modes and erase/restore (#1261)

* Made blit node numerically stable.

* Added blend mode parameter to brush strokes.

* Fixed difference blend mode.

* Added erase/restore blend modes.

* Added blend mode and draw mode widgets.

* Added comment explaining the ImageFrame.transform.

* Initial blit/blend version.

* Working version of erase/restore.

* Improved inlining for blend functions.

* Dsiable the blend mode selector in erase/draw mode.

* Fixed incorrect bounds calculation.

* Use factor instead of percentage for opacity

* Rearrange options bar widgets

* Tidy up blend modes

* Code review

---------

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

node-graph/gcore/src/raster.rs

@@ -199,6 +199,7 @@ pub trait Sample {
 impl<'i, T: Sample> Sample for &'i T {
 	type Pixel = T::Pixel;
 
+	#[inline(always)]
 	fn sample(&self, pos: DVec2, area: DVec2) -> Option<Self::Pixel> {
 		(**self).sample(pos, area)
 	}

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

@@ -46,37 +46,28 @@ impl core::fmt::Display for LuminanceCalculation {
 }
 
 impl BlendMode {
-	pub fn list() -> [BlendMode; 29] {
+	pub fn list() -> [&'static [BlendMode]; 6] {
 		[
-			BlendMode::Normal,
-			BlendMode::Multiply,
-			BlendMode::Darken,
-			BlendMode::ColorBurn,
-			BlendMode::LinearBurn,
-			BlendMode::DarkerColor,
-			BlendMode::Screen,
-			BlendMode::Lighten,
-			BlendMode::ColorDodge,
-			BlendMode::LinearDodge,
-			BlendMode::LighterColor,
-			BlendMode::Overlay,
-			BlendMode::SoftLight,
-			BlendMode::HardLight,
-			BlendMode::VividLight,
-			BlendMode::LinearLight,
-			BlendMode::PinLight,
-			BlendMode::HardMix,
-			BlendMode::Difference,
-			BlendMode::Exclusion,
-			BlendMode::Subtract,
-			BlendMode::Divide,
-			BlendMode::Hue,
-			BlendMode::Saturation,
-			BlendMode::Color,
-			BlendMode::Luminosity,
-			BlendMode::InsertRed,
-			BlendMode::InsertGreen,
-			BlendMode::InsertBlue,
+			// Normal group
+			&[BlendMode::Normal],
+			// Darken group
+			&[BlendMode::Darken, BlendMode::Multiply, BlendMode::ColorBurn, BlendMode::LinearBurn, BlendMode::DarkerColor],
+			// Lighten group
+			&[BlendMode::Lighten, BlendMode::Screen, BlendMode::ColorDodge, BlendMode::LinearDodge, BlendMode::LighterColor],
+			// Contrast group
+			&[
+				BlendMode::Overlay,
+				BlendMode::SoftLight,
+				BlendMode::HardLight,
+				BlendMode::VividLight,
+				BlendMode::LinearLight,
+				BlendMode::PinLight,
+				BlendMode::HardMix,
+			],
+			// Inversion group
+			&[BlendMode::Difference, BlendMode::Exclusion, BlendMode::Subtract, BlendMode::Divide],
+			// Component group
+			&[BlendMode::Hue, BlendMode::Saturation, BlendMode::Color, BlendMode::Luminosity],
 		]
 	}
 }
@@ -84,7 +75,7 @@ impl BlendMode {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "std", derive(specta::Type))]
 #[derive(Debug, Default, Clone, Copy, Eq, PartialEq, DynAny, Hash)]
-#[repr(i32)] // TODO: Enable Int8 capability for SPRIV so that we don't need this?
+#[repr(i32)] // TODO: Enable Int8 capability for SPIR-V so that we don't need this?
 pub enum BlendMode {
 	#[default]
 	// Basic group
@@ -126,29 +117,30 @@ pub enum BlendMode {
 	Color,
 	Luminosity,
 
-	// Other Stuff
-	InsertRed,
-	InsertGreen,
-	InsertBlue,
+	// Other stuff
+	Erase,
+	Restore,
+	MultiplyAlpha,
 }
 
 impl core::fmt::Display for BlendMode {
 	fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
 		match self {
+			// Normal group
 			BlendMode::Normal => write!(f, "Normal"),
-
-			BlendMode::Multiply => write!(f, "Multiply"),
+			// Darken group
 			BlendMode::Darken => write!(f, "Darken"),
+			BlendMode::Multiply => write!(f, "Multiply"),
 			BlendMode::ColorBurn => write!(f, "Color Burn"),
 			BlendMode::LinearBurn => write!(f, "Linear Burn"),
 			BlendMode::DarkerColor => write!(f, "Darker Color"),
-
-			BlendMode::Screen => write!(f, "Screen"),
+			// Lighten group
 			BlendMode::Lighten => write!(f, "Lighten"),
+			BlendMode::Screen => write!(f, "Screen"),
 			BlendMode::ColorDodge => write!(f, "Color Dodge"),
 			BlendMode::LinearDodge => write!(f, "Linear Dodge"),
 			BlendMode::LighterColor => write!(f, "Lighter Color"),
-
+			// Contrast group
 			BlendMode::Overlay => write!(f, "Overlay"),
 			BlendMode::SoftLight => write!(f, "Soft Light"),
 			BlendMode::HardLight => write!(f, "Hard Light"),
@@ -156,64 +148,24 @@ impl core::fmt::Display for BlendMode {
 			BlendMode::LinearLight => write!(f, "Linear Light"),
 			BlendMode::PinLight => write!(f, "Pin Light"),
 			BlendMode::HardMix => write!(f, "Hard Mix"),
-
+			// Inversion group
 			BlendMode::Difference => write!(f, "Difference"),
 			BlendMode::Exclusion => write!(f, "Exclusion"),
 			BlendMode::Subtract => write!(f, "Subtract"),
 			BlendMode::Divide => write!(f, "Divide"),
-
+			// Component group
 			BlendMode::Hue => write!(f, "Hue"),
 			BlendMode::Saturation => write!(f, "Saturation"),
 			BlendMode::Color => write!(f, "Color"),
 			BlendMode::Luminosity => write!(f, "Luminosity"),
-
-			BlendMode::InsertRed => write!(f, "Insert Red"),
-			BlendMode::InsertGreen => write!(f, "Insert Green"),
-			BlendMode::InsertBlue => write!(f, "Insert Blue"),
+			// Other utility blend modes (hidden from the normal list)
+			BlendMode::Erase => write!(f, "Erase"),
+			BlendMode::Restore => write!(f, "Restore"),
+			BlendMode::MultiplyAlpha => write!(f, "Multiply Alpha"),
 		}
 	}
 }
 
-pub fn to_primtive_string(blend_mode: &BlendMode) -> &'static str {
-	match blend_mode {
-		BlendMode::Normal => "Normal",
-
-		BlendMode::Multiply => "Multiply",
-		BlendMode::Darken => "Darken",
-		BlendMode::ColorBurn => "ColorBurn",
-		BlendMode::LinearBurn => "LinearBurn",
-		BlendMode::DarkerColor => "DarkerColor",
-
-		BlendMode::Screen => "Screen",
-		BlendMode::Lighten => "Lighten",
-		BlendMode::ColorDodge => "ColorDodge",
-		BlendMode::LinearDodge => "LinearDodge",
-		BlendMode::LighterColor => "LighterColor",
-
-		BlendMode::Overlay => "Overlay",
-		BlendMode::SoftLight => "SoftLight",
-		BlendMode::HardLight => "HardLight",
-		BlendMode::VividLight => "VividLight",
-		BlendMode::LinearLight => "LinearLight",
-		BlendMode::PinLight => "PinLight",
-		BlendMode::HardMix => "HardMix",
-
-		BlendMode::Difference => "Difference",
-		BlendMode::Exclusion => "Exclusion",
-		BlendMode::Subtract => "Subtract",
-		BlendMode::Divide => "Divide",
-
-		BlendMode::Hue => "Hue",
-		BlendMode::Saturation => "Saturation",
-		BlendMode::Color => "Color",
-		BlendMode::Luminosity => "Luminosity",
-
-		BlendMode::InsertRed => "InsertRed",
-		BlendMode::InsertGreen => "InsertGreen",
-		BlendMode::InsertBlue => "InsertBlue",
-	}
-}
-
 #[derive(Debug, Clone, Copy, Default)]
 pub struct LuminanceNode<LuminanceCalculation> {
 	luminance_calc: LuminanceCalculation,
@@ -452,24 +404,27 @@ pub struct BlendNode<BlendMode, Opacity> {
 
 #[node_macro::node_fn(BlendNode)]
 fn blend_node(input: (Color, Color), blend_mode: BlendMode, opacity: f64) -> Color {
-	let opacity = opacity as f32 / 100.;
-
-	let (foreground, background) = input;
+	blend_colors(input.0, input.1, blend_mode, opacity as f32 / 100.)
+}
 
+#[inline(always)]
+pub fn blend_colors(foreground: Color, background: Color, blend_mode: BlendMode, opacity: f32) -> Color {
 	let target_color = match blend_mode {
+		// Normal group
 		BlendMode::Normal => background.blend_rgb(foreground, Color::blend_normal),
-		BlendMode::Multiply => background.blend_rgb(foreground, Color::blend_multiply),
+		// Darken group
 		BlendMode::Darken => background.blend_rgb(foreground, Color::blend_darken),
+		BlendMode::Multiply => background.blend_rgb(foreground, Color::blend_multiply),
 		BlendMode::ColorBurn => background.blend_rgb(foreground, Color::blend_color_burn),
 		BlendMode::LinearBurn => background.blend_rgb(foreground, Color::blend_linear_burn),
 		BlendMode::DarkerColor => background.blend_darker_color(foreground),
-
-		BlendMode::Screen => background.blend_rgb(foreground, Color::blend_screen),
+		// Lighten group
 		BlendMode::Lighten => background.blend_rgb(foreground, Color::blend_lighten),
+		BlendMode::Screen => background.blend_rgb(foreground, Color::blend_screen),
 		BlendMode::ColorDodge => background.blend_rgb(foreground, Color::blend_color_dodge),
 		BlendMode::LinearDodge => background.blend_rgb(foreground, Color::blend_linear_dodge),
 		BlendMode::LighterColor => background.blend_lighter_color(foreground),
-
+		// Contrast group
 		BlendMode::Overlay => foreground.blend_rgb(background, Color::blend_hardlight),
 		BlendMode::SoftLight => background.blend_rgb(foreground, Color::blend_softlight),
 		BlendMode::HardLight => background.blend_rgb(foreground, Color::blend_hardlight),
@@ -477,20 +432,20 @@ fn blend_node(input: (Color, Color), blend_mode: BlendMode, opacity: f64) -> Col
 		BlendMode::LinearLight => background.blend_rgb(foreground, Color::blend_linear_light),
 		BlendMode::PinLight => background.blend_rgb(foreground, Color::blend_pin_light),
 		BlendMode::HardMix => background.blend_rgb(foreground, Color::blend_hard_mix),
-
-		BlendMode::Difference => background.blend_rgb(foreground, Color::blend_exclusion),
+		// Inversion group
+		BlendMode::Difference => background.blend_rgb(foreground, Color::blend_difference),
 		BlendMode::Exclusion => background.blend_rgb(foreground, Color::blend_exclusion),
 		BlendMode::Subtract => background.blend_rgb(foreground, Color::blend_subtract),
 		BlendMode::Divide => background.blend_rgb(foreground, Color::blend_divide),
-
+		// Component group
 		BlendMode::Hue => background.blend_hue(foreground),
 		BlendMode::Saturation => background.blend_saturation(foreground),
 		BlendMode::Color => background.blend_color(foreground),
 		BlendMode::Luminosity => background.blend_luminosity(foreground),
-
-		BlendMode::InsertRed => foreground.with_red(background.r()),
-		BlendMode::InsertGreen => foreground.with_green(background.g()),
-		BlendMode::InsertBlue => foreground.with_blue(background.b()),
+		// Other utility blend modes (hidden from the normal list)
+		BlendMode::Erase => return background.alpha_subtract(foreground),
+		BlendMode::Restore => return background.alpha_add(foreground),
+		BlendMode::MultiplyAlpha => return background.alpha_multiply(foreground),
 	};
 
 	background.alpha_blend(target_color.to_associated_alpha(opacity))

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

@@ -65,6 +65,15 @@ impl Bbox {
 		}
 	}
 
+	pub fn from_transform(transform: DAffine2) -> Self {
+		Self {
+			top_left: transform.transform_point2(DVec2::new(0., 1.)),
+			top_right: transform.transform_point2(DVec2::new(1., 1.)),
+			bottom_left: transform.transform_point2(DVec2::new(0., 0.)),
+			bottom_right: transform.transform_point2(DVec2::new(1., 0.)),
+		}
+	}
+
 	pub fn affine_transform(self, transform: DAffine2) -> Self {
 		Self {
 			top_left: transform.transform_point2(self.top_left),

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

@@ -938,6 +938,30 @@ impl Color {
 			alpha: self.alpha * inv_alpha + other.alpha,
 		}
 	}
+
+	#[inline(always)]
+	pub fn alpha_add(&self, other: Color) -> Self {
+		Self {
+			alpha: (self.alpha + other.alpha).clamp(0., 1.),
+			..*self
+		}
+	}
+
+	#[inline(always)]
+	pub fn alpha_subtract(&self, other: Color) -> Self {
+		Self {
+			alpha: (self.alpha - other.alpha).clamp(0., 1.),
+			..*self
+		}
+	}
+
+	#[inline(always)]
+	pub fn alpha_multiply(&self, other: Color) -> Self {
+		Self {
+			alpha: (self.alpha * other.alpha).clamp(0., 1.),
+			..*self
+		}
+	}
 }
 
 #[test]

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

@@ -67,12 +67,15 @@ where
 
 impl<P: Copy + Pixel> Raster for Image<P> {
 	type Pixel = P;
+	#[inline(always)]
 	fn get_pixel(&self, x: u32, y: u32) -> Option<P> {
 		self.data.get((x + y * self.width) as usize).copied()
 	}
+	#[inline(always)]
 	fn width(&self) -> u32 {
 		self.width
 	}
+	#[inline(always)]
 	fn height(&self) -> u32 {
 		self.height
 	}
@@ -237,6 +240,16 @@ fn map_node<P: Pixel>(input: (u32, u32), data: Vec<P>) -> Image<P> {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct ImageFrame<P: Pixel> {
 	pub image: Image<P>,
+
+	// The transform that maps image space to layer space.
+	//
+	// Image space is unitless [0, 1] for both axes, with x axis positive
+	// going right and y axis positive going down, with the origin lying at
+	// the topleft of the image and (1, 1) lying at the bottom right of the image.
+	//
+	// Layer space has pixels as its units for both axes, with the x axis
+	// positive going right and y axis positive going down, with the origin
+	// being an unspecified quantity.
 	pub transform: DAffine2,
 }
 
@@ -244,6 +257,7 @@ impl<P: Debug + Copy + Pixel> Sample for ImageFrame<P> {
 	type Pixel = P;
 
 	// TODO: Improve sampling logic
+	#[inline(always)]
 	fn sample(&self, pos: DVec2, _area: DVec2) -> Option<Self::Pixel> {
 		let image_size = DVec2::new(self.image.width() as f64, self.image.height() as f64);
 		let pos = (DAffine2::from_scale(image_size) * self.transform.inverse()).transform_point2(pos);

node-graph/gcore/src/vector/brush_stroke.rs

@@ -1,4 +1,5 @@
 use crate::raster::bbox::AxisAlignedBbox;
+use crate::raster::BlendMode;
 use crate::Color;
 
 use dyn_any::{DynAny, StaticType};
@@ -14,6 +15,7 @@ pub struct BrushStyle {
 	pub hardness: f64,
 	pub flow: f64,
 	pub spacing: f64, // Spacing as a fraction of the diameter.
+	pub blend_mode: BlendMode,
 }
 
 impl Default for BrushStyle {
@@ -24,6 +26,7 @@ impl Default for BrushStyle {
 			hardness: 50.,
 			flow: 100.,
 			spacing: 50., // Percentage of diameter.
+			blend_mode: BlendMode::Normal,
 		}
 	}
 }
@@ -41,6 +44,8 @@ impl Hash for BrushStyle {
 #[derive(Clone, Debug, PartialEq, DynAny)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct BrushInputSample {
+	// The position of the sample in layer space, in pixels.
+	// The origin of layer space is not specified.
 	pub position: DVec2,
 	// Future work: pressure, stylus angle, etc.
 }
@@ -63,11 +68,11 @@ pub struct BrushStroke {
 impl BrushStroke {
 	pub fn bounding_box(&self) -> AxisAlignedBbox {
 		let radius = self.style.diameter / 2.;
-		self.trace
+		self.compute_blit_points()
 			.iter()
-			.map(|sample| AxisAlignedBbox {
-				start: sample.position + DVec2::new(-radius, -radius),
-				end: sample.position + DVec2::new(radius, radius),
+			.map(|pos| AxisAlignedBbox {
+				start: *pos + DVec2::new(-radius, -radius),
+				end: *pos + DVec2::new(radius, radius),
 			})
 			.reduce(|a, b| a.union(&b))
 			.unwrap_or(AxisAlignedBbox::ZERO)