Function lerp_graphic

node-graph/nodes/vector/src/vector_nodes.rs:2310–2364

Lerp between two graphics. Solid color and gradient pairings interpolate; all other pairings step at the midpoint.

(a: Option<&List<Graphic>>, b: Option<&List<Graphic>>, time: f64)

	// Lerp between two graphics. Solid color and gradient pairings interpolate; all other pairings step at the midpoint.
	fn lerp_graphic(a: Option<&List<Graphic>>, b: Option<&List<Graphic>>, time: f64) -> Option<List<Graphic>> {
		let transparent = List::new_from_element(Color::TRANSPARENT).into_graphic_list();

		let a = a.filter(|graphic_list| is_paint_present(graphic_list));
		let b = b.filter(|graphic_list| is_paint_present(graphic_list));

		let (a, b) = match (a, b) {
			(None, None) => return None,
			(Some(a), None) => (a, &transparent),
			(None, Some(b)) => (&transparent, b),
			(Some(a), Some(b)) => (a, b),
		};

		// This keeps the gradient metadata attributes
		let gradient_with_stops = |mut gradient_list: List<GradientStops>, stops: GradientStops| -> Graphic {
			if let Some(target) = gradient_list.element_mut(0) {
				*target = stops;
			} else {
				gradient_list.push(Item::new_from_element(stops));
			}
			Graphic::Gradient(gradient_list)
		};

		let graphic = match (a.element(0), b.element(0)) {
			(Some(Graphic::Color(color_list_a)), Some(Graphic::Color(color_list_b))) => color_list_a
				.element(0)
				.zip(color_list_b.element(0))
				.map(|(color_a, color_b)| Graphic::from(color_a.lerp(color_b, time as f32))),
			(Some(Graphic::Color(color_list_a)), Some(Graphic::Gradient(gradient_list_b))) => color_list_a.element(0).zip(gradient_list_b.element(0)).map(|(color_a, stops_b)| {
				let mut solid_to_gradient = stops_b.clone();
				solid_to_gradient.color.iter_mut().for_each(|color| *color = *color_a);
				let stops = solid_to_gradient.lerp(stops_b, time);
				gradient_with_stops(gradient_list_b.clone(), stops)
			}),
			(Some(Graphic::Gradient(gradient_list_a)), Some(Graphic::Color(color_list_b))) => gradient_list_a.element(0).zip(color_list_b.element(0)).map(|(stops_a, color_b)| {
				let mut gradient_to_solid = stops_a.clone();
				gradient_to_solid.color.iter_mut().for_each(|color| *color = *color_b);
				let stops = stops_a.lerp(&gradient_to_solid, time);
				gradient_with_stops(gradient_list_a.clone(), stops)
			}),
			(Some(Graphic::Gradient(gradient_list_a)), Some(Graphic::Gradient(gradient_list_b))) => gradient_list_a.element(0).zip(gradient_list_b.element(0)).map(|(stops_a, stops_b)| {
				let stops = stops_a.lerp(stops_b, time);
				let metadata_source = if time < 0.5 { gradient_list_a } else { gradient_list_b };

				let mut gradient_list = metadata_source.clone();
				gradient_list.set_attribute(ATTR_TRANSFORM, 0, lerp_gradient_transform(gradient_list_a, gradient_list_b, time));

				gradient_with_stops(gradient_list, stops)
			}),
			// Pairings beyond solid colors and gradients (raster, vector, or mixed) can't be interpolated, so step at the midpoint
			_ => return Some(if time < 0.5 { a.clone() } else { b.clone() }),
		};

		graphic.map(List::new_from_element)
	}

	// Preserve original `List<Graphic>` as upstream data so this group layer's nested layers can be edited by the tools.
	let mut graphic_list_content = content.clone().into_graphic_list();