raster-nodes: create mod blending_nodes and move assoc nodes

Author: Firestar99

editor/src/messages/portfolio/document_migration.rs

@@ -251,6 +251,27 @@ const NODE_REPLACEMENTS: &[NodeReplacement<'static>] = &[
 		node: graphene_std::vector::auto_tangents::IDENTIFIER,
 		aliases: &["graphene_core::vector::GenerateHandlesNode", "graphene_core::vector::RemoveHandlesNode"],
 	},
+	// raster::blending_nodes
+	NodeReplacement {
+		node: graphene_std::raster_nodes::blending_nodes::blend::IDENTIFIER,
+		aliases: &[
+			"graphene_raster_nodes::adjustments::BlendNode",
+			"graphene_core::raster::adjustments::BlendNode",
+			"graphene_core::raster::BlendNode",
+		],
+	},
+	NodeReplacement {
+		node: graphene_std::raster_nodes::blending_nodes::blend_color_pair::IDENTIFIER,
+		aliases: &["graphene_raster_nodes::adjustments::BlendColorPairNode", "graphene_core::raster::BlendColorPairNode"],
+	},
+	NodeReplacement {
+		node: graphene_std::raster_nodes::blending_nodes::color_overlay::IDENTIFIER,
+		aliases: &[
+			"graphene_raster_nodes::adjustments::ColorOverlayNode",
+			"graphene_core::raster::adjustments::ColorOverlayNode",
+			"graphene_raster_nodes::generate_curves::ColorOverlayNode",
+		],
+	},
 	// raster::adjustments
 	NodeReplacement {
 		node: graphene_std::raster_nodes::adjustments::luminance::IDENTIFIER,
@@ -292,14 +313,6 @@ const NODE_REPLACEMENTS: &[NodeReplacement<'static>] = &[
 		node: graphene_std::raster_nodes::adjustments::threshold::IDENTIFIER,
 		aliases: &["graphene_core::raster::adjustments::ThresholdNode", "graphene_core::raster::ThresholdNode"],
 	},
-	NodeReplacement {
-		node: graphene_std::raster_nodes::adjustments::blend::IDENTIFIER,
-		aliases: &["graphene_core::raster::adjustments::BlendNode", "graphene_core::raster::BlendNode"],
-	},
-	NodeReplacement {
-		node: graphene_std::raster_nodes::adjustments::blend_color_pair::IDENTIFIER,
-		aliases: &["graphene_core::raster::BlendColorPairNode"],
-	},
 	// this node doesn't seem to exist?
 	// (graphene_std::raster_nodes::adjustments::blend_color::IDENTIFIER, &["graphene_core::raster::adjustments::BlendColorsNode","graphene_core::raster::BlendColorsNode"]),
 	NodeReplacement {
@@ -326,10 +339,6 @@ const NODE_REPLACEMENTS: &[NodeReplacement<'static>] = &[
 		node: graphene_std::raster_nodes::adjustments::exposure::IDENTIFIER,
 		aliases: &["graphene_core::raster::adjustments::ExposureNode", "graphene_core::raster::ExposureNode"],
 	},
-	NodeReplacement {
-		node: graphene_std::raster_nodes::adjustments::color_overlay::IDENTIFIER,
-		aliases: &["graphene_core::raster::adjustments::ColorOverlayNode", "graphene_raster_nodes::generate_curves::ColorOverlayNode"],
-	},
 	// raster
 	NodeReplacement {
 		node: graphene_std::raster_nodes::generate_curves::generate_curves::IDENTIFIER,

node-graph/gbrush/src/brush.rs

@@ -14,7 +14,7 @@ use graphene_core::registry::FutureWrapperNode;
 use graphene_core::transform::Transform;
 use graphene_core::value::ClonedNode;
 use graphene_core::{Ctx, Node};
-use graphene_raster_nodes::adjustments::blend_colors;
+use graphene_raster_nodes::blending_nodes::blend_colors;
 use graphene_raster_nodes::std_nodes::{empty_image, extend_image_to_bounds};
 
 #[derive(Clone, Copy, Debug, PartialEq)]

node-graph/graster-nodes/src/adjust.rs

@@ -0,0 +1,35 @@
+use graphene_core::Color;
+use graphene_core::gradient::GradientStops;
+use graphene_core::raster_types::{CPU, RasterDataTable};
+
+pub trait Adjust<P> {
+	fn adjust(&mut self, map_fn: impl Fn(&P) -> P);
+}
+impl Adjust<Color> for Color {
+	fn adjust(&mut self, map_fn: impl Fn(&Color) -> Color) {
+		*self = map_fn(self);
+	}
+}
+impl Adjust<Color> for Option<Color> {
+	fn adjust(&mut self, map_fn: impl Fn(&Color) -> Color) {
+		if let Some(v) = self {
+			*v = map_fn(v)
+		}
+	}
+}
+impl Adjust<Color> for GradientStops {
+	fn adjust(&mut self, map_fn: impl Fn(&Color) -> Color) {
+		for (_pos, c) in self.iter_mut() {
+			*c = map_fn(c);
+		}
+	}
+}
+impl Adjust<Color> for RasterDataTable<CPU> {
+	fn adjust(&mut self, map_fn: impl Fn(&Color) -> Color) {
+		for instance in self.instance_mut_iter() {
+			for c in instance.instance.data_mut().data.iter_mut() {
+				*c = map_fn(c);
+			}
+		}
+	}
+}

node-graph/graster-nodes/src/adjustments.rs

@@ -1,17 +1,13 @@
 #![allow(clippy::too_many_arguments)]
 
+use crate::adjust::Adjust;
 use crate::cubic_spline::CubicSplines;
 use dyn_any::DynAny;
-use graphene_core::Node;
-use graphene_core::blending::BlendMode;
 use graphene_core::color::Color;
-use graphene_core::color::Pixel;
 use graphene_core::context::Ctx;
 use graphene_core::gradient::GradientStops;
-use graphene_core::raster::image::Image;
-use graphene_core::raster_types::{CPU, Raster, RasterDataTable};
+use graphene_core::raster_types::{CPU, RasterDataTable};
 use graphene_core::registry::types::{Angle, Percentage, SignedPercentage};
-use std::cmp::Ordering;
 use std::fmt::Debug;
 
 // TODO: Implement the following:
@@ -137,10 +133,10 @@ fn make_opaque<T: Adjust<Color>>(
 fn brightness_contrast<T: Adjust<Color>>(
 	_: impl Ctx,
 	#[implementations(
-	Color,
-	RasterDataTable<CPU>,
-	GradientStops,
-)]
+		Color,
+		RasterDataTable<CPU>,
+		GradientStops,
+	)]
 	mut input: T,
 	brightness: SignedPercentage,
 	contrast: SignedPercentage,
@@ -447,178 +443,6 @@ async fn threshold<T: Adjust<Color>>(
 	image
 }
 
-trait Blend<P: Pixel> {
-	fn blend(&self, under: &Self, blend_fn: impl Fn(P, P) -> P) -> Self;
-}
-impl Blend<Color> for Color {
-	fn blend(&self, under: &Self, blend_fn: impl Fn(Color, Color) -> Color) -> Self {
-		blend_fn(*self, *under)
-	}
-}
-impl Blend<Color> for Option<Color> {
-	fn blend(&self, under: &Self, blend_fn: impl Fn(Color, Color) -> Color) -> Self {
-		match (self, under) {
-			(Some(a), Some(b)) => Some(blend_fn(*a, *b)),
-			(a, None) => *a,
-			(None, b) => *b,
-		}
-	}
-}
-impl Blend<Color> for RasterDataTable<CPU> {
-	fn blend(&self, under: &Self, blend_fn: impl Fn(Color, Color) -> Color) -> Self {
-		let mut result_table = self.clone();
-
-		for (over, under) in result_table.instance_mut_iter().zip(under.instance_ref_iter()) {
-			let data = over.instance.data.iter().zip(under.instance.data.iter()).map(|(a, b)| blend_fn(*a, *b)).collect();
-
-			*over.instance = Raster::new_cpu(Image {
-				data,
-				width: over.instance.width,
-				height: over.instance.height,
-				base64_string: None,
-			});
-		}
-
-		result_table
-	}
-}
-impl Blend<Color> for GradientStops {
-	fn blend(&self, under: &Self, blend_fn: impl Fn(Color, Color) -> Color) -> Self {
-		let mut combined_stops = self.iter().map(|(position, _)| position).chain(under.iter().map(|(position, _)| position)).collect::<Vec<_>>();
-		combined_stops.dedup_by(|&mut a, &mut b| (a - b).abs() < 1e-6);
-		combined_stops.sort_by(|a, b| a.partial_cmp(b).unwrap_or(Ordering::Equal));
-
-		let stops = combined_stops
-			.into_iter()
-			.map(|&position| {
-				let over_color = self.evaluate(position);
-				let under_color = under.evaluate(position);
-				let color = blend_fn(over_color, under_color);
-				(position, color)
-			})
-			.collect::<Vec<_>>();
-
-		GradientStops::new(stops)
-	}
-}
-
-#[node_macro::node(category("Raster"))]
-async fn blend<T: Blend<Color> + Send>(
-	_: impl Ctx,
-	#[implementations(
-		Color,
-		RasterDataTable<CPU>,
-		GradientStops,
-	)]
-	over: T,
-	#[expose]
-	#[implementations(
-		Color,
-		RasterDataTable<CPU>,
-		GradientStops,
-	)]
-	under: T,
-	blend_mode: BlendMode,
-	#[default(100.)] opacity: Percentage,
-) -> T {
-	over.blend(&under, |a, b| blend_colors(a, b, blend_mode, opacity / 100.))
-}
-
-#[node_macro::node(category(""), skip_impl)]
-fn blend_color_pair<BlendModeNode, OpacityNode>(input: (Color, Color), blend_mode: &'n BlendModeNode, opacity: &'n OpacityNode) -> Color
-where
-	BlendModeNode: Node<'n, (), Output = BlendMode> + 'n,
-	OpacityNode: Node<'n, (), Output = Percentage> + 'n,
-{
-	let blend_mode = blend_mode.eval(());
-	let opacity = opacity.eval(());
-	blend_colors(input.0, input.1, blend_mode, opacity / 100.)
-}
-
-pub fn apply_blend_mode(foreground: Color, background: Color, blend_mode: BlendMode) -> Color {
-	match blend_mode {
-		// Normal group
-		BlendMode::Normal => background.blend_rgb(foreground, Color::blend_normal),
-		// 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),
-		// 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),
-		BlendMode::VividLight => background.blend_rgb(foreground, Color::blend_vivid_light),
-		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),
-		// 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),
-		// Other utility blend modes (hidden from the normal list) - do not have alpha blend
-		_ => panic!("Used blend mode without alpha blend"),
-	}
-}
-
-trait Adjust<P> {
-	fn adjust(&mut self, map_fn: impl Fn(&P) -> P);
-}
-impl Adjust<Color> for Color {
-	fn adjust(&mut self, map_fn: impl Fn(&Color) -> Color) {
-		*self = map_fn(self);
-	}
-}
-impl Adjust<Color> for Option<Color> {
-	fn adjust(&mut self, map_fn: impl Fn(&Color) -> Color) {
-		if let Some(v) = self {
-			*v = map_fn(v)
-		}
-	}
-}
-impl Adjust<Color> for GradientStops {
-	fn adjust(&mut self, map_fn: impl Fn(&Color) -> Color) {
-		for (_pos, c) in self.iter_mut() {
-			*c = map_fn(c);
-		}
-	}
-}
-impl Adjust<Color> for RasterDataTable<CPU> {
-	fn adjust(&mut self, map_fn: impl Fn(&Color) -> Color) {
-		for instance in self.instance_mut_iter() {
-			for c in instance.instance.data_mut().data.iter_mut() {
-				*c = map_fn(c);
-			}
-		}
-	}
-}
-
-#[inline(always)]
-pub fn blend_colors(foreground: Color, background: Color, blend_mode: BlendMode, opacity: f64) -> Color {
-	let target_color = match blend_mode {
-		// Other utility blend modes (hidden from the normal list) - do not have alpha blend
-		BlendMode::Erase => return background.alpha_subtract(foreground),
-		BlendMode::Restore => return background.alpha_add(foreground),
-		BlendMode::MultiplyAlpha => return background.alpha_multiply(foreground),
-		blend_mode => apply_blend_mode(foreground, background, blend_mode),
-	};
-
-	background.alpha_blend(target_color.to_associated_alpha(opacity as f32))
-}
-
 // Aims for interoperable compatibility with:
 // https://www.adobe.com/devnet-apps/photoshop/fileformatashtml/#:~:text=%27grdm%27%20%3D%20Gradient%20Map
 // https://www.adobe.com/devnet-apps/photoshop/fileformatashtml/#:~:text=Gradient%20settings%20(Photoshop%206.0)
@@ -1146,56 +970,3 @@ async fn exposure<T: Adjust<Color>>(
 	});
 	input
 }
-
-#[node_macro::node(category("Raster: Adjustment"))]
-fn color_overlay<T: Adjust<Color>>(
-	_: impl Ctx,
-	#[implementations(
-		Color,
-		RasterDataTable<CPU>,
-		GradientStops,
-	)]
-	mut image: T,
-	#[default(Color::BLACK)] color: Color,
-	blend_mode: BlendMode,
-	#[default(100.)] opacity: Percentage,
-) -> T {
-	let opacity = (opacity as f32 / 100.).clamp(0., 1.);
-
-	image.adjust(|pixel| {
-		let image = pixel.map_rgb(|channel| channel * (1. - opacity));
-
-		// The apply blend mode function divides rgb by the alpha channel for the background. This undoes that.
-		let associated_pixel = Color::from_rgbaf32_unchecked(pixel.r() * pixel.a(), pixel.g() * pixel.a(), pixel.b() * pixel.a(), pixel.a());
-		let overlay = apply_blend_mode(color, associated_pixel, blend_mode).map_rgb(|channel| channel * opacity);
-
-		Color::from_rgbaf32_unchecked(image.r() + overlay.r(), image.g() + overlay.g(), image.b() + overlay.b(), pixel.a())
-	});
-	image
-}
-
-#[cfg(test)]
-mod test {
-	use graphene_core::blending::BlendMode;
-	use graphene_core::color::Color;
-	use graphene_core::raster::image::Image;
-	use graphene_core::raster_types::{Raster, RasterDataTable};
-
-	#[tokio::test]
-	async fn color_overlay_multiply() {
-		let image_color = Color::from_rgbaf32_unchecked(0.7, 0.6, 0.5, 0.4);
-		let image = Image::new(1, 1, image_color);
-
-		// Color { red: 0., green: 1., blue: 0., alpha: 1. }
-		let overlay_color = Color::GREEN;
-
-		// 100% of the output should come from the multiplied value
-		let opacity = 100_f64;
-
-		let result = super::color_overlay((), RasterDataTable::new(Raster::new_cpu(image.clone())), overlay_color, BlendMode::Multiply, opacity);
-		let result = result.instance_ref_iter().next().unwrap().instance;
-
-		// The output should just be the original green and alpha channels (as we multiply them by 1 and other channels by 0)
-		assert_eq!(result.data[0], Color::from_rgbaf32_unchecked(0., image_color.g(), 0., image_color.a()));
-	}
-}