Use f64 not f32 throughout graph; add Vector2 value node (#1618)

* Use doubles in graph * Format .graphite files onto one line * Rename new node to Vector2 * No primary input --------- Co-authored-by: Keavon Chambers <keavon@keavon.com>
2026-09-18 07:48:02 +08:00 · 2024-02-18 22:16:37 +00:00
parent 0e0e347435
commit 229b5dbb20
24 changed files with 477 additions and 445 deletions
--- a/node-graph/gcore/src/ops.rs
+++ b/node-graph/gcore/src/ops.rs
@@ -85,28 +85,28 @@ where
 // Floor
 pub struct FloorNode;
 #[node_macro::node_fn(FloorNode)]
-fn floor(input: f32) -> f32 {
+fn floor(input: f64) -> f64 {
 	input.floor()
 }

 // Ceil
 pub struct CeilingNode;
 #[node_macro::node_fn(CeilingNode)]
-fn ceil(input: f32) -> f32 {
+fn ceil(input: f64) -> f64 {
 	input.ceil()
 }

 // Round
 pub struct RoundNode;
 #[node_macro::node_fn(RoundNode)]
-fn round(input: f32) -> f32 {
+fn round(input: f64) -> f64 {
 	input.round()
 }

 // Absolute Value
 pub struct AbsoluteValue;
 #[node_macro::node_fn(AbsoluteValue)]
-fn abs(input: f32) -> f32 {
+fn abs(input: f64) -> f64 {
 	input.abs()
 }

@@ -122,28 +122,28 @@ fn ln<U: num_traits::float::Float>(first: U, second: U) -> U {
 // Natural Log
 pub struct NaturalLogarithmNode;
 #[node_macro::node_fn(NaturalLogarithmNode)]
-fn ln(input: f32) -> f32 {
+fn ln(input: f64) -> f64 {
 	input.ln()
 }

 // Sine
 pub struct SineNode;
 #[node_macro::node_fn(SineNode)]
-fn ln(input: f32) -> f32 {
+fn ln(input: f64) -> f64 {
 	input.sin()
 }

 // Cosine
 pub struct CosineNode;
 #[node_macro::node_fn(CosineNode)]
-fn ln(input: f32) -> f32 {
+fn ln(input: f64) -> f64 {
 	input.cos()
 }

 // Tangent
 pub struct TangentNode;
 #[node_macro::node_fn(TangentNode)]
-fn ln(input: f32) -> f32 {
+fn ln(input: f64) -> f64 {
 	input.tan()
 }

@@ -192,6 +192,15 @@ where
 	first % second
 }

+pub struct ConstructVector2<X, Y> {
+	x: X,
+	y: Y,
+}
+#[node_macro::node_fn(ConstructVector2)]
+fn construct_vector2(_primary: (), x: f64, y: f64) -> glam::DVec2 {
+	glam::DVec2::new(x, y)
+}
+
 // Size Of
 #[cfg(feature = "std")]
 struct SizeOfNode;
--- a/node-graph/gcore/src/raster/adjustments.rs
+++ b/node-graph/gcore/src/raster/adjustments.rs
@@ -297,17 +297,17 @@ pub struct LevelsNode<InputStart, InputMid, InputEnd, OutputStart, OutputEnd> {

 // From https://stackoverflow.com/questions/39510072/algorithm-for-adjustment-of-image-levels
 #[node_macro::node_fn(LevelsNode)]
-fn levels_node(color: Color, input_start: f32, input_mid: f32, input_end: f32, output_start: f32, output_end: f32) -> Color {
+fn levels_node(color: Color, input_start: f64, input_mid: f64, input_end: f64, output_start: f64, output_end: f64) -> Color {
 	let color = color.to_gamma_srgb();

 	// Input Range (Range: 0-1)
-	let input_shadows = input_start / 100.;
-	let input_midtones = input_mid / 100.;
-	let input_highlights = input_end / 100.;
+	let input_shadows = (input_start / 100.) as f32;
+	let input_midtones = (input_mid / 100.) as f32;
+	let input_highlights = (input_end / 100.) as f32;

 	// Output Range (Range: 0-1)
-	let output_minimums = output_start / 100.;
-	let output_maximums = output_end / 100.;
+	let output_minimums = (output_start / 100.) as f32;
+	let output_maximums = (output_end / 100.) as f32;

 	// Midtones interpolation factor between minimums and maximums (Range: 0-1)
 	let midtones = output_minimums + (output_maximums - output_minimums) * input_midtones;
@@ -354,15 +354,15 @@ pub struct BlackAndWhiteNode<Tint, Reds, Yellows, Greens, Cyans, Blues, Magentas
 // From <https://stackoverflow.com/a/55233732/775283>
 // Works the same for gamma and linear color
 #[node_macro::node_fn(BlackAndWhiteNode)]
-fn black_and_white_color_node(color: Color, tint: Color, reds: f32, yellows: f32, greens: f32, cyans: f32, blues: f32, magentas: f32) -> Color {
+fn black_and_white_color_node(color: Color, tint: Color, reds: f64, yellows: f64, greens: f64, cyans: f64, blues: f64, magentas: f64) -> Color {
 	let color = color.to_gamma_srgb();

-	let reds = reds / 100.;
-	let yellows = yellows / 100.;
-	let greens = greens / 100.;
-	let cyans = cyans / 100.;
-	let blues = blues / 100.;
-	let magentas = magentas / 100.;
+	let reds = reds as f32 / 100.;
+	let yellows = yellows as f32 / 100.;
+	let greens = greens as f32 / 100.;
+	let cyans = cyans as f32 / 100.;
+	let blues = blues as f32 / 100.;
+	let magentas = magentas as f32 / 100.;

 	let gray_base = color.r().min(color.g()).min(color.b());

@@ -400,17 +400,17 @@ pub struct HueSaturationNode<Hue, Saturation, Lightness> {
 }

 #[node_macro::node_fn(HueSaturationNode)]
-fn hue_shift_color_node(color: Color, hue_shift: f32, saturation_shift: f32, lightness_shift: f32) -> Color {
+fn hue_shift_color_node(color: Color, hue_shift: f64, saturation_shift: f64, lightness_shift: f64) -> Color {
 	let color = color.to_gamma_srgb();

 	let [hue, saturation, lightness, alpha] = color.to_hsla();

 	let color = Color::from_hsla(
-		(hue + hue_shift / 360.) % 1.,
+		(hue + hue_shift as f32 / 360.) % 1.,
 		// TODO: Improve the way saturation works (it's slightly off)
-		(saturation + saturation_shift / 100.).clamp(0., 1.),
+		(saturation + saturation_shift as f32 / 100.).clamp(0., 1.),
 		// TODO: Fix the way lightness works (it's very off)
-		(lightness + lightness_shift / 100.).clamp(0., 1.),
+		(lightness + lightness_shift as f32 / 100.).clamp(0., 1.),
 		alpha,
 	);

@@ -450,9 +450,9 @@ pub struct ThresholdNode<MinLuminance, MaxLuminance, LuminanceCalc> {
 }

 #[node_macro::node_fn(ThresholdNode)]
-fn threshold_node(color: Color, min_luminance: f32, max_luminance: f32, luminance_calc: LuminanceCalculation) -> Color {
-	let min_luminance = Color::srgb_to_linear(min_luminance / 100.);
-	let max_luminance = Color::srgb_to_linear(max_luminance / 100.);
+fn threshold_node(color: Color, min_luminance: f64, max_luminance: f64, luminance_calc: LuminanceCalculation) -> Color {
+	let min_luminance = Color::srgb_to_linear(min_luminance as f32 / 100.);
+	let max_luminance = Color::srgb_to_linear(max_luminance as f32 / 100.);

 	let luminance = match luminance_calc {
 		LuminanceCalculation::SRGB => color.luminance_srgb(),
@@ -476,8 +476,8 @@ pub struct BlendNode<BlendMode, Opacity> {
 }

 #[node_macro::node_fn(BlendNode)]
-fn blend_node(input: (Color, Color), blend_mode: BlendMode, opacity: f32) -> Color {
-	blend_colors(input.0, input.1, blend_mode, opacity / 100.)
+fn blend_node(input: (Color, Color), blend_mode: BlendMode, opacity: f64) -> Color {
+	blend_colors(input.0, input.1, blend_mode, opacity as f32 / 100.)
 }

 pub fn apply_blend_mode(foreground: Color, background: Color, blend_mode: BlendMode) -> Color {
@@ -540,8 +540,8 @@ pub struct VibranceNode<Vibrance> {
 // Modified from https://stackoverflow.com/questions/33966121/what-is-the-algorithm-for-vibrance-filters
 // The results of this implementation are very close to correct, but not quite perfect
 #[node_macro::node_fn(VibranceNode)]
-fn vibrance_node(color: Color, vibrance: f32) -> Color {
-	let vibrance = vibrance / 100.;
+fn vibrance_node(color: Color, vibrance: f64) -> Color {
+	let vibrance = vibrance as f32 / 100.;
 	// Slow the effect down by half when it's negative, since artifacts begin appearing past -50%.
 	// So this scales the 0% to -50% range to 0% to -100%.
 	let slowed_vibrance = if vibrance >= 0. { vibrance } else { vibrance * 0.5 };
@@ -811,37 +811,37 @@ pub struct ChannelMixerNode<Monochrome, MonochromeR, MonochromeG, MonochromeB, M
 fn channel_mixer_node(
 	color: Color,
 	monochrome: bool,
-	monochrome_r: f32,
-	monochrome_g: f32,
-	monochrome_b: f32,
-	monochrome_c: f32,
-	red_r: f32,
-	red_g: f32,
-	red_b: f32,
-	red_c: f32,
-	green_r: f32,
-	green_g: f32,
-	green_b: f32,
-	green_c: f32,
-	blue_r: f32,
-	blue_g: f32,
-	blue_b: f32,
-	blue_c: f32,
+	monochrome_r: f64,
+	monochrome_g: f64,
+	monochrome_b: f64,
+	monochrome_c: f64,
+	red_r: f64,
+	red_g: f64,
+	red_b: f64,
+	red_c: f64,
+	green_r: f64,
+	green_g: f64,
+	green_b: f64,
+	green_c: f64,
+	blue_r: f64,
+	blue_g: f64,
+	blue_b: f64,
+	blue_c: f64,
 ) -> Color {
 	let color = color.to_gamma_srgb();

 	let (r, g, b, a) = color.components();

 	let color = if monochrome {
-		let (monochrome_r, monochrome_g, monochrome_b, monochrome_c) = (monochrome_r / 100., monochrome_g / 100., monochrome_b / 100., monochrome_c / 100.);
+		let (monochrome_r, monochrome_g, monochrome_b, monochrome_c) = (monochrome_r as f32 / 100., monochrome_g as f32 / 100., monochrome_b as f32 / 100., monochrome_c as f32 / 100.);

 		let gray = (r * monochrome_r + g * monochrome_g + b * monochrome_b + monochrome_c).clamp(0., 1.);

 		Color::from_rgbaf32_unchecked(gray, gray, gray, a)
 	} else {
-		let (red_r, red_g, red_b, red_c) = (red_r / 100., red_g / 100., red_b / 100., red_c / 100.);
-		let (green_r, green_g, green_b, green_c) = (green_r / 100., green_g / 100., green_b / 100., green_c / 100.);
-		let (blue_r, blue_g, blue_b, blue_c) = (blue_r / 100., blue_g / 100., blue_b / 100., blue_c / 100.);
+		let (red_r, red_g, red_b, red_c) = (red_r as f32 / 100., red_g as f32 / 100., red_b as f32 / 100., red_c as f32 / 100.);
+		let (green_r, green_g, green_b, green_c) = (green_r as f32 / 100., green_g as f32 / 100., green_b as f32 / 100., green_c as f32 / 100.);
+		let (blue_r, blue_g, blue_b, blue_c) = (blue_r as f32 / 100., blue_g as f32 / 100., blue_b as f32 / 100., blue_c as f32 / 100.);

 		let red = (r * red_r + g * red_g + b * red_b + red_c).clamp(0., 1.);
 		let green = (r * green_r + g * green_g + b * green_b + green_c).clamp(0., 1.);
@@ -948,42 +948,42 @@ pub struct SelectiveColorNode<Absolute, RC, RM, RY, RK, YC, YM, YY, YK, GC, GM,
 fn selective_color_node(
 	color: Color,
 	mode: RelativeAbsolute,
-	r_c: f32,
-	r_m: f32,
-	r_y: f32,
-	r_k: f32,
-	y_c: f32,
-	y_m: f32,
-	y_y: f32,
-	y_k: f32,
-	g_c: f32,
-	g_m: f32,
-	g_y: f32,
-	g_k: f32,
-	c_c: f32,
-	c_m: f32,
-	c_y: f32,
-	c_k: f32,
-	b_c: f32,
-	b_m: f32,
-	b_y: f32,
-	b_k: f32,
-	m_c: f32,
-	m_m: f32,
-	m_y: f32,
-	m_k: f32,
-	w_c: f32,
-	w_m: f32,
-	w_y: f32,
-	w_k: f32,
-	n_c: f32,
-	n_m: f32,
-	n_y: f32,
-	n_k: f32,
-	k_c: f32,
-	k_m: f32,
-	k_y: f32,
-	k_k: f32,
+	r_c: f64,
+	r_m: f64,
+	r_y: f64,
+	r_k: f64,
+	y_c: f64,
+	y_m: f64,
+	y_y: f64,
+	y_k: f64,
+	g_c: f64,
+	g_m: f64,
+	g_y: f64,
+	g_k: f64,
+	c_c: f64,
+	c_m: f64,
+	c_y: f64,
+	c_k: f64,
+	b_c: f64,
+	b_m: f64,
+	b_y: f64,
+	b_k: f64,
+	m_c: f64,
+	m_m: f64,
+	m_y: f64,
+	m_k: f64,
+	w_c: f64,
+	w_m: f64,
+	w_y: f64,
+	w_k: f64,
+	n_c: f64,
+	n_m: f64,
+	n_y: f64,
+	n_k: f64,
+	k_c: f64,
+	k_m: f64,
+	k_y: f64,
+	k_k: f64,
 ) -> Color {
 	let color = color.to_gamma_srgb();

@@ -1018,15 +1018,15 @@ fn selective_color_node(
 	};

 	let (sum_r, sum_g, sum_b) = [
-		(SelectiveColorChoice::Reds, (r_c, r_m, r_y, r_k)),
-		(SelectiveColorChoice::Yellows, (y_c, y_m, y_y, y_k)),
-		(SelectiveColorChoice::Greens, (g_c, g_m, g_y, g_k)),
-		(SelectiveColorChoice::Cyans, (c_c, c_m, c_y, c_k)),
-		(SelectiveColorChoice::Blues, (b_c, b_m, b_y, b_k)),
-		(SelectiveColorChoice::Magentas, (m_c, m_m, m_y, m_k)),
-		(SelectiveColorChoice::Whites, (w_c, w_m, w_y, w_k)),
-		(SelectiveColorChoice::Neutrals, (n_c, n_m, n_y, n_k)),
-		(SelectiveColorChoice::Blacks, (k_c, k_m, k_y, k_k)),
+		(SelectiveColorChoice::Reds, (r_c as f32, r_m as f32, r_y as f32, r_k as f32)),
+		(SelectiveColorChoice::Yellows, (y_c as f32, y_m as f32, y_y as f32, y_k as f32)),
+		(SelectiveColorChoice::Greens, (g_c as f32, g_m as f32, g_y as f32, g_k as f32)),
+		(SelectiveColorChoice::Cyans, (c_c as f32, c_m as f32, c_y as f32, c_k as f32)),
+		(SelectiveColorChoice::Blues, (b_c as f32, b_m as f32, b_y as f32, b_k as f32)),
+		(SelectiveColorChoice::Magentas, (m_c as f32, m_m as f32, m_y as f32, m_k as f32)),
+		(SelectiveColorChoice::Whites, (w_c as f32, w_m as f32, w_y as f32, w_k as f32)),
+		(SelectiveColorChoice::Neutrals, (n_c as f32, n_m as f32, n_y as f32, n_k as f32)),
+		(SelectiveColorChoice::Blacks, (k_c as f32, k_m as f32, k_y as f32, k_k as f32)),
 	]
 	.into_iter()
 	.fold((0., 0., 0.), |acc, (color_parameter_group, (c, m, y, k))| {
@@ -1065,21 +1065,21 @@ pub struct OpacityNode<O> {
 }

 #[node_macro::node_fn(OpacityNode)]
-fn opacity_node(color: Color, opacity_multiplier: f32) -> Color {
-	let opacity_multiplier = opacity_multiplier / 100.;
+fn opacity_node(color: Color, opacity_multiplier: f64) -> Color {
+	let opacity_multiplier = opacity_multiplier as f32 / 100.;
 	Color::from_rgbaf32_unchecked(color.r(), color.g(), color.b(), color.a() * opacity_multiplier)
 }

 #[node_macro::node_impl(OpacityNode)]
-fn opacity_node(mut vector_data: VectorData, opacity_multiplier: f32) -> VectorData {
-	let opacity_multiplier = opacity_multiplier / 100.;
+fn opacity_node(mut vector_data: VectorData, opacity_multiplier: f64) -> VectorData {
+	let opacity_multiplier = opacity_multiplier as f32 / 100.;
 	vector_data.alpha_blending.opacity *= opacity_multiplier;
 	vector_data
 }

 #[node_macro::node_impl(OpacityNode)]
-fn opacity_node(mut graphic_group: GraphicGroup, opacity_multiplier: f32) -> GraphicGroup {
-	let opacity_multiplier = opacity_multiplier / 100.;
+fn opacity_node(mut graphic_group: GraphicGroup, opacity_multiplier: f64) -> GraphicGroup {
+	let opacity_multiplier = opacity_multiplier as f32 / 100.;
 	graphic_group.alpha_blending.opacity *= opacity_multiplier;
 	graphic_group
 }
@@ -1115,11 +1115,11 @@ pub struct PosterizeNode<P> {
 // Based on http://www.axiomx.com/posterize.htm
 // This algorithm produces fully accurate output in relation to the industry standard.
 #[node_macro::node_fn(PosterizeNode)]
-fn posterize(color: Color, posterize_value: f32) -> Color {
+fn posterize(color: Color, posterize_value: f64) -> Color {
 	let color = color.to_gamma_srgb();

-	let number_of_areas = posterize_value.recip();
-	let size_of_areas = (posterize_value - 1.).recip();
+	let number_of_areas = posterize_value.recip() as f32;
+	let size_of_areas = (posterize_value - 1.).recip() as f32;
 	let channel = |channel: f32| (channel / number_of_areas).floor() * size_of_areas;
 	let color = color.map_rgb(channel);

@@ -1135,14 +1135,14 @@ pub struct ExposureNode<Exposure, Offset, GammaCorrection> {

 // Based on https://geraldbakker.nl/psnumbers/exposure.html
 #[node_macro::node_fn(ExposureNode)]
-fn exposure(color: Color, exposure: f32, offset: f32, gamma_correction: f32) -> Color {
+fn exposure(color: Color, exposure: f64, offset: f64, gamma_correction: f64) -> Color {
 	let adjusted = color
 		// Exposure
-		.map_rgb(|c: f32| c * 2_f32.powf(exposure))
+		.map_rgb(|c: f32| c * 2_f32.powf(exposure as f32))
 		// Offset
-		.map_rgb(|c: f32| c + offset)
+		.map_rgb(|c: f32| c + offset as f32)
 		// Gamma correction
-		.gamma(gamma_correction);
+		.gamma(gamma_correction as f32);

 	adjusted.map_rgb(|c: f32| c.clamp(0., 1.))
 }
@@ -1224,8 +1224,8 @@ pub struct ColorOverlayNode<Color, BlendMode, Opacity> {

 #[cfg(feature = "alloc")]
 #[node_macro::node_fn(ColorOverlayNode)]
-pub fn color_overlay_node(mut image: ImageFrame<Color>, color: Color, blend_mode: BlendMode, opacity: f32) -> ImageFrame<Color> {
-	let opacity = (opacity / 100.).clamp(0., 1.);
+pub fn color_overlay_node(mut image: ImageFrame<Color>, color: Color, blend_mode: BlendMode, opacity: f64) -> ImageFrame<Color> {
+	let opacity = (opacity as f32 / 100.).clamp(0., 1.);
 	for pixel in &mut image.image.data {
 		let image = pixel.map_rgb(|channel| channel * (1. - opacity));

@@ -1254,7 +1254,7 @@ fn color_overlay_multiply() {
 	let overlay_color = Color::GREEN;

 	// 100% of the output should come from the multiplied value
-	let opacity = 100_f32;
+	let opacity = 100_f64;

 	let result = ColorOverlayNode {
 		color: ClonedNode(overlay_color),
--- a/node-graph/gcore/src/raster/brightness_contrast.rs
+++ b/node-graph/gcore/src/raster/brightness_contrast.rs
@@ -27,10 +27,10 @@ pub struct GenerateBrightnessContrastLegacyMapperNode<Brightness, Contrast> {
 }

 #[node_macro::node_fn(GenerateBrightnessContrastLegacyMapperNode)]
-fn brightness_contrast_legacy_node(_primary: (), brightness: f32, contrast: f32) -> BrightnessContrastLegacyMapperNode {
-	let brightness = brightness / 255.;
+fn brightness_contrast_legacy_node(_primary: (), brightness: f64, contrast: f64) -> BrightnessContrastLegacyMapperNode {
+	let brightness = brightness as f32 / 255.;

-	let contrast = contrast / 100.;
+	let contrast = contrast as f32 / 100.;
 	let contrast = if contrast > 0. { (contrast * core::f32::consts::FRAC_PI_2 - 0.01).tan() } else { contrast };

 	let combined = brightness * contrast + brightness - contrast / 2.;
@@ -68,10 +68,10 @@ pub struct GenerateBrightnessContrastMapperNode<Brightness, Contrast> {
 // TODO: Replace this node implementation with one that reuses the more generalized Curves adjustment node.
 // TODO: It will be necessary to ensure the tests below are faithfully translated in a way that ensures identical results.
 #[node_macro::node_fn(GenerateBrightnessContrastMapperNode)]
-fn brightness_contrast_node(_primary: (), brightness: f32, contrast: f32) -> BrightnessContrastMapperNode {
+fn brightness_contrast_node(_primary: (), brightness: f64, contrast: f64) -> BrightnessContrastMapperNode {
 	// Brightness LUT
 	let brightness_is_negative = brightness < 0.;
-	let brightness = brightness.abs() / 100.;
+	let brightness = brightness.abs() as f32 / 100.;
 	let brightness_curve_points = CubicSplines {
 		x: [0., 130. - brightness * 26., 233. - brightness * 48., 255.].map(|x| x / 255.),
 		y: [0., 130. + brightness * 51., 233. + brightness * 10., 255.].map(|x| x / 255.),
@@ -93,7 +93,7 @@ fn brightness_contrast_node(_primary: (), brightness: f32, contrast: f32) -> Bri
 	}

 	// Contrast LUT
-	let contrast = contrast / 100.;
+	let contrast = contrast as f32 / 100.;
 	let contrast_curve_points = CubicSplines {
 		x: [0., 64., 192., 255.].map(|x| x / 255.),
 		y: [0., 64. - contrast * 30., 192. + contrast * 30., 255.].map(|x| x / 255.),
--- a/node-graph/gcore/src/text.rs
+++ b/node-graph/gcore/src/text.rs
@@ -15,7 +15,7 @@ pub struct TextGeneratorNode<Text, FontName, Size> {
 }

 #[node_fn(TextGeneratorNode)]
-fn generate_text<'a: 'input, T>(editor: EditorApi<'a, T>, text: String, font_name: Font, font_size: f32) -> crate::vector::VectorData {
+fn generate_text<'a: 'input, T>(editor: EditorApi<'a, T>, text: String, font_name: Font, font_size: f64) -> crate::vector::VectorData {
 	let buzz_face = editor.font_cache.get(&font_name).map(|data| load_face(data));
 	crate::vector::VectorData::from_subpaths(to_path(&text, buzz_face, font_size as f64, None))
 }
--- a/node-graph/gcore/src/transform.rs
+++ b/node-graph/gcore/src/transform.rs
@@ -236,7 +236,7 @@ pub(crate) async fn transform_vector_data<Fut: Future>(
 	mut footprint: Footprint,
 	transform_target: impl Node<Footprint, Output = Fut>,
 	translate: DVec2,
-	rotate: f32,
+	rotate: f64,
 	scale: DVec2,
 	shear: DVec2,
 	pivot: DVec2,
@@ -245,7 +245,7 @@ where
 	Fut::Output: TransformMut,
 {
 	// TODO: This is hack and might break for Vector data because the pivot may be incorrect
-	let transform = DAffine2::from_scale_angle_translation(scale, rotate as f64, translate) * DAffine2::from_cols_array(&[1., shear.y, shear.x, 1., 0., 0.]);
+	let transform = DAffine2::from_scale_angle_translation(scale, rotate, translate) * DAffine2::from_cols_array(&[1., shear.y, shear.x, 1., 0., 0.]);
 	if !footprint.ignore_modifications {
 		let pivot_transform = DAffine2::from_translation(pivot);
 		let modification = pivot_transform * transform * pivot_transform.inverse();
--- a/node-graph/gcore/src/vector/generator_nodes.rs
+++ b/node-graph/gcore/src/vector/generator_nodes.rs
@@ -12,7 +12,7 @@ pub struct CircleGenerator<Radius> {
 }

 #[node_macro::node_fn(CircleGenerator)]
-fn circle_generator(_input: (), radius: f32) -> VectorData {
+fn circle_generator(_input: (), radius: f64) -> VectorData {
 	let radius: f64 = radius.into();
 	super::VectorData::from_subpath(Subpath::new_ellipse(DVec2::splat(-radius), DVec2::splat(radius)))
 }
@@ -24,7 +24,7 @@ pub struct EllipseGenerator<RadiusX, RadiusY> {
 }

 #[node_macro::node_fn(EllipseGenerator)]
-fn ellipse_generator(_input: (), radius_x: f32, radius_y: f32) -> VectorData {
+fn ellipse_generator(_input: (), radius_x: f64, radius_y: f64) -> VectorData {
 	let radius = DVec2::new(radius_x as f64, radius_y as f64);
 	let corner1 = -radius;
 	let corner2 = radius;
@@ -38,7 +38,7 @@ pub struct RectangleGenerator<SizeX, SizeY> {
 }

 #[node_macro::node_fn(RectangleGenerator)]
-fn square_generator(_input: (), size_x: f32, size_y: f32) -> VectorData {
+fn square_generator(_input: (), size_x: f64, size_y: f64) -> VectorData {
 	let size = DVec2::new(size_x as f64, size_y as f64);
 	let corner1 = -size / 2.;
 	let corner2 = size / 2.;
@@ -53,7 +53,7 @@ pub struct RegularPolygonGenerator<Points, Radius> {
 }

 #[node_macro::node_fn(RegularPolygonGenerator)]
-fn regular_polygon_generator(_input: (), points: u32, radius: f32) -> VectorData {
+fn regular_polygon_generator(_input: (), points: u32, radius: f64) -> VectorData {
 	let points = points.into();
 	let radius: f64 = (radius * 2.).into();
 	super::VectorData::from_subpath(Subpath::new_regular_polygon(DVec2::splat(-radius), points, radius))
@@ -67,7 +67,7 @@ pub struct StarGenerator<Points, Radius, InnerRadius> {
 }

 #[node_macro::node_fn(StarGenerator)]
-fn star_generator(_input: (), points: u32, radius: f32, inner_radius: f32) -> VectorData {
+fn star_generator(_input: (), points: u32, radius: f64, inner_radius: f64) -> VectorData {
 	let points = points.into();
 	let diameter: f64 = (radius * 2.).into();
 	let inner_diameter = (inner_radius * 2.).into();
--- a/node-graph/gcore/src/vector/style.rs
+++ b/node-graph/gcore/src/vector/style.rs
@@ -307,7 +307,7 @@ pub struct Stroke {
 	pub color: Option<Color>,
 	/// Line thickness
 	pub weight: f64,
-	pub dash_lengths: Vec<f32>,
+	pub dash_lengths: Vec<f64>,
 	pub dash_offset: f64,
 	pub line_cap: LineCap,
 	pub line_join: LineJoin,
@@ -344,7 +344,7 @@ impl Stroke {
 		Self {
 			color: self.color.map(|color| color.lerp(&other.color.unwrap_or(color), time as f32)),
 			weight: self.weight + (other.weight - self.weight) * time,
-			dash_lengths: self.dash_lengths.iter().zip(other.dash_lengths.iter()).map(|(a, b)| a + (b - a) * time as f32).collect(),
+			dash_lengths: self.dash_lengths.iter().zip(other.dash_lengths.iter()).map(|(a, b)| a + (b - a) * time).collect(),
 			dash_offset: self.dash_offset + (other.dash_offset - self.dash_offset) * time,
 			line_cap: if time < 0.5 { self.line_cap } else { other.line_cap },
 			line_join: if time < 0.5 { self.line_join } else { other.line_join },
@@ -420,7 +420,7 @@ impl Stroke {
 		dash_lengths
 			.split(&[',', ' '])
 			.filter(|x| !x.is_empty())
-			.map(str::parse::<f32>)
+			.map(str::parse::<f64>)
 			.collect::<Result<Vec<_>, _>>()
 			.ok()
 			.map(|lengths| {
--- a/node-graph/gcore/src/vector/vector_nodes.rs
+++ b/node-graph/gcore/src/vector/vector_nodes.rs
@@ -59,21 +59,21 @@ pub struct SetStrokeNode<Color, Weight, DashLengths, DashOffset, LineCap, LineJo
 fn set_vector_data_stroke(
 	mut vector_data: VectorData,
 	color: Option<Color>,
-	weight: f32,
-	dash_lengths: Vec<f32>,
-	dash_offset: f32,
+	weight: f64,
+	dash_lengths: Vec<f64>,
+	dash_offset: f64,
 	line_cap: super::style::LineCap,
 	line_join: super::style::LineJoin,
-	miter_limit: f32,
+	miter_limit: f64,
 ) -> VectorData {
 	vector_data.style.set_stroke(Stroke {
 		color,
-		weight: weight as f64,
+		weight,
 		dash_lengths,
-		dash_offset: dash_offset as f64,
+		dash_offset,
 		line_cap,
 		line_join,
-		line_join_miter_limit: miter_limit as f64,
+		line_join_miter_limit: miter_limit,
 	});
 	vector_data
 }
@@ -112,16 +112,16 @@ pub struct CircularRepeatNode<AngleOffset, Radius, Count> {
 }

 #[node_macro::node_fn(CircularRepeatNode)]
-fn circular_repeat_vector_data(mut vector_data: VectorData, angle_offset: f32, radius: f32, count: u32) -> VectorData {
+fn circular_repeat_vector_data(mut vector_data: VectorData, angle_offset: f64, radius: f64, count: u32) -> VectorData {
 	let mut new_subpaths: Vec<Subpath<_>> = Vec::with_capacity(vector_data.subpaths.len() * count as usize);

 	let Some(bounding_box) = vector_data.bounding_box() else { return vector_data };
 	let center = (bounding_box[0] + bounding_box[1]) / 2.;

-	let base_transform = DVec2::new(0., radius as f64) - center;
+	let base_transform = DVec2::new(0., radius) - center;

 	for i in 0..count {
-		let angle = (2. * std::f64::consts::PI / count as f64) * i as f64 + angle_offset.to_radians() as f64;
+		let angle = (2. * std::f64::consts::PI / count as f64) * i as f64 + angle_offset.to_radians();
 		let rotation = DAffine2::from_angle(angle);
 		let transform = DAffine2::from_translation(center) * rotation * DAffine2::from_translation(base_transform);
 		for mut subpath in vector_data.subpaths.clone() {
@@ -189,18 +189,14 @@ async fn copy_to_points<I: GraphicElementRendered + Default + ConcatElement + Tr
 	footprint: Footprint,
 	points: impl Node<Footprint, Output = FP>,
 	instance: impl Node<Footprint, Output = FI>,
-	random_scale_min: f32,
-	random_scale_max: f32,
-	random_scale_bias: f32,
-	random_rotation: f32,
+	random_scale_min: f64,
+	random_scale_max: f64,
+	random_scale_bias: f64,
+	random_rotation: f64,
 ) -> I {
 	let points = self.points.eval(footprint).await;
 	let instance = self.instance.eval(footprint).await;
-	let random_scale_min = random_scale_min as f64;
-	let random_scale_max = random_scale_max as f64;
 	let random_scale_difference = random_scale_max - random_scale_min;
-	let random_scale_bias = random_scale_bias as f64;
-	let random_rotation = random_rotation as f64;

 	let points_list = points.subpaths.iter().flat_map(|s| s.anchors());

@@ -260,17 +256,14 @@ pub struct SamplePoints<VectorData, Spacing, StartOffset, StopOffset, AdaptiveSp
 async fn sample_points<FV: Future<Output = VectorData>, FL: Future<Output = Vec<Vec<f64>>>>(
 	footprint: Footprint,
 	mut vector_data: impl Node<Footprint, Output = FV>,
-	spacing: f32,
-	start_offset: f32,
-	stop_offset: f32,
+	spacing: f64,
+	start_offset: f64,
+	stop_offset: f64,
 	adaptive_spacing: bool,
 	lengths_of_segments_of_subpaths: impl Node<Footprint, Output = FL>,
 ) -> VectorData {
 	let mut vector_data = self.vector_data.eval(footprint).await;
 	let lengths_of_segments_of_subpaths = self.lengths_of_segments_of_subpaths.eval(footprint).await;
-	let spacing = spacing as f64;
-	let start_offset = start_offset as f64;
-	let stop_offset = stop_offset as f64;

 	for (index, subpath) in &mut vector_data.subpaths.iter_mut().enumerate() {
 		if subpath.is_empty() || !spacing.is_finite() || spacing <= 0. {
@@ -326,7 +319,7 @@ pub struct PoissonDiskPoints<SeparationDiskDiameter> {
 }

 #[node_macro::node_fn(PoissonDiskPoints)]
-fn poisson_disk_points(mut vector_data: VectorData, separation_disk_diameter: f32) -> VectorData {
+fn poisson_disk_points(mut vector_data: VectorData, separation_disk_diameter: f64) -> VectorData {
 	let mut rng = rand::rngs::StdRng::seed_from_u64(0);
 	for subpath in &mut vector_data.subpaths.iter_mut() {
 		if subpath.manipulator_groups().len() < 3 {
@@ -335,7 +328,7 @@ fn poisson_disk_points(mut vector_data: VectorData, separation_disk_diameter: f3

 		subpath.apply_transform(vector_data.transform);

-		let points = subpath.poisson_disk_points(separation_disk_diameter as f64, || rng.gen::<f64>()).into_iter().map(|point| point.into());
+		let points = subpath.poisson_disk_points(separation_disk_diameter, || rng.gen::<f64>()).into_iter().map(|point| point.into());
 		*subpath = Subpath::from_anchors(points, false);

 		subpath.apply_transform(vector_data.transform.inverse());
@@ -391,10 +384,8 @@ async fn morph<SourceFuture: Future<Output = VectorData>, TargetFuture: Future<O
 	source: impl Node<Footprint, Output = SourceFuture>,
 	target: impl Node<Footprint, Output = TargetFuture>,
 	start_index: u32,
-	time: f32,
+	time: f64,
 ) -> VectorData {
-	let time = time as f64;
-
 	let mut source = self.source.eval(footprint).await;
 	let mut target = self.target.eval(footprint).await;