Revert "Remove 'To u32', 'To u64', and 'To f64' number conversion nodes and clean up node type usages"

This reverts commit 316a737874.

editor/src/messages/portfolio/document/node_graph/document_node_definitions.rs

@@ -1016,9 +1016,7 @@ fn static_nodes() -> Vec<DocumentNodeDefinition> {
 					..Default::default()
 				},
 			},
-			description: Cow::Borrowed(
-				"Decomposes the X and Y components of a 2D coordinate.\n\nThe inverse of this node is \"Coordinate Value\", which can have either or both its X and Y exposed as graph inputs.",
-			),
+			description: Cow::Borrowed("TODO"),
 			properties: None,
 		},
 		// TODO: Remove this and just use the proto node definition directly

editor/src/messages/portfolio/document_migration.rs

@@ -722,44 +722,6 @@ pub fn document_migration_upgrades(document: &mut DocumentMessageHandler, reset_
 
 			document.network_interface.replace_reference_name(node_id, network_path, "Sample Polyline".to_string());
 		}
-
-		// Replace "To u32" and "To u64" nodes with "Floor" nodes
-		if reference == "To u32" || reference == "To u64" {
-			let node_definition = resolve_document_node_type("Floor").unwrap();
-			let new_node_template = node_definition.default_node_template();
-			let document_node = new_node_template.document_node;
-			document.network_interface.replace_implementation(node_id, network_path, document_node.implementation.clone());
-			document
-				.network_interface
-				.replace_implementation_metadata(node_id, network_path, new_node_template.persistent_node_metadata);
-
-			let old_inputs = document.network_interface.replace_inputs(node_id, document_node.inputs.clone(), network_path);
-
-			document.network_interface.set_input(&InputConnector::node(*node_id, 0), old_inputs[0].clone(), network_path);
-
-			document.network_interface.replace_reference_name(node_id, network_path, "Floor".to_string());
-			document
-				.network_interface
-				.set_manual_compostion(node_id, network_path, graph_craft::concrete!(graphene_std::Context).into());
-		}
-
-		// Replace the "To f64" node with the "Identity" node
-		if reference == "To f64" {
-			let node_definition = resolve_document_node_type("Identity").unwrap();
-			let new_node_template = node_definition.default_node_template();
-			let document_node = new_node_template.document_node;
-			document.network_interface.replace_implementation(node_id, network_path, document_node.implementation.clone());
-			document
-				.network_interface
-				.replace_implementation_metadata(node_id, network_path, new_node_template.persistent_node_metadata);
-
-			let old_inputs = document.network_interface.replace_inputs(node_id, document_node.inputs.clone(), network_path);
-
-			document.network_interface.set_input(&InputConnector::node(*node_id, 0), old_inputs[0].clone(), network_path);
-
-			document.network_interface.replace_reference_name(node_id, network_path, "Identity".to_string());
-			document.network_interface.set_manual_compostion(node_id, network_path, None);
-		}
 	}
 
 	// Ensure layers are positioned as stacks if they are upstream siblings of another layer

node-graph/gcore/src/debug.rs

@@ -1,16 +1,5 @@
-use crate::GraphicGroupTable;
-use crate::instances::Instances;
-use crate::raster_types::{CPU, GPU, RasterDataTable};
-use crate::vector::VectorDataTable;
+use crate::raster_types::{CPU, RasterDataTable};
 use crate::{Color, Ctx};
-use glam::{DAffine2, DVec2};
-
-#[node_macro::node(category("Debug"), name("Log to Console"))]
-fn log_to_console<T: std::fmt::Debug>(_: impl Ctx, #[implementations(String, bool, f64, u32, u64, DVec2, VectorDataTable, DAffine2, Color, Option<Color>)] value: T) -> T {
-	// KEEP THIS `debug!()` - It acts as the output for the debug node itself
-	log::debug!("{:#?}", value);
-	value
-}
 
 /// Meant for debugging purposes, not general use. Returns the size of the input type in bytes.
 #[node_macro::node(category("Debug"))]
@@ -35,19 +24,3 @@ fn unwrap<T: Default>(_: impl Ctx, #[implementations(Option<f64>, Option<f32>, O
 fn clone<'i, T: Clone + 'i>(_: impl Ctx, #[implementations(&RasterDataTable<CPU>)] value: &'i T) -> T {
 	value.clone()
 }
-
-/// Meant for debugging purposes, not general use. Retrieves the value from a Vec, if it exists, or otherwise the default value for the type.
-#[node_macro::node(category("Debug"))]
-fn index_vector<T: Clone + Default>(_: impl Ctx, #[implementations(Vec<Color>, Vec<Option<Color>>, Vec<f64>, Vec<u64>, Vec<DVec2>)] value: Vec<T>, index: u32) -> T {
-	value.get(index as usize).cloned().unwrap_or_default()
-}
-
-/// Meant for debugging purposes, not general use. Creates a table with a single row containing the input index, if it exists.
-#[node_macro::node(category("Debug"))]
-async fn index_table<T: Clone>(_: impl Ctx, #[implementations(VectorDataTable, RasterDataTable<CPU>, RasterDataTable<GPU>, GraphicGroupTable)] value: Instances<T>, index: u32) -> Instances<T> {
-	let mut result = Instances::default();
-	if let Some(instance) = value.instance_iter().nth(index as usize) {
-		result.push(instance.clone());
-	}
-	result
-}

node-graph/gcore/src/extract_xy.rs

@@ -2,9 +2,7 @@ use crate::Ctx;
 use dyn_any::DynAny;
 use glam::{DVec2, IVec2, UVec2};
 
-/// Obtains the X or Y component of a coordinate point.
-///
-/// The inverse of this node is "Coordinate Value", which can have either or both its X and Y exposed as graph inputs.
+/// Obtain the X or Y component of a coordinate.
 #[node_macro::node(name("Extract XY"), category("Math: Vector"))]
 fn extract_xy<T: Into<DVec2>>(_: impl Ctx, #[implementations(DVec2, IVec2, UVec2)] vector: T, axis: XY) -> f64 {
 	match axis {

node-graph/gcore/src/logic.rs

@@ -1,13 +1,14 @@
-use crate::ArtboardGroupTable;
-use crate::Color;
-use crate::GraphicElement;
-use crate::GraphicGroupTable;
-use crate::gradient::GradientStops;
-use crate::raster_types::{CPU, GPU, RasterDataTable};
 use crate::vector::VectorDataTable;
-use crate::{Context, Ctx};
+use crate::{Color, Context, Ctx};
 use glam::{DAffine2, DVec2};
 
+#[node_macro::node(category("Debug"), name("Log to Console"))]
+fn log_to_console<T: std::fmt::Debug>(_: impl Ctx, #[implementations(String, bool, f64, u32, u64, DVec2, VectorDataTable, DAffine2, Color, Option<Color>)] value: T) -> T {
+	// KEEP THIS `debug!()` - It acts as the output for the debug node itself
+	log::debug!("{:#?}", value);
+	value
+}
+
 #[node_macro::node(category("Text"))]
 fn to_string<T: std::fmt::Debug>(_: impl Ctx, #[implementations(String, bool, f64, u32, u64, DVec2, VectorDataTable, DAffine2)] value: T) -> String {
 	format!("{:?}", value)
@@ -44,42 +45,24 @@ async fn switch<T, C: Send + 'n + Clone>(
 	#[implementations(
 		Context -> String,
 		Context -> bool,
-		Context -> f32,
 		Context -> f64,
 		Context -> u32,
 		Context -> u64,
 		Context -> DVec2,
-		Context -> DAffine2,
-		Context -> ArtboardGroupTable,
 		Context -> VectorDataTable,
-		Context -> GraphicGroupTable,
-		Context -> RasterDataTable<CPU>,
-		Context -> RasterDataTable<GPU>,
-		Context -> GraphicElement,
-		Context -> Color,
-		Context -> Option<Color>,
-		Context -> GradientStops,
+		Context -> DAffine2,
 	)]
 	if_true: impl Node<C, Output = T>,
 	#[expose]
 	#[implementations(
 		Context -> String,
 		Context -> bool,
-		Context -> f32,
 		Context -> f64,
 		Context -> u32,
 		Context -> u64,
 		Context -> DVec2,
-		Context -> DAffine2,
-		Context -> ArtboardGroupTable,
 		Context -> VectorDataTable,
-		Context -> GraphicGroupTable,
-		Context -> RasterDataTable<CPU>,
-		Context -> RasterDataTable<GPU>,
-		Context -> GraphicElement,
-		Context -> Color,
-		Context -> Option<Color>,
-		Context -> GradientStops,
+		Context -> DAffine2,
 	)]
 	if_false: impl Node<C, Output = T>,
 ) -> T {

node-graph/gcore/src/ops.rs

@@ -73,17 +73,9 @@ pub trait Convert<T>: Sized {
 	fn convert(self) -> T;
 }
 
-impl<T: ToString> Convert<String> for T {
-	/// Converts this type into a `String` using its `ToString` implementation.
-	#[inline]
-	fn convert(self) -> String {
-		self.to_string()
-	}
-}
-
 /// Implements the [`Convert`] trait for conversion between the cartesian product of Rust's primitive numeric types.
 macro_rules! impl_convert {
-	($from:ty, $to:ty) => {
+	($from:ty,$to:ty) => {
 		impl Convert<$to> for $from {
 			fn convert(self) -> $to {
 				self as $to

node-graph/gcore/src/transform_nodes.rs

@@ -70,7 +70,6 @@ async fn boundless_footprint<T: 'n + 'static>(
 
 	transform_target.eval(ctx.into_context()).await
 }
-
 #[node_macro::node(category("Debug"))]
 async fn freeze_real_time<T: 'n + 'static>(
 	ctx: impl Ctx + CloneVarArgs + ExtractAll,

node-graph/gcore/src/vector/algorithms/instance.rs

@@ -86,7 +86,6 @@ async fn instance_position(ctx: impl Ctx + ExtractVarArgs) -> DVec2 {
 	Default::default()
 }
 
-// TODO: Make this return a u32 instead of an f64, but we ned to improve math-related compatibility with integer types first.
 #[node_macro::node(category("Instancing"), path(graphene_core::vector))]
 async fn instance_index(ctx: impl Ctx + ExtractIndex) -> f64 {
 	match ctx.try_index() {

node-graph/gmath-nodes/src/lib.rs

@@ -78,12 +78,8 @@ fn math<U: num_traits::float::Float>(
 #[node_macro::node(category("Math: Arithmetic"))]
 fn add<U: Add<T>, T>(
 	_: impl Ctx,
-	/// The left-hand side of the addition operation.
-	#[implementations(f64, f32, u32, DVec2, f64, DVec2)]
-	augend: U,
-	/// The right-hand side of the addition operation.
-	#[implementations(f64, f32, u32, DVec2, DVec2, f64)]
-	addend: T,
+	#[implementations(f64, &f64, f64, &f64, f32, &f32, f32, &f32, u32, &u32, u32, &u32, DVec2, f64, DVec2)] augend: U,
+	#[implementations(f64, f64, &f64, &f64, f32, f32, &f32, &f32, u32, u32, &u32, &u32, DVec2, DVec2, f64)] addend: T,
 ) -> <U as Add<T>>::Output {
 	augend + addend
 }
@@ -92,12 +88,8 @@ fn add<U: Add<T>, T>(
 #[node_macro::node(category("Math: Arithmetic"))]
 fn subtract<U: Sub<T>, T>(
 	_: impl Ctx,
-	/// The left-hand side of the subtraction operation.
-	#[implementations(f64, f32, u32, DVec2, f64, DVec2)]
-	minuend: U,
-	/// The right-hand side of the subtraction operation.
-	#[implementations(f64, f32, u32, DVec2, DVec2, f64)]
-	subtrahend: T,
+	#[implementations(f64, &f64, f64, &f64, f32, &f32, f32, &f32, u32, &u32, u32, &u32, DVec2, f64, DVec2)] minuend: U,
+	#[implementations(f64, f64, &f64, &f64, f32, f32, &f32, &f32, u32, u32, &u32, &u32, DVec2, DVec2, f64)] subtrahend: T,
 ) -> <U as Sub<T>>::Output {
 	minuend - subtrahend
 }
@@ -106,12 +98,9 @@ fn subtract<U: Sub<T>, T>(
 #[node_macro::node(category("Math: Arithmetic"))]
 fn multiply<U: Mul<T>, T>(
 	_: impl Ctx,
-	/// The left-hand side of the multiplication operation.
-	#[implementations(f64, f32, u32, DVec2, f64, DVec2)]
-	multiplier: U,
-	/// The right-hand side of the multiplication operation.
+	#[implementations(f64, &f64, f64, &f64, f32, &f32, f32, &f32, u32, &u32, u32, &u32, DVec2, f64, DVec2)] multiplier: U,
 	#[default(1.)]
-	#[implementations(f64, f32, u32, DVec2, DVec2, f64)]
+	#[implementations(f64, f64, &f64, &f64, f32, f32, &f32, &f32, u32, u32, &u32, &u32, DVec2, DVec2, f64)]
 	multiplicand: T,
 ) -> <U as Mul<T>>::Output {
 	multiplier * multiplicand
@@ -123,10 +112,7 @@ fn multiply<U: Mul<T>, T>(
 #[node_macro::node(category("Math: Arithmetic"))]
 fn divide<U: Div<T> + Default + PartialEq, T: Default + PartialEq>(
 	_: impl Ctx,
-	/// The left-hand side of the division operation.
-	#[implementations(f64, f64, f32, f32, u32, u32, DVec2, DVec2, f64)]
-	numerator: U,
-	/// The right-hand side of the division operation.
+	#[implementations(f64, f64, f32, f32, u32, u32, DVec2, DVec2, f64)] numerator: U,
 	#[default(1.)]
 	#[implementations(f64, f64, f32, f32, u32, u32, DVec2, f64, DVec2)]
 	denominator: T,
@@ -144,12 +130,9 @@ where
 #[node_macro::node(category("Math: Arithmetic"))]
 fn modulo<U: Rem<T, Output: Add<T, Output: Rem<T, Output = U::Output>>>, T: Copy>(
 	_: impl Ctx,
-	/// The left-hand side of the modulo operation.
-	#[implementations(f64, f32, u32, DVec2, DVec2, f64)]
-	numerator: U,
-	/// The right-hand side of the modulo operation.
+	#[implementations(f64, &f64, f64, &f64, f32, &f32, f32, &f32, u32, &u32, u32, &u32, DVec2, DVec2, f64)] numerator: U,
 	#[default(2.)]
-	#[implementations(f64, f32, u32, DVec2, f64, DVec2)]
+	#[implementations(f64, f64, &f64, &f64, f32, f32, &f32, &f32, u32, u32, &u32, &u32, DVec2, f64, DVec2)]
 	modulus: T,
 	always_positive: bool,
 ) -> <U as Rem<T>>::Output {
@@ -160,12 +143,9 @@ fn modulo<U: Rem<T, Output: Add<T, Output: Rem<T, Output = U::Output>>>, T: Copy
 #[node_macro::node(category("Math: Arithmetic"))]
 fn exponent<U: Pow<T>, T>(
 	_: impl Ctx,
-	/// The base number that will be raised to the power.
-	#[implementations(f64, f32, u32)]
-	base: U,
-	/// The power to which the base number will be raised.
+	#[implementations(f64, &f64, f64, &f64, f32, &f32, f32, &f32, u32, &u32, u32, &u32)] base: U,
 	#[default(2.)]
-	#[implementations(f64, f32, u32)]
+	#[implementations(f64, f64, &f64, &f64, f32, f32, &f32, &f32, u32, u32, &u32, &u32)]
 	power: T,
 ) -> <U as num_traits::Pow<T>>::Output {
 	base.pow(power)
@@ -175,11 +155,9 @@ fn exponent<U: Pow<T>, T>(
 #[node_macro::node(category("Math: Arithmetic"))]
 fn root<U: num_traits::float::Float>(
 	_: impl Ctx,
-	/// The number for which the nth root will be calculated.
 	#[default(2.)]
 	#[implementations(f64, f32)]
 	radicand: U,
-	/// The degree of the root to be calculated. Square root is 2, cube root is 3, and so on.
 	#[default(2.)]
 	#[implementations(f64, f32)]
 	degree: U,
@@ -294,6 +272,26 @@ fn random<U: num_traits::float::Float>(
 	result * (max - min) + min
 }
 
+/// Convert a number to an integer of the type u32, which may be the required type for certain node inputs. This will be removed in the future when automatic type conversion is implemented.
+#[node_macro::node(name("To u32"), category("Math: Numeric"))]
+fn to_u32<U: num_traits::float::Float>(_: impl Ctx, #[implementations(f64, f32)] value: U) -> u32 {
+	let value = U::clamp(value, U::from(0.).unwrap(), U::from(u32::MAX as f64).unwrap());
+	value.to_u32().unwrap()
+}
+
+/// Convert a number to an integer of the type u64, which may be the required type for certain node inputs. This will be removed in the future when automatic type conversion is implemented.
+#[node_macro::node(name("To u64"), category("Math: Numeric"))]
+fn to_u64<U: num_traits::float::Float>(_: impl Ctx, #[implementations(f64, f32)] value: U) -> u64 {
+	let value = U::clamp(value, U::from(0.).unwrap(), U::from(u64::MAX as f64).unwrap());
+	value.to_u64().unwrap()
+}
+
+/// Convert an integer to a decimal number of the type f64, which may be the required type for certain node inputs. This will be removed in the future when automatic type conversion is implemented.
+#[node_macro::node(name("To f64"), category("Math: Numeric"))]
+fn to_f64<U: num_traits::int::PrimInt>(_: impl Ctx, #[implementations(u32, u64)] value: U) -> f64 {
+	value.to_f64().unwrap()
+}
+
 /// The rounding function (round) maps an input value to its nearest whole number. Halfway values are rounded away from zero.
 #[node_macro::node(category("Math: Numeric"))]
 fn round<U: num_traits::float::Float>(_: impl Ctx, #[implementations(f64, f32)] value: U) -> U {
@@ -320,29 +318,13 @@ fn absolute_value<U: num_traits::float::Float>(_: impl Ctx, #[implementations(f6
 
 /// The minimum function (min) picks the smaller of two numbers.
 #[node_macro::node(category("Math: Numeric"))]
-fn min<T: std::cmp::PartialOrd>(
-	_: impl Ctx,
-	/// One of the two values, of which the lesser will be returned.
-	#[implementations(f64, f32, u32, &str)]
-	value: T,
-	/// The other of the two values, of which the lesser will be returned.
-	#[implementations(f64, f32, u32, &str)]
-	other_value: T,
-) -> T {
+fn min<T: std::cmp::PartialOrd>(_: impl Ctx, #[implementations(f64, &f64, f32, &f32, u32, &u32, &str)] value: T, #[implementations(f64, &f64, f32, &f32, u32, &u32, &str)] other_value: T) -> T {
 	if value < other_value { value } else { other_value }
 }
 
 /// The maximum function (max) picks the larger of two numbers.
 #[node_macro::node(category("Math: Numeric"))]
-fn max<T: std::cmp::PartialOrd>(
-	_: impl Ctx,
-	/// One of the two values, of which the greater will be returned.
-	#[implementations(f64, f32, u32, &str)]
-	value: T,
-	/// The other of the two values, of which the greater will be returned.
-	#[implementations(f64, f32, u32, &str)]
-	other_value: T,
-) -> T {
+fn max<T: std::cmp::PartialOrd>(_: impl Ctx, #[implementations(f64, &f64, f32, &f32, u32, &u32, &str)] value: T, #[implementations(f64, &f64, f32, &f32, u32, &u32, &str)] other_value: T) -> T {
 	if value > other_value { value } else { other_value }
 }
 
@@ -350,15 +332,9 @@ fn max<T: std::cmp::PartialOrd>(
 #[node_macro::node(category("Math: Numeric"))]
 fn clamp<T: std::cmp::PartialOrd>(
 	_: impl Ctx,
-	/// The value to be clamped, which will be restricted to the range between the minimum and maximum values.
-	#[implementations(f64, f32, u32, &str)]
-	value: T,
-	/// One of the two values that defines the range within which the input value will be clamped. This is conventionally the lesser of the two values.
-	#[implementations(f64, f32, u32, &str)]
-	min: T,
-	/// The other of the two values that defines the range within which the input value will be clamped. This is conventionally the greater of the two values.
-	#[implementations(f64, f32, u32, &str)]
-	max: T,
+	#[implementations(f64, &f64, f32, &f32, u32, &u32, &str)] value: T,
+	#[implementations(f64, &f64, f32, &f32, u32, &u32, &str)] min: T,
+	#[implementations(f64, &f64, f32, &f32, u32, &u32, &str)] max: T,
 ) -> T {
 	let (min, max) = if min < max { (min, max) } else { (max, min) };
 	if value < min {
@@ -372,27 +348,45 @@ fn clamp<T: std::cmp::PartialOrd>(
 
 /// The equality operation (==) compares two values and returns true if they are equal, or false if they are not.
 #[node_macro::node(category("Math: Logic"))]
-fn equals<U: std::cmp::PartialEq<T>, T>(_: impl Ctx, #[implementations(f64, f32, u32, DVec2, &str)] value: T, #[implementations(f64, f32, u32, DVec2, &str)] other_value: U) -> bool {
+fn equals<U: std::cmp::PartialEq<T>, T>(
+	_: impl Ctx,
+	#[implementations(f64, &f64, f32, &f32, u32, &u32, DVec2, &DVec2, &str)] value: T,
+	#[implementations(f64, &f64, f32, &f32, u32, &u32, DVec2, &DVec2, &str)] other_value: U,
+) -> bool {
 	other_value == value
 }
 
 /// The inequality operation (!=) compares two values and returns true if they are not equal, or false if they are.
 #[node_macro::node(category("Math: Logic"))]
-fn not_equals<U: std::cmp::PartialEq<T>, T>(_: impl Ctx, #[implementations(f64, f32, u32, DVec2, &str)] value: T, #[implementations(f64, f32, u32, DVec2, &str)] other_value: U) -> bool {
+fn not_equals<U: std::cmp::PartialEq<T>, T>(
+	_: impl Ctx,
+	#[implementations(f64, &f64, f32, &f32, u32, &u32, DVec2, &DVec2, &str)] value: T,
+	#[implementations(f64, &f64, f32, &f32, u32, &u32, DVec2, &DVec2, &str)] other_value: U,
+) -> bool {
 	other_value != value
 }
 
 /// The less-than operation (<) compares two values and returns true if the first value is less than the second, or false if it is not.
 /// If enabled with "Or Equal", the less-than-or-equal operation (<=) will be used instead.
 #[node_macro::node(category("Math: Logic"))]
-fn less_than<T: std::cmp::PartialOrd<T>>(_: impl Ctx, #[implementations(f64, f32, u32)] value: T, #[implementations(f64, f32, u32)] other_value: T, or_equal: bool) -> bool {
+fn less_than<T: std::cmp::PartialOrd<T>>(
+	_: impl Ctx,
+	#[implementations(f64, &f64, f32, &f32, u32, &u32)] value: T,
+	#[implementations(f64, &f64, f32, &f32, u32, &u32)] other_value: T,
+	or_equal: bool,
+) -> bool {
 	if or_equal { value <= other_value } else { value < other_value }
 }
 
 /// The greater-than operation (>) compares two values and returns true if the first value is greater than the second, or false if it is not.
 /// If enabled with "Or Equal", the greater-than-or-equal operation (>=) will be used instead.
 #[node_macro::node(category("Math: Logic"))]
-fn greater_than<T: std::cmp::PartialOrd<T>>(_: impl Ctx, #[implementations(f64, f32, u32)] value: T, #[implementations(f64, f32, u32)] other_value: T, or_equal: bool) -> bool {
+fn greater_than<T: std::cmp::PartialOrd<T>>(
+	_: impl Ctx,
+	#[implementations(f64, &f64, f32, &f32, u32, &u32)] value: T,
+	#[implementations(f64, &f64, f32, &f32, u32, &u32)] other_value: T,
+	or_equal: bool,
+) -> bool {
 	if or_equal { value >= other_value } else { value > other_value }
 }