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-16 23:08:05 +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;

--- a/node-graph/graph-craft/src/document/value.rs
+++ b/node-graph/graph-craft/src/document/value.rs
@@ -42,7 +42,7 @@ pub enum TaggedValue {
 	VectorData(graphene_core::vector::VectorData),
 	Fill(graphene_core::vector::style::Fill),
 	Stroke(graphene_core::vector::style::Stroke),
-	VecF32(Vec<f32>),
+	VecF64(Vec<f64>),
 	VecDVec2(Vec<DVec2>),
 	RedGreenBlue(graphene_core::raster::RedGreenBlue),
 	NoiseType(graphene_core::raster::NoiseType),
@@ -109,7 +109,7 @@ impl Hash for TaggedValue {
 			Self::VectorData(x) => x.hash(state),
 			Self::Fill(x) => x.hash(state),
 			Self::Stroke(x) => x.hash(state),
-			Self::VecF32(x) => x.iter().for_each(|val| val.to_bits().hash(state)),
+			Self::VecF64(x) => x.iter().for_each(|val| val.to_bits().hash(state)),
 			Self::VecDVec2(x) => x.iter().for_each(|val| val.to_array().iter().for_each(|x| x.to_bits().hash(state))),
 			Self::RedGreenBlue(x) => x.hash(state),
 			Self::NoiseType(x) => x.hash(state),
@@ -183,7 +183,7 @@ impl<'a> TaggedValue {
 			TaggedValue::VectorData(x) => Box::new(x),
 			TaggedValue::Fill(x) => Box::new(x),
 			TaggedValue::Stroke(x) => Box::new(x),
-			TaggedValue::VecF32(x) => Box::new(x),
+			TaggedValue::VecF64(x) => Box::new(x),
 			TaggedValue::VecDVec2(x) => Box::new(x),
 			TaggedValue::RedGreenBlue(x) => Box::new(x),
 			TaggedValue::NoiseType(x) => Box::new(x),
@@ -259,7 +259,7 @@ impl<'a> TaggedValue {
 			TaggedValue::VectorData(_) => concrete!(graphene_core::vector::VectorData),
 			TaggedValue::Fill(_) => concrete!(graphene_core::vector::style::Fill),
 			TaggedValue::Stroke(_) => concrete!(graphene_core::vector::style::Stroke),
-			TaggedValue::VecF32(_) => concrete!(Vec<f32>),
+			TaggedValue::VecF64(_) => concrete!(Vec<f64>),
 			TaggedValue::VecDVec2(_) => concrete!(Vec<DVec2>),
 			TaggedValue::RedGreenBlue(_) => concrete!(graphene_core::raster::RedGreenBlue),
 			TaggedValue::NoiseType(_) => concrete!(graphene_core::raster::NoiseType),
@@ -323,7 +323,7 @@ impl<'a> TaggedValue {
 			x if x == TypeId::of::<graphene_core::vector::VectorData>() => Ok(TaggedValue::VectorData(*downcast(input).unwrap())),
 			x if x == TypeId::of::<graphene_core::vector::style::Fill>() => Ok(TaggedValue::Fill(*downcast(input).unwrap())),
 			x if x == TypeId::of::<graphene_core::vector::style::Stroke>() => Ok(TaggedValue::Stroke(*downcast(input).unwrap())),
-			x if x == TypeId::of::<Vec<f32>>() => Ok(TaggedValue::VecF32(*downcast(input).unwrap())),
+			x if x == TypeId::of::<Vec<f64>>() => Ok(TaggedValue::VecF64(*downcast(input).unwrap())),
 			x if x == TypeId::of::<Vec<DVec2>>() => Ok(TaggedValue::VecDVec2(*downcast(input).unwrap())),
 			x if x == TypeId::of::<graphene_core::raster::RedGreenBlue>() => Ok(TaggedValue::RedGreenBlue(*downcast(input).unwrap())),
 			x if x == TypeId::of::<graphene_core::raster::NoiseType>() => Ok(TaggedValue::NoiseType(*downcast(input).unwrap())),
--- a/node-graph/gstd/src/imaginate.rs
+++ b/node-graph/gstd/src/imaginate.rs
@@ -269,13 +269,13 @@ pub async fn imaginate<'a, P: Pixel>(
 	res: impl Future<Output = Option<DVec2>>,
 	samples: impl Future<Output = u32>,
 	sampling_method: impl Future<Output = ImaginateSamplingMethod>,
-	prompt_guidance: impl Future<Output = f32>,
+	prompt_guidance: impl Future<Output = f64>,
 	prompt: impl Future<Output = String>,
 	negative_prompt: impl Future<Output = String>,
 	adapt_input_image: impl Future<Output = bool>,
-	image_creativity: impl Future<Output = f32>,
+	image_creativity: impl Future<Output = f64>,
 	inpaint: impl Future<Output = bool>,
-	mask_blur: impl Future<Output = f32>,
+	mask_blur: impl Future<Output = f64>,
 	mask_starting_fill: impl Future<Output = ImaginateMaskStartingFill>,
 	improve_faces: impl Future<Output = bool>,
 	tiling: impl Future<Output = bool>,
@@ -336,13 +336,13 @@ async fn imaginate_maybe_fail<'a, P: Pixel, F: Fn(ImaginateStatus)>(
 	res: impl Future<Output = Option<DVec2>>,
 	samples: impl Future<Output = u32>,
 	sampling_method: impl Future<Output = ImaginateSamplingMethod>,
-	prompt_guidance: impl Future<Output = f32>,
+	prompt_guidance: impl Future<Output = f64>,
 	prompt: impl Future<Output = String>,
 	negative_prompt: impl Future<Output = String>,
 	adapt_input_image: impl Future<Output = bool>,
-	image_creativity: impl Future<Output = f32>,
+	image_creativity: impl Future<Output = f64>,
 	_inpaint: impl Future<Output = bool>,
-	_mask_blur: impl Future<Output = f32>,
+	_mask_blur: impl Future<Output = f64>,
 	_mask_starting_fill: impl Future<Output = ImaginateMaskStartingFill>,
 	improve_faces: impl Future<Output = bool>,
 	tiling: impl Future<Output = bool>,
--- a/node-graph/gstd/src/raster.rs
+++ b/node-graph/gstd/src/raster.rs
@@ -529,13 +529,13 @@ generate_imaginate_node! {
 	res: Res: Option<DVec2>,
 	samples: Samples: u32,
 	sampling_method: SamplingMethod: ImaginateSamplingMethod,
-	prompt_guidance: PromptGuidance: f32,
+	prompt_guidance: PromptGuidance: f64,
 	prompt: Prompt: String,
 	negative_prompt: NegativePrompt: String,
 	adapt_input_image: AdaptInputImage: bool,
-	image_creativity: ImageCreativity: f32,
+	image_creativity: ImageCreativity: f64,
 	inpaint: Inpaint: bool,
-	mask_blur: MaskBlur: f32,
+	mask_blur: MaskBlur: f64,
 	mask_starting_fill: MaskStartingFill: ImaginateMaskStartingFill,
 	improve_faces: ImproveFaces: bool,
 	tiling: Tiling: bool,
@@ -596,25 +596,25 @@ fn noise_pattern(
 	_no_primary_input: (),
 	dimensions: UVec2,
 	seed: u32,
-	scale: f32,
+	scale: f64,
 	noise_type: NoiseType,
 	domain_warp_type: DomainWarpType,
-	domain_warp_amplitude: f32,
+	domain_warp_amplitude: f64,
 	fractal_type: FractalType,
 	fractal_octaves: u32,
-	fractal_lacunarity: f32,
-	fractal_gain: f32,
-	fractal_weighted_strength: f32,
-	fractal_ping_pong_strength: f32,
+	fractal_lacunarity: f64,
+	fractal_gain: f64,
+	fractal_weighted_strength: f64,
+	fractal_ping_pong_strength: f64,
 	cellular_distance_function: CellularDistanceFunction,
 	cellular_return_type: CellularReturnType,
-	cellular_jitter: f32,
+	cellular_jitter: f64,
 ) -> graphene_core::raster::ImageFrame<Color> {
 	// All
 	let [width, height] = dimensions.to_array();
 	let mut image = Image::new(width, height, Color::from_luminance(0.5));
 	let mut noise = fastnoise_lite::FastNoiseLite::with_seed(seed as i32);
-	noise.set_frequency(Some(scale / 1000.));
+	noise.set_frequency(Some(scale as f32 / 1000.));

 	// Domain Warp
 	let domain_warp_type = match domain_warp_type {
@@ -625,7 +625,7 @@ fn noise_pattern(
 	};
 	let domain_warp_active = domain_warp_type.is_some();
 	noise.set_domain_warp_type(domain_warp_type);
-	noise.set_domain_warp_amp(Some(domain_warp_amplitude));
+	noise.set_domain_warp_amp(Some(domain_warp_amplitude as f32));

 	// Fractal
 	let noise_type = match noise_type {
@@ -664,10 +664,10 @@ fn noise_pattern(
 	};
 	noise.set_fractal_type(Some(fractal_type));
 	noise.set_fractal_octaves(Some(fractal_octaves as i32));
-	noise.set_fractal_lacunarity(Some(fractal_lacunarity));
-	noise.set_fractal_gain(Some(fractal_gain));
-	noise.set_fractal_weighted_strength(Some(fractal_weighted_strength));
-	noise.set_fractal_ping_pong_strength(Some(fractal_ping_pong_strength));
+	noise.set_fractal_lacunarity(Some(fractal_lacunarity as f32));
+	noise.set_fractal_gain(Some(fractal_gain as f32));
+	noise.set_fractal_weighted_strength(Some(fractal_weighted_strength as f32));
+	noise.set_fractal_ping_pong_strength(Some(fractal_ping_pong_strength as f32));

 	// Cellular
 	let cellular_distance_function = match cellular_distance_function {
@@ -687,7 +687,7 @@ fn noise_pattern(
 	};
 	noise.set_cellular_distance_function(Some(cellular_distance_function));
 	noise.set_cellular_return_type(Some(cellular_return_type));
-	noise.set_cellular_jitter(Some(cellular_jitter));
+	noise.set_cellular_jitter(Some(cellular_jitter as f32));

 	// Calculate the noise for every pixel
 	for y in 0..height {
--- a/node-graph/interpreted-executor/src/node_registry.rs
+++ b/node-graph/interpreted-executor/src/node_registry.rs
@@ -203,6 +203,8 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 		register_node!(graphene_core::ops::AddNode<_>, input: &f32, params: [f32]),
 		register_node!(graphene_core::ops::AddNode<_>, input: f32, params: [&f32]),
 		register_node!(graphene_core::ops::AddNode<_>, input: &f32, params: [&f32]),
+		register_node!(graphene_core::ops::AddNode<_>, input: f64, params: [f64]),
+		register_node!(graphene_core::ops::AddNode<_>, input: glam::DVec2, params: [glam::DVec2]),
 		register_node!(graphene_core::ops::SubtractNode<_>, input: u32, params: [u32]),
 		register_node!(graphene_core::ops::SubtractNode<_>, input: &u32, params: [u32]),
 		register_node!(graphene_core::ops::SubtractNode<_>, input: u32, params: [&u32]),
@@ -211,6 +213,8 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 		register_node!(graphene_core::ops::SubtractNode<_>, input: &f32, params: [f32]),
 		register_node!(graphene_core::ops::SubtractNode<_>, input: f32, params: [&f32]),
 		register_node!(graphene_core::ops::SubtractNode<_>, input: &f32, params: [&f32]),
+		register_node!(graphene_core::ops::SubtractNode<_>, input: f64, params: [f64]),
+		register_node!(graphene_core::ops::SubtractNode<_>, input: glam::DVec2, params: [glam::DVec2]),
 		register_node!(graphene_core::ops::DivideNode<_>, input: u32, params: [u32]),
 		register_node!(graphene_core::ops::DivideNode<_>, input: &u32, params: [u32]),
 		register_node!(graphene_core::ops::DivideNode<_>, input: u32, params: [&u32]),
@@ -219,6 +223,9 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 		register_node!(graphene_core::ops::DivideNode<_>, input: &f32, params: [f32]),
 		register_node!(graphene_core::ops::DivideNode<_>, input: f32, params: [&f32]),
 		register_node!(graphene_core::ops::DivideNode<_>, input: &f32, params: [&f32]),
+		register_node!(graphene_core::ops::DivideNode<_>, input: f64, params: [f64]),
+		register_node!(graphene_core::ops::DivideNode<_>, input: glam::DVec2, params: [f64]),
+		register_node!(graphene_core::ops::DivideNode<_>, input: glam::DVec2, params: [glam::DVec2]),
 		register_node!(graphene_core::ops::MultiplyNode<_>, input: u32, params: [u32]),
 		register_node!(graphene_core::ops::MultiplyNode<_>, input: &u32, params: [u32]),
 		register_node!(graphene_core::ops::MultiplyNode<_>, input: u32, params: [&u32]),
@@ -227,6 +234,9 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 		register_node!(graphene_core::ops::MultiplyNode<_>, input: &f32, params: [f32]),
 		register_node!(graphene_core::ops::MultiplyNode<_>, input: f32, params: [&f32]),
 		register_node!(graphene_core::ops::MultiplyNode<_>, input: &f32, params: [&f32]),
+		register_node!(graphene_core::ops::MultiplyNode<_>, input: f64, params: [f64]),
+		register_node!(graphene_core::ops::MultiplyNode<_>, input: glam::DVec2, params: [f64]),
+		register_node!(graphene_core::ops::MultiplyNode<_>, input: glam::DVec2, params: [glam::DVec2]),
 		register_node!(graphene_core::ops::ExponentNode<_>, input: u32, params: [u32]),
 		register_node!(graphene_core::ops::ExponentNode<_>, input: &u32, params: [u32]),
 		register_node!(graphene_core::ops::ExponentNode<_>, input: u32, params: [&u32]),
@@ -234,32 +244,34 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 		register_node!(graphene_core::ops::ExponentNode<_>, input: f32, params: [f32]),
 		register_node!(graphene_core::ops::ExponentNode<_>, input: &f32, params: [f32]),
 		register_node!(graphene_core::ops::ExponentNode<_>, input: f32, params: [&f32]),
-		register_node!(graphene_core::ops::FloorNode, input: f32, params: []),
-		register_node!(graphene_core::ops::CeilingNode, input: f32, params: []),
-		register_node!(graphene_core::ops::RoundNode, input: f32, params: []),
-		register_node!(graphene_core::ops::AbsoluteValue, input: f32, params: []),
-		register_node!(graphene_core::ops::LogarithmNode<_>, input: f32, params: [f32]),
-		register_node!(graphene_core::ops::NaturalLogarithmNode, input: f32, params: []),
-		register_node!(graphene_core::ops::SineNode, input: f32, params: []),
-		register_node!(graphene_core::ops::CosineNode, input: f32, params: []),
-		register_node!(graphene_core::ops::TangentNode, input: f32, params: []),
+		register_node!(graphene_core::ops::ExponentNode<_>, input: f64, params: [f64]),
+		register_node!(graphene_core::ops::FloorNode, input: f64, params: []),
+		register_node!(graphene_core::ops::CeilingNode, input: f64, params: []),
+		register_node!(graphene_core::ops::RoundNode, input: f64, params: []),
+		register_node!(graphene_core::ops::AbsoluteValue, input: f64, params: []),
+		register_node!(graphene_core::ops::LogarithmNode<_>, input: f64, params: [f64]),
+		register_node!(graphene_core::ops::NaturalLogarithmNode, input: f64, params: []),
+		register_node!(graphene_core::ops::SineNode, input: f64, params: []),
+		register_node!(graphene_core::ops::CosineNode, input: f64, params: []),
+		register_node!(graphene_core::ops::TangentNode, input: f64, params: []),
 		register_node!(graphene_core::ops::MaximumNode<_>, input: u32, params: [u32]),
-		register_node!(graphene_core::ops::MaximumNode<_>, input: f32, params: [f32]),
+		register_node!(graphene_core::ops::MaximumNode<_>, input: f64, params: [f64]),
 		register_node!(graphene_core::ops::MinimumNode<_>, input: u32, params: [u32]),
-		register_node!(graphene_core::ops::MinimumNode<_>, input: f32, params: [f32]),
+		register_node!(graphene_core::ops::MinimumNode<_>, input: f64, params: [f64]),
 		register_node!(graphene_core::ops::EqualsNode<_>, input: u32, params: [u32]),
-		register_node!(graphene_core::ops::EqualsNode<_>, input: f32, params: [f32]),
+		register_node!(graphene_core::ops::EqualsNode<_>, input: f64, params: [f64]),
 		register_node!(graphene_core::ops::ModuloNode<_>, input: u32, params: [u32]),
 		register_node!(graphene_core::ops::ModuloNode<_>, input: &u32, params: [u32]),
 		register_node!(graphene_core::ops::ModuloNode<_>, input: u32, params: [&u32]),
 		register_node!(graphene_core::ops::ModuloNode<_>, input: &u32, params: [&u32]),
-		register_node!(graphene_core::ops::ModuloNode<_>, input: f32, params: [f32]),
-		register_node!(graphene_core::ops::ModuloNode<_>, input: &f32, params: [f32]),
-		register_node!(graphene_core::ops::ModuloNode<_>, input: f32, params: [&f32]),
-		register_node!(graphene_core::ops::ModuloNode<_>, input: &f32, params: [&f32]),
+		register_node!(graphene_core::ops::ModuloNode<_>, input: f64, params: [f64]),
+		register_node!(graphene_core::ops::ModuloNode<_>, input: &f64, params: [f64]),
+		register_node!(graphene_core::ops::ModuloNode<_>, input: f64, params: [&f64]),
+		register_node!(graphene_core::ops::ModuloNode<_>, input: &f64, params: [&f64]),
+		register_node!(graphene_core::ops::ConstructVector2<_, _>, input: (), params: [f64, f64]),
 		register_node!(graphene_core::ops::SomeNode, input: WasmEditorApi, params: []),
 		register_node!(graphene_core::logic::LogToConsoleNode, input: bool, params: []),
-		register_node!(graphene_core::logic::LogToConsoleNode, input: f32, params: []),
+		register_node!(graphene_core::logic::LogToConsoleNode, input: f64, params: []),
 		register_node!(graphene_core::logic::LogToConsoleNode, input: f64, params: []),
 		register_node!(graphene_core::logic::LogToConsoleNode, input: u32, params: []),
 		register_node!(graphene_core::logic::LogToConsoleNode, input: u64, params: []),
@@ -442,12 +454,12 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 		raster_node!(graphene_core::raster::ExtractChannelNode<_>, params: [RedGreenBlue]),
 		raster_node!(graphene_core::raster::ExtractAlphaNode<>, params: []),
 		raster_node!(graphene_core::raster::ExtractOpaqueNode<>, params: []),
-		raster_node!(graphene_core::raster::LevelsNode<_, _, _, _, _>, params: [f32, f32, f32, f32, f32]),
+		raster_node!(graphene_core::raster::LevelsNode<_, _, _, _, _>, params: [f64, f64, f64, f64, f64]),
 		register_node!(graphene_std::image_segmentation::ImageSegmentationNode<_>, input: ImageFrame<Color>, params: [ImageFrame<Color>]),
 		register_node!(graphene_std::image_color_palette::ImageColorPaletteNode<_>, input: ImageFrame<Color>, params: [u32]),
 		register_node!(graphene_core::raster::IndexNode<_>, input: Vec<ImageFrame<Color>>, params: [u32]),
 		register_node!(graphene_core::raster::adjustments::ColorFillNode<_>, input: ImageFrame<Color>, params: [Color]),
-		register_node!(graphene_core::raster::adjustments::ColorOverlayNode<_, _, _>, input: ImageFrame<Color>, params: [Color, BlendMode, f32]),
+		register_node!(graphene_core::raster::adjustments::ColorOverlayNode<_, _, _>, input: ImageFrame<Color>, params: [Color, BlendMode, f64]),
 		register_node!(graphene_core::raster::IndexNode<_>, input: Vec<Color>, params: [u32]),
 		vec![(
 			ProtoNodeIdentifier::new("graphene_core::raster::BlendNode<_, _, _, _>"),
@@ -455,7 +467,7 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 				Box::pin(async move {
 					let image: DowncastBothNode<(), ImageFrame<Color>> = DowncastBothNode::new(args[0].clone());
 					let blend_mode: DowncastBothNode<(), BlendMode> = DowncastBothNode::new(args[1].clone());
-					let opacity: DowncastBothNode<(), f32> = DowncastBothNode::new(args[2].clone());
+					let opacity: DowncastBothNode<(), f64> = DowncastBothNode::new(args[2].clone());
 					let blend_node = graphene_core::raster::BlendNode::new(CopiedNode::new(blend_mode.eval(()).await), CopiedNode::new(opacity.eval(()).await));
 					let node = graphene_std::raster::BlendImageNode::new(image, blend_node);
 					let any: DynAnyNode<ImageFrame<Color>, _, _> = graphene_std::any::DynAnyNode::new(node);
@@ -465,21 +477,21 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 			NodeIOTypes::new(
 				concrete!(ImageFrame<Color>),
 				concrete!(ImageFrame<Color>),
-				vec![fn_type!(ImageFrame<Color>), fn_type!(BlendMode), fn_type!(f32)],
+				vec![fn_type!(ImageFrame<Color>), fn_type!(BlendMode), fn_type!(f64)],
 			),
 		)],
-		raster_node!(graphene_core::raster::BlackAndWhiteNode<_, _, _, _, _, _, _>, params: [Color, f32, f32, f32, f32, f32, f32]),
-		raster_node!(graphene_core::raster::HueSaturationNode<_, _, _>, params: [f32, f32, f32]),
+		raster_node!(graphene_core::raster::BlackAndWhiteNode<_, _, _, _, _, _, _>, params: [Color, f64, f64, f64, f64, f64, f64]),
+		raster_node!(graphene_core::raster::HueSaturationNode<_, _, _>, params: [f64, f64, f64]),
 		raster_node!(graphene_core::raster::InvertRGBNode, params: []),
-		raster_node!(graphene_core::raster::ThresholdNode<_, _, _>, params: [f32, f32, LuminanceCalculation]),
-		raster_node!(graphene_core::raster::VibranceNode<_>, params: [f32]),
+		raster_node!(graphene_core::raster::ThresholdNode<_, _, _>, params: [f64, f64, LuminanceCalculation]),
+		raster_node!(graphene_core::raster::VibranceNode<_>, params: [f64]),
 		raster_node!(
 			graphene_core::raster::ChannelMixerNode<_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _>,
-			params: [bool, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32]
+			params: [bool, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64]
 		),
 		raster_node!(
 			graphene_core::raster::SelectiveColorNode<_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _>,
-			params: [RelativeAbsolute, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32]
+			params: [RelativeAbsolute, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64]
 		),
 		vec![(
 			ProtoNodeIdentifier::new("graphene_core::raster::BrightnessContrastNode<_, _, _>"),
@@ -487,9 +499,9 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 				Box::pin(async move {
 					use graphene_core::raster::brightness_contrast::*;

-					let brightness: DowncastBothNode<(), f32> = DowncastBothNode::new(args[0].clone());
+					let brightness: DowncastBothNode<(), f64> = DowncastBothNode::new(args[0].clone());
 					let brightness = ClonedNode::new(brightness.eval(()).await);
-					let contrast: DowncastBothNode<(), f32> = DowncastBothNode::new(args[1].clone());
+					let contrast: DowncastBothNode<(), f64> = DowncastBothNode::new(args[1].clone());
 					let contrast = ClonedNode::new(contrast.eval(()).await);
 					let use_legacy: DowncastBothNode<(), bool> = DowncastBothNode::new(args[2].clone());

@@ -547,14 +559,14 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 				NodeIOTypes::new(concrete!(ImageFrame<Color>), concrete!(ImageFrame<Color>), vec![fn_type!(graphene_core::raster::curve::Curve)]),
 			),
 		],
-		raster_node!(graphene_core::raster::OpacityNode<_>, params: [f32]),
-		register_node!(graphene_core::raster::OpacityNode<_>, input: VectorData, params: [f32]),
-		register_node!(graphene_core::raster::OpacityNode<_>, input: GraphicGroup, params: [f32]),
+		raster_node!(graphene_core::raster::OpacityNode<_>, params: [f64]),
+		register_node!(graphene_core::raster::OpacityNode<_>, input: VectorData, params: [f64]),
+		register_node!(graphene_core::raster::OpacityNode<_>, input: GraphicGroup, params: [f64]),
 		register_node!(graphene_core::raster::BlendModeNode<_>, input: VectorData, params: [BlendMode]),
 		register_node!(graphene_core::raster::BlendModeNode<_>, input: GraphicGroup, params: [BlendMode]),
 		register_node!(graphene_core::raster::BlendModeNode<_>, input: ImageFrame<Color>, params: [BlendMode]),
-		raster_node!(graphene_core::raster::PosterizeNode<_>, params: [f32]),
-		raster_node!(graphene_core::raster::ExposureNode<_, _, _>, params: [f32, f32, f32]),
+		raster_node!(graphene_core::raster::PosterizeNode<_>, params: [f64]),
+		raster_node!(graphene_core::raster::ExposureNode<_, _, _>, params: [f64, f64, f64]),
 		register_node!(graphene_core::memo::LetNode<_>, input: Option<ImageFrame<Color>>, params: []),
 		register_node!(graphene_core::memo::LetNode<_>, input: Option<WasmEditorApi>, params: []),
 		async_node!(graphene_core::memo::EndLetNode<_, _>, input: WasmEditorApi, output: ImageFrame<Color>, params: [ImageFrame<Color>]),
@@ -628,13 +640,13 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 						fn_type!(Option<DVec2>),
 						fn_type!(u32),
 						fn_type!(ImaginateSamplingMethod),
-						fn_type!(f32),
+						fn_type!(f64),
 						fn_type!(String),
 						fn_type!(String),
 						fn_type!(bool),
-						fn_type!(f32),
+						fn_type!(f64),
 						fn_type!(bool),
-						fn_type!(f32),
+						fn_type!(f64),
 						fn_type!(ImaginateMaskStartingFill),
 						fn_type!(bool),
 						fn_type!(bool),
@@ -657,7 +669,7 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 		async_node!(graphene_core::memo::ImpureMemoNode<_, _, _>, input: Footprint, output: VectorData, fn_params: [Footprint => VectorData]),
 		register_node!(graphene_core::structural::ConsNode<_, _>, input: Image<Color>, params: [&str]),
 		register_node!(graphene_std::raster::ImageFrameNode<_, _>, input: Image<Color>, params: [DAffine2]),
-		register_node!(graphene_std::raster::NoisePatternNode<_, _, _, _, _, _, _, _, _, _, _, _, _, _, _>, input: (), params: [UVec2, u32, f32, NoiseType, DomainWarpType, f32, FractalType, u32, f32, f32, f32, f32, CellularDistanceFunction, CellularReturnType, f32]),
+		register_node!(graphene_std::raster::NoisePatternNode<_, _, _, _, _, _, _, _, _, _, _, _, _, _, _>, input: (), params: [UVec2, u32, f64, NoiseType, DomainWarpType, f64, FractalType, u32, f64, f64, f64, f64, CellularDistanceFunction, CellularReturnType, f64]),
 		#[cfg(feature = "quantization")]
 		register_node!(graphene_std::quantization::GenerateQuantizationNode<_, _>, input: ImageFrame<Color>, params: [u32, u32]),
 		register_node!(graphene_core::quantization::QuantizeNode<_>, input: Color, params: [QuantizationChannels]),
@@ -679,20 +691,20 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 		async_node!(graphene_std::wasm_application_io::RenderNode<_, _, _>, input: WasmEditorApi, output: RenderOutput, fn_params: [Footprint => Option<Color>, () => Arc<WasmSurfaceHandle>]),
 		async_node!(graphene_std::wasm_application_io::RenderNode<_, _, _>, input: WasmEditorApi, output: RenderOutput, fn_params: [() => Vec<Color>, () => Arc<WasmSurfaceHandle>]),
 		async_node!(graphene_std::wasm_application_io::RenderNode<_, _, _>, input: WasmEditorApi, output: RenderOutput, fn_params: [Footprint => Vec<Color>, () => Arc<WasmSurfaceHandle>]),
-		async_node!(graphene_core::transform::TransformNode<_, _, _, _, _, _>, input: Footprint, output: VectorData, fn_params: [Footprint => VectorData, () => DVec2, () => f32, () => DVec2, () => DVec2, () => DVec2]),
-		async_node!(graphene_core::transform::TransformNode<_, _, _, _, _, _>, input: Footprint, output: WasmSurfaceHandleFrame, fn_params: [Footprint => WasmSurfaceHandleFrame, () => DVec2, () => f32, () => DVec2, () => DVec2, () => DVec2]),
-		async_node!(graphene_core::transform::TransformNode<_, _, _, _, _, _>, input: Footprint, output: WasmSurfaceHandleFrame, fn_params: [Footprint => WasmSurfaceHandleFrame, () => DVec2, () => f32, () => DVec2, () => DVec2, () => DVec2]),
-		async_node!(graphene_core::transform::TransformNode<_, _, _, _, _, _>, input: Footprint, output: ImageFrame<Color>, fn_params: [Footprint => ImageFrame<Color>, () => DVec2, () => f32, () => DVec2, () => DVec2, () => DVec2]),
-		async_node!(graphene_core::transform::TransformNode<_, _, _, _, _, _>, input: Footprint, output: GraphicGroup, fn_params: [Footprint => GraphicGroup, () => DVec2, () => f32, () => DVec2, () => DVec2, () => DVec2]),
+		async_node!(graphene_core::transform::TransformNode<_, _, _, _, _, _>, input: Footprint, output: VectorData, fn_params: [Footprint => VectorData, () => DVec2, () => f64, () => DVec2, () => DVec2, () => DVec2]),
+		async_node!(graphene_core::transform::TransformNode<_, _, _, _, _, _>, input: Footprint, output: WasmSurfaceHandleFrame, fn_params: [Footprint => WasmSurfaceHandleFrame, () => DVec2, () => f64, () => DVec2, () => DVec2, () => DVec2]),
+		async_node!(graphene_core::transform::TransformNode<_, _, _, _, _, _>, input: Footprint, output: WasmSurfaceHandleFrame, fn_params: [Footprint => WasmSurfaceHandleFrame, () => DVec2, () => f64, () => DVec2, () => DVec2, () => DVec2]),
+		async_node!(graphene_core::transform::TransformNode<_, _, _, _, _, _>, input: Footprint, output: ImageFrame<Color>, fn_params: [Footprint => ImageFrame<Color>, () => DVec2, () => f64, () => DVec2, () => DVec2, () => DVec2]),
+		async_node!(graphene_core::transform::TransformNode<_, _, _, _, _, _>, input: Footprint, output: GraphicGroup, fn_params: [Footprint => GraphicGroup, () => DVec2, () => f64, () => DVec2, () => DVec2, () => DVec2]),
 		register_node!(graphene_core::transform::SetTransformNode<_>, input: VectorData, params: [VectorData]),
 		register_node!(graphene_core::transform::SetTransformNode<_>, input: ImageFrame<Color>, params: [ImageFrame<Color>]),
 		register_node!(graphene_core::transform::SetTransformNode<_>, input: VectorData, params: [DAffine2]),
 		register_node!(graphene_core::transform::SetTransformNode<_>, input: ImageFrame<Color>, params: [DAffine2]),
 		register_node!(graphene_core::vector::SetFillNode<_, _, _, _, _, _, _>, input: VectorData, params: [graphene_core::vector::style::FillType, Option<graphene_core::Color>, graphene_core::vector::style::GradientType, DVec2, DVec2, DAffine2, Vec<(f64, graphene_core::Color)>]),
-		register_node!(graphene_core::vector::SetStrokeNode<_, _, _, _, _, _, _>, input: VectorData, params: [Option<graphene_core::Color>, f32, Vec<f32>, f32, graphene_core::vector::style::LineCap, graphene_core::vector::style::LineJoin, f32]),
+		register_node!(graphene_core::vector::SetStrokeNode<_, _, _, _, _, _, _>, input: VectorData, params: [Option<graphene_core::Color>, f64, Vec<f64>, f64, graphene_core::vector::style::LineCap, graphene_core::vector::style::LineJoin, f64]),
 		register_node!(graphene_core::vector::RepeatNode<_, _>, input: VectorData, params: [DVec2, u32]),
 		register_node!(graphene_core::vector::BoundingBoxNode, input: VectorData, params: []),
-		register_node!(graphene_core::vector::CircularRepeatNode<_, _, _>, input: VectorData, params: [f32, f32, u32]),
+		register_node!(graphene_core::vector::CircularRepeatNode<_, _, _>, input: VectorData, params: [f64, f64, u32]),
 		vec![(
 			ProtoNodeIdentifier::new("graphene_core::transform::CullNode<_>"),
 			|args| {
@@ -735,18 +747,18 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 		)],
 		register_node!(graphene_std::raster::SampleNode<_>, input: Footprint, params: [ImageFrame<Color>]),
 		register_node!(graphene_std::raster::MandelbrotNode, input: Footprint, params: []),
-		async_node!(graphene_core::vector::CopyToPoints<_, _, _, _, _, _>, input: Footprint, output: VectorData, fn_params: [Footprint => VectorData, Footprint => VectorData, () => f32, () => f32, () => f32, () => f32]),
-		async_node!(graphene_core::vector::CopyToPoints<_, _, _, _, _, _>, input: Footprint, output: GraphicGroup, fn_params: [Footprint => VectorData, Footprint => GraphicGroup, () => f32, () => f32, () => f32, () => f32]),
-		async_node!(graphene_core::vector::SamplePoints<_, _, _, _, _, _>, input: Footprint, output: VectorData, fn_params: [Footprint => VectorData, () => f32, () => f32, () => f32, () => bool, Footprint => Vec<Vec<f64>>]),
-		register_node!(graphene_core::vector::PoissonDiskPoints<_>, input: VectorData, params: [f32]),
+		async_node!(graphene_core::vector::CopyToPoints<_, _, _, _, _, _>, input: Footprint, output: VectorData, fn_params: [Footprint => VectorData, Footprint => VectorData, () => f64, () => f64, () => f64, () => f64]),
+		async_node!(graphene_core::vector::CopyToPoints<_, _, _, _, _, _>, input: Footprint, output: GraphicGroup, fn_params: [Footprint => VectorData, Footprint => GraphicGroup, () => f64, () => f64, () => f64, () => f64]),
+		async_node!(graphene_core::vector::SamplePoints<_, _, _, _, _, _>, input: Footprint, output: VectorData, fn_params: [Footprint => VectorData, () => f64, () => f64, () => f64, () => bool, Footprint => Vec<Vec<f64>>]),
+		register_node!(graphene_core::vector::PoissonDiskPoints<_>, input: VectorData, params: [f64]),
 		register_node!(graphene_core::vector::LengthsOfSegmentsOfSubpaths, input: VectorData, params: []),
 		register_node!(graphene_core::vector::SplinesFromPointsNode, input: VectorData, params: []),
-		async_node!(graphene_core::vector::MorphNode<_, _, _, _>, input: Footprint, output: VectorData, fn_params: [Footprint => VectorData, Footprint => VectorData, () => u32, () => f32]),
-		register_node!(graphene_core::vector::generator_nodes::CircleGenerator<_>, input: (), params: [f32]),
-		register_node!(graphene_core::vector::generator_nodes::EllipseGenerator<_, _>, input: (), params: [f32, f32]),
-		register_node!(graphene_core::vector::generator_nodes::RectangleGenerator<_, _>, input: (), params: [f32, f32]),
-		register_node!(graphene_core::vector::generator_nodes::RegularPolygonGenerator<_, _>, input: (), params: [u32, f32]),
-		register_node!(graphene_core::vector::generator_nodes::StarGenerator<_, _, _>, input: (), params: [u32, f32, f32]),
+		async_node!(graphene_core::vector::MorphNode<_, _, _, _>, input: Footprint, output: VectorData, fn_params: [Footprint => VectorData, Footprint => VectorData, () => u32, () => f64]),
+		register_node!(graphene_core::vector::generator_nodes::CircleGenerator<_>, input: (), params: [f64]),
+		register_node!(graphene_core::vector::generator_nodes::EllipseGenerator<_, _>, input: (), params: [f64, f64]),
+		register_node!(graphene_core::vector::generator_nodes::RectangleGenerator<_, _>, input: (), params: [f64, f64]),
+		register_node!(graphene_core::vector::generator_nodes::RegularPolygonGenerator<_, _>, input: (), params: [u32, f64]),
+		register_node!(graphene_core::vector::generator_nodes::StarGenerator<_, _, _>, input: (), params: [u32, f64, f64]),
 		register_node!(graphene_core::vector::generator_nodes::LineGenerator<_, _>, input: (), params: [DVec2, DVec2]),
 		register_node!(graphene_core::vector::generator_nodes::SplineGenerator<_>, input: (), params: [Vec<DVec2>]),
 		register_node!(
@@ -754,7 +766,7 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 			input: Vec<graphene_core::vector::bezier_rs::Subpath<graphene_core::uuid::ManipulatorGroupId>>,
 			params: [Vec<graphene_core::uuid::ManipulatorGroupId>]
 		),
-		register_node!(graphene_core::text::TextGeneratorNode<_, _, _>, input: WasmEditorApi, params: [String, graphene_core::text::Font, f32]),
+		register_node!(graphene_core::text::TextGeneratorNode<_, _, _>, input: WasmEditorApi, params: [String, graphene_core::text::Font, f64]),
 		register_node!(graphene_std::brush::VectorPointsNode, input: VectorData, params: []),
 		register_node!(graphene_core::ExtractImageFrame, input: WasmEditorApi, params: []),
 		async_node!(graphene_core::ConstructLayerNode<_, _>, input: Footprint, output: GraphicGroup, fn_params: [Footprint => graphene_core::GraphicElement, Footprint => GraphicGroup]),
@@ -780,5 +792,5 @@ pub static NODE_REGISTRY: Lazy<HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes,

 #[cfg(test)]
 mod protograph_testing {
-	// TODO: adde tests testing the node registry
+	// TODO: add tests testing the node registry
 }