Refactor vector data type from document-legacy into node graph (#1057)

Add vector data type

node-graph/gcore/Cargo.toml

@@ -33,6 +33,8 @@ kurbo = { git = "https://github.com/linebender/kurbo.git", features = [
 	"serde",
 ], optional = true }
 glam = { version = "^0.22", default-features = false, features = ["scalar-math", "libm"]}
+rand_chacha = "0.3.1"
+spin = "0.9.2"
 node-macro = {path = "../node-macro"}
 specta.workspace = true
 once_cell = { version = "1.17.0", default-features = false }

node-graph/gcore/src/consts.rs

@@ -0,0 +1,5 @@
+use crate::raster::Color;
+
+// RENDERING
+pub const LAYER_OUTLINE_STROKE_COLOR: Color = Color::BLACK;
+pub const LAYER_OUTLINE_STROKE_WEIGHT: f64 = 1.;

node-graph/gcore/src/lib.rs

@@ -7,6 +7,7 @@ extern crate alloc;
 #[cfg(feature = "log")]
 extern crate log;
 
+pub mod consts;
 pub mod generic;
 pub mod ops;
 pub mod structural;
@@ -22,6 +23,7 @@ pub mod raster;
 pub mod vector;
 
 use core::any::TypeId;
+pub use raster::Color;
 
 // pub trait Node: for<'n> NodeIO<'n> {
 pub trait Node<'i, Input: 'i>: 'i {

node-graph/gcore/src/raster/color.rs

@@ -28,7 +28,7 @@ pub struct Color {
 	alpha: f32,
 }
 
-#[allow(clippy::derive_hash_xor_eq)]
+#[allow(clippy::derived_hash_with_manual_eq)]
 impl Hash for Color {
 	fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
 		self.red.to_bits().hash(state);

node-graph/gcore/src/uuid.rs

@@ -40,3 +40,41 @@ mod u64_string {
 		u64::from_str(&s).map_err(serde::de::Error::custom)
 	}
 }
+
+mod uuid_generation {
+	use core::cell::Cell;
+	use rand_chacha::rand_core::{RngCore, SeedableRng};
+	use rand_chacha::ChaCha20Rng;
+	use spin::Mutex;
+
+	static RNG: Mutex<Option<ChaCha20Rng>> = Mutex::new(None);
+	thread_local! {
+		pub static UUID_SEED: Cell<Option<u64>> = Cell::new(None);
+	}
+
+	pub fn set_uuid_seed(random_seed: u64) {
+		UUID_SEED.with(|seed| seed.set(Some(random_seed)))
+	}
+
+	pub fn generate_uuid() -> u64 {
+		let mut lock = RNG.lock();
+		if lock.is_none() {
+			UUID_SEED.with(|seed| {
+				let random_seed = seed.get().unwrap_or(42);
+				*lock = Some(ChaCha20Rng::seed_from_u64(random_seed));
+			})
+		}
+		lock.as_mut().map(ChaCha20Rng::next_u64).expect("uuid mutex poisoned")
+	}
+}
+
+pub use uuid_generation::*;
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub struct ManipulatorGroupId(u64);
+
+impl bezier_rs::Identifier for ManipulatorGroupId {
+	fn new() -> Self {
+		Self(generate_uuid())
+	}
+}

node-graph/gcore/src/vector/mod.rs

@@ -1,6 +1,16 @@
 pub mod consts;
 pub mod generator_nodes;
-pub mod id_vec;
 pub mod manipulator_group;
 pub mod manipulator_point;
+
+pub mod style;
+pub use style::PathStyle;
+
 pub mod subpath;
+pub use subpath::Subpath;
+
+mod vector_data;
+pub use vector_data::VectorData;
+
+mod id_vec;
+pub use id_vec::IdBackedVec;

node-graph/gcore/src/vector/style.rs

@@ -0,0 +1,520 @@
+//! Contains stylistic options for SVG elements.
+
+use crate::consts::{LAYER_OUTLINE_STROKE_COLOR, LAYER_OUTLINE_STROKE_WEIGHT};
+use crate::Color;
+
+use glam::{DAffine2, DVec2};
+use serde::{Deserialize, Serialize};
+use std::fmt::{self, Display, Write};
+
+/// Precision of the opacity value in digits after the decimal point.
+/// A value of 3 would correspond to a precision of 10^-3.
+const OPACITY_PRECISION: usize = 3;
+
+fn format_opacity(name: &str, opacity: f32) -> String {
+	if (opacity - 1.).abs() > 10_f32.powi(-(OPACITY_PRECISION as i32)) {
+		format!(r#" {}-opacity="{:.precision$}""#, name, opacity, precision = OPACITY_PRECISION)
+	} else {
+		String::new()
+	}
+}
+
+#[derive(Default, PartialEq, Eq, Clone, Copy, Debug, Hash, Serialize, Deserialize, specta::Type)]
+pub enum GradientType {
+	#[default]
+	Linear,
+	Radial,
+}
+
+/// A gradient fill.
+///
+/// Contains the start and end points, along with the colors at varying points along the length.
+#[repr(C)]
+#[derive(Debug, PartialEq, Default, Serialize, Deserialize, specta::Type)]
+pub struct Gradient {
+	pub start: DVec2,
+	pub end: DVec2,
+	pub transform: DAffine2,
+	pub positions: Vec<(f64, Option<Color>)>,
+	uuid: u64,
+	pub gradient_type: GradientType,
+}
+impl Gradient {
+	/// Constructs a new gradient with the colors at 0 and 1 specified.
+	pub fn new(start: DVec2, start_color: Color, end: DVec2, end_color: Color, transform: DAffine2, uuid: u64, gradient_type: GradientType) -> Self {
+		Gradient {
+			start,
+			end,
+			positions: vec![(0., Some(start_color)), (1., Some(end_color))],
+			transform,
+			uuid,
+			gradient_type,
+		}
+	}
+
+	/// Adds the gradient def with the uuid specified
+	fn render_defs(&self, svg_defs: &mut String, multiplied_transform: DAffine2, bounds: [DVec2; 2], transformed_bounds: [DVec2; 2]) {
+		let bound_transform = DAffine2::from_scale_angle_translation(bounds[1] - bounds[0], 0., bounds[0]);
+		let transformed_bound_transform = DAffine2::from_scale_angle_translation(transformed_bounds[1] - transformed_bounds[0], 0., transformed_bounds[0]);
+		let updated_transform = multiplied_transform * bound_transform;
+
+		let positions = self
+			.positions
+			.iter()
+			.filter_map(|(pos, color)| color.map(|color| (pos, color)))
+			.map(|(position, color)| format!(r##"<stop offset="{}" stop-color="#{}" />"##, position, color.rgba_hex()))
+			.collect::<String>();
+
+		let mod_gradient = transformed_bound_transform.inverse();
+		let mod_points = mod_gradient.inverse() * transformed_bound_transform.inverse() * updated_transform;
+
+		let start = mod_points.transform_point2(self.start);
+		let end = mod_points.transform_point2(self.end);
+
+		let transform = mod_gradient
+			.to_cols_array()
+			.iter()
+			.enumerate()
+			.map(|(i, entry)| entry.to_string() + if i == 5 { "" } else { "," })
+			.collect::<String>();
+
+		match self.gradient_type {
+			GradientType::Linear => {
+				let _ = write!(
+					svg_defs,
+					r#"<linearGradient id="{}" x1="{}" x2="{}" y1="{}" y2="{}" gradientTransform="matrix({})">{}</linearGradient>"#,
+					self.uuid, start.x, end.x, start.y, end.y, transform, positions
+				);
+			}
+			GradientType::Radial => {
+				let radius = (f64::powi(start.x - end.x, 2) + f64::powi(start.y - end.y, 2)).sqrt();
+				let _ = write!(
+					svg_defs,
+					r#"<radialGradient id="{}" cx="{}" cy="{}" r="{}" gradientTransform="matrix({})">{}</radialGradient>"#,
+					self.uuid, start.x, start.y, radius, transform, positions
+				);
+			}
+		}
+	}
+
+	/// Insert a stop into the gradient, the index if successful
+	pub fn insert_stop(&mut self, mouse: DVec2, transform: DAffine2) -> Option<usize> {
+		// Transform the start and end positions to the same coordinate space as the mouse.
+		let (start, end) = (transform.transform_point2(self.start), transform.transform_point2(self.end));
+
+		// Calculate the new position by finding the closest point on the line
+		let new_position = ((end - start).angle_between(mouse - start)).cos() * start.distance(mouse) / start.distance(end);
+
+		// Don't insert point past end of line
+		if !(0. ..=1.).contains(&new_position) {
+			return None;
+		}
+
+		// Compute the color of the inserted stop
+		let get_color = |index: usize, time: f64| match (self.positions[index].1, self.positions.get(index + 1).and_then(|x| x.1)) {
+			// Lerp between the nearest colours if applicable
+			(Some(a), Some(b)) => a.lerp(
+				b,
+				((time - self.positions[index].0) / self.positions.get(index + 1).map(|end| end.0 - self.positions[index].0).unwrap_or_default()) as f32,
+			),
+			// Use the start or the end colour if applicable
+			(Some(v), _) | (_, Some(v)) => Some(v),
+			_ => Some(Color::WHITE),
+		};
+
+		// Compute the correct index to keep the positions in order
+		let mut index = 0;
+		while self.positions.len() > index && self.positions[index].0 <= new_position {
+			index += 1;
+		}
+
+		let new_color = get_color(index - 1, new_position);
+
+		// Insert the new stop
+		self.positions.insert(index, (new_position, new_color));
+
+		Some(index)
+	}
+}
+
+impl Clone for Gradient {
+	/// Clones the gradient, with the cloned gradient having the new uuid.
+	/// If multiple gradients have the same id then only one gradient will be shown in the final svg output.
+	fn clone(&self) -> Self {
+		Self {
+			start: self.start,
+			end: self.end,
+			transform: self.transform,
+			positions: self.positions.clone(),
+			uuid: crate::uuid::generate_uuid(),
+			gradient_type: self.gradient_type,
+		}
+	}
+}
+
+/// Describes the fill of a layer.
+///
+/// Can be None, a solid [Color], a linear [Gradient], a radial [Gradient] or potentially some sort of image or pattern in the future
+#[repr(C)]
+#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize, specta::Type)]
+pub enum Fill {
+	#[default]
+	None,
+	Solid(Color),
+	Gradient(Gradient),
+}
+
+impl Fill {
+	/// Construct a new solid [Fill] from a [Color].
+	pub fn solid(color: Color) -> Self {
+		Self::Solid(color)
+	}
+
+	/// Evaluate the color at some point on the fill. Doesn't currently work for Gradient.
+	pub fn color(&self) -> Color {
+		match self {
+			Self::None => Color::BLACK,
+			Self::Solid(color) => *color,
+			// TODO: Should correctly sample the gradient
+			Self::Gradient(Gradient { positions, .. }) => positions[0].1.unwrap_or(Color::BLACK),
+		}
+	}
+
+	/// Renders the fill, adding necessary defs.
+	pub fn render(&self, svg_defs: &mut String, multiplied_transform: DAffine2, bounds: [DVec2; 2], transformed_bounds: [DVec2; 2]) -> String {
+		match self {
+			Self::None => r#" fill="none""#.to_string(),
+			Self::Solid(color) => format!(r##" fill="#{}"{}"##, color.rgb_hex(), format_opacity("fill", color.a())),
+			Self::Gradient(gradient) => {
+				gradient.render_defs(svg_defs, multiplied_transform, bounds, transformed_bounds);
+				format!(r##" fill="url('#{}')""##, gradient.uuid)
+			}
+		}
+	}
+
+	/// Check if the fill is not none
+	pub fn is_some(&self) -> bool {
+		*self != Self::None
+	}
+
+	/// Extract a gradient from the fill
+	pub fn as_gradient(&self) -> Option<&Gradient> {
+		if let Self::Gradient(gradient) = self {
+			Some(gradient)
+		} else {
+			None
+		}
+	}
+}
+
+/// The stroke (outline) style of an SVG element.
+#[repr(C)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, specta::Type)]
+pub enum LineCap {
+	Butt,
+	Round,
+	Square,
+}
+
+impl Display for LineCap {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		match self {
+			LineCap::Butt => write!(f, "butt"),
+			LineCap::Round => write!(f, "round"),
+			LineCap::Square => write!(f, "square"),
+		}
+	}
+}
+
+#[repr(C)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, specta::Type)]
+pub enum LineJoin {
+	Miter,
+	Bevel,
+	Round,
+}
+
+impl Display for LineJoin {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		match self {
+			LineJoin::Bevel => write!(f, "bevel"),
+			LineJoin::Miter => write!(f, "miter"),
+			LineJoin::Round => write!(f, "round"),
+		}
+	}
+}
+
+#[repr(C)]
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, specta::Type)]
+pub struct Stroke {
+	/// Stroke color
+	color: Option<Color>,
+	/// Line thickness
+	weight: f64,
+	dash_lengths: Vec<f32>,
+	dash_offset: f64,
+	line_cap: LineCap,
+	line_join: LineJoin,
+	line_join_miter_limit: f64,
+}
+
+impl Stroke {
+	pub fn new(color: Color, weight: f64) -> Self {
+		Self {
+			color: Some(color),
+			weight,
+			..Default::default()
+		}
+	}
+
+	/// Get the current stroke color.
+	pub fn color(&self) -> Option<Color> {
+		self.color
+	}
+
+	/// Get the current stroke weight.
+	pub fn weight(&self) -> f64 {
+		self.weight
+	}
+
+	pub fn dash_lengths(&self) -> String {
+		self.dash_lengths.iter().map(|v| v.to_string()).collect::<Vec<_>>().join(", ")
+	}
+
+	pub fn dash_offset(&self) -> f64 {
+		self.dash_offset
+	}
+
+	pub fn line_cap_index(&self) -> u32 {
+		self.line_cap as u32
+	}
+
+	pub fn line_join_index(&self) -> u32 {
+		self.line_join as u32
+	}
+
+	pub fn line_join_miter_limit(&self) -> f32 {
+		self.line_join_miter_limit as f32
+	}
+
+	/// Provide the SVG attributes for the stroke.
+	pub fn render(&self) -> String {
+		if let Some(color) = self.color {
+			format!(
+				r##" stroke="#{}"{} stroke-width="{}" stroke-dasharray="{}" stroke-dashoffset="{}" stroke-linecap="{}" stroke-linejoin="{}" stroke-miterlimit="{}" "##,
+				color.rgb_hex(),
+				format_opacity("stroke", color.a()),
+				self.weight,
+				self.dash_lengths(),
+				self.dash_offset,
+				self.line_cap,
+				self.line_join,
+				self.line_join_miter_limit
+			)
+		} else {
+			String::new()
+		}
+	}
+
+	pub fn with_color(mut self, color: &Option<Color>) -> Option<Self> {
+		self.color = *color;
+
+		Some(self)
+	}
+
+	pub fn with_weight(mut self, weight: f64) -> Self {
+		self.weight = weight;
+		self
+	}
+
+	pub fn with_dash_lengths(mut self, dash_lengths: &str) -> Option<Self> {
+		dash_lengths
+			.split(&[',', ' '])
+			.filter(|x| !x.is_empty())
+			.map(str::parse::<f32>)
+			.collect::<Result<Vec<_>, _>>()
+			.ok()
+			.map(|lengths| {
+				self.dash_lengths = lengths;
+				self
+			})
+	}
+
+	pub fn with_dash_offset(mut self, dash_offset: f64) -> Self {
+		self.dash_offset = dash_offset;
+		self
+	}
+
+	pub fn with_line_cap(mut self, line_cap: LineCap) -> Self {
+		self.line_cap = line_cap;
+		self
+	}
+
+	pub fn with_line_join(mut self, line_join: LineJoin) -> Self {
+		self.line_join = line_join;
+		self
+	}
+
+	pub fn with_line_join_miter_limit(mut self, limit: f64) -> Self {
+		self.line_join_miter_limit = limit;
+		self
+	}
+}
+
+// Having an alpha of 1 to start with leads to a better experience with the properties panel
+impl Default for Stroke {
+	fn default() -> Self {
+		Self {
+			weight: 0.,
+			color: Some(Color::from_rgba8(0, 0, 0, 255)),
+			dash_lengths: vec![0.],
+			dash_offset: 0.,
+			line_cap: LineCap::Butt,
+			line_join: LineJoin::Miter,
+			line_join_miter_limit: 4.,
+		}
+	}
+}
+
+#[repr(C)]
+#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, specta::Type)]
+pub struct PathStyle {
+	stroke: Option<Stroke>,
+	fill: Fill,
+}
+
+impl PathStyle {
+	pub fn new(stroke: Option<Stroke>, fill: Fill) -> Self {
+		Self { stroke, fill }
+	}
+
+	/// Get the current path's [Fill].
+	///
+	/// # Example
+	/// ```
+	/// # use graphene_core::vector::style::{Fill, PathStyle};
+	/// # use graphene_core::raster::color::Color;
+	/// let fill = Fill::solid(Color::RED);
+	/// let style = PathStyle::new(None, fill.clone());
+	///
+	/// assert_eq!(*style.fill(), fill);
+	/// ```
+	pub fn fill(&self) -> &Fill {
+		&self.fill
+	}
+
+	/// Get the current path's [Stroke].
+	///
+	/// # Example
+	/// ```
+	/// # use graphene_core::vector::style::{Fill, Stroke, PathStyle};
+	/// # use graphene_core::raster::color::Color;
+	/// let stroke = Stroke::new(Color::GREEN, 42.);
+	/// let style = PathStyle::new(Some(stroke.clone()), Fill::None);
+	///
+	/// assert_eq!(style.stroke(), Some(stroke));
+	/// ```
+	pub fn stroke(&self) -> Option<Stroke> {
+		self.stroke.clone()
+	}
+
+	/// Replace the path's [Fill] with a provided one.
+	///
+	/// # Example
+	/// ```
+	/// # use graphene_core::vector::style::{Fill, PathStyle};
+	/// # use graphene_core::raster::color::Color;
+	/// let mut style = PathStyle::default();
+	///
+	/// assert_eq!(*style.fill(), Fill::None);
+	///
+	/// let fill = Fill::solid(Color::RED);
+	/// style.set_fill(fill.clone());
+	///
+	/// assert_eq!(*style.fill(), fill);
+	/// ```
+	pub fn set_fill(&mut self, fill: Fill) {
+		self.fill = fill;
+	}
+
+	/// Replace the path's [Stroke] with a provided one.
+	///
+	/// # Example
+	/// ```
+	/// # use graphene_core::vector::style::{Stroke, PathStyle};
+	/// # use graphene_core::raster::color::Color;
+	/// let mut style = PathStyle::default();
+	///
+	/// assert_eq!(style.stroke(), None);
+	///
+	/// let stroke = Stroke::new(Color::GREEN, 42.);
+	/// style.set_stroke(stroke.clone());
+	///
+	/// assert_eq!(style.stroke(), Some(stroke));
+	/// ```
+	pub fn set_stroke(&mut self, stroke: Stroke) {
+		self.stroke = Some(stroke);
+	}
+
+	/// Set the path's fill to None.
+	///
+	/// # Example
+	/// ```
+	/// # use graphene_core::vector::style::{Fill, PathStyle};
+	/// # use graphene_core::raster::color::Color;
+	/// let mut style = PathStyle::new(None, Fill::Solid(Color::RED));
+	///
+	/// assert!(style.fill().is_some());
+	///
+	/// style.clear_fill();
+	///
+	/// assert!(!style.fill().is_some());
+	/// ```
+	pub fn clear_fill(&mut self) {
+		self.fill = Fill::None;
+	}
+
+	/// Set the path's stroke to None.
+	///
+	/// # Example
+	/// ```
+	/// # use graphene_core::vector::style::{Fill, Stroke, PathStyle};
+	/// # use graphene_core::raster::color::Color;
+	/// let mut style = PathStyle::new(Some(Stroke::new(Color::GREEN, 42.)), Fill::None);
+	///
+	/// assert!(style.stroke().is_some());
+	///
+	/// style.clear_stroke();
+	///
+	/// assert!(!style.stroke().is_some());
+	/// ```
+	pub fn clear_stroke(&mut self) {
+		self.stroke = None;
+	}
+
+	pub fn render(&self, view_mode: ViewMode, svg_defs: &mut String, multiplied_transform: DAffine2, bounds: [DVec2; 2], transformed_bounds: [DVec2; 2]) -> String {
+		let fill_attribute = match (view_mode, &self.fill) {
+			(ViewMode::Outline, _) => Fill::None.render(svg_defs, multiplied_transform, bounds, transformed_bounds),
+			(_, fill) => fill.render(svg_defs, multiplied_transform, bounds, transformed_bounds),
+		};
+		let stroke_attribute = match (view_mode, &self.stroke) {
+			(ViewMode::Outline, _) => Stroke::new(LAYER_OUTLINE_STROKE_COLOR, LAYER_OUTLINE_STROKE_WEIGHT).render(),
+			(_, Some(stroke)) => stroke.render(),
+			(_, None) => String::new(),
+		};
+
+		format!("{}{}", fill_attribute, stroke_attribute)
+	}
+}
+
+/// Represents different ways of rendering an object
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Deserialize, Serialize, specta::Type)]
+pub enum ViewMode {
+	/// Render with normal coloration at the current viewport resolution
+	#[default]
+	Normal,
+	/// Render only the outlines of shapes at the current viewport resolution
+	Outline,
+	/// Render with normal coloration at the document resolution, showing the pixels when the current viewport resolution is higher
+	Pixels,
+}

node-graph/gcore/src/vector/vector_data.rs

@@ -0,0 +1,12 @@
+use glam::DAffine2;
+
+use super::style::PathStyle;
+use crate::uuid::ManipulatorGroupId;
+
+/// [VectorData] is passed between nodes.
+/// It contains a list of subpaths (that may be open or closed), a transform and some style information.
+pub struct VectorData {
+	pub subpaths: Vec<bezier_rs::Subpath<ManipulatorGroupId>>,
+	pub transform: DAffine2,
+	pub style: PathStyle,
+}

node-graph/gpu-compiler/Cargo.toml

@@ -16,7 +16,6 @@ graphene-core = { path = "../gcore", features = ["async", "std", "alloc"] }
 graph-craft = {path = "../graph-craft", features = ["serde"] }
 dyn-any = { path = "../../libraries/dyn-any", features = ["log-bad-types", "rc", "glam"] }
 num-traits = "0.2"
-rand_chacha = "0.3.1"
 log = "0.4"
 serde = { version = "1", features = ["derive", "rc"]}
 glam = { version = "0.22" }

node-graph/graph-craft/Cargo.toml

@@ -15,7 +15,6 @@ graphene-core = { path = "../gcore", features = ["std"] }
 dyn-any = { path = "../../libraries/dyn-any", features = ["log-bad-types", "rc", "glam"] }
 num-traits = "0.2"
 dyn-clone = "1.0"
-rand_chacha = "0.3.1"
 log = "0.4"
 serde = { version = "1", features = ["derive", "rc"], optional = true }
 glam = { version = "0.22" }

node-graph/graph-craft/src/document.rs

@@ -4,27 +4,14 @@ use graphene_core::{NodeIdentifier, Type};
 
 use dyn_any::{DynAny, StaticType};
 use glam::IVec2;
+pub use graphene_core::uuid::generate_uuid;
 use graphene_core::TypeDescriptor;
-use rand_chacha::{
-	rand_core::{RngCore, SeedableRng},
-	ChaCha20Rng,
-};
 use std::borrow::Cow;
 use std::collections::{HashMap, HashSet};
-use std::sync::Mutex;
 
 pub mod value;
 
 pub type NodeId = u64;
-static RNG: Mutex<Option<ChaCha20Rng>> = Mutex::new(None);
-
-pub fn generate_uuid() -> u64 {
-	let mut lock = RNG.lock().expect("uuid mutex poisoned");
-	if lock.is_none() {
-		*lock = Some(ChaCha20Rng::seed_from_u64(0));
-	}
-	lock.as_mut().map(ChaCha20Rng::next_u64).unwrap()
-}
 
 fn merge_ids(a: u64, b: u64) -> u64 {
 	use std::hash::{Hash, Hasher};

node-graph/interpreted-executor/Cargo.toml

@@ -20,7 +20,6 @@ dyn-any = { path = "../../libraries/dyn-any", features = ["log-bad-types", "glam
 num-traits = "0.2"
 borrow_stack = { path = "../borrow_stack" }
 dyn-clone = "1.0"
-rand_chacha = "0.3.1"
 log = "0.4"
 serde = { version = "1", features = ["derive"], optional = true }
 glam = { version = "0.22" }

node-graph/vulkan-executor/Cargo.toml

@@ -14,7 +14,6 @@ graphene-core = { path = "../gcore", features = ["async", "std", "alloc", "gpu"]
 graph-craft = {path = "../graph-craft" }
 dyn-any = { path = "../../libraries/dyn-any", features = ["log-bad-types", "rc", "glam"] }
 num-traits = "0.2"
-rand_chacha = "0.3.1"
 log = "0.4"
 serde = { version = "1", features = ["derive", "rc"], optional = true }
 glam = { version = "0.22" }

node-graph/wgpu-executor/Cargo.toml

@@ -15,7 +15,6 @@ graph-craft = {path = "../graph-craft" }
 dyn-any = { path = "../../libraries/dyn-any", features = ["log-bad-types", "rc", "glam"] }
 future-executor = { path = "../future-executor" }
 num-traits = "0.2"
-rand_chacha = "0.3.1"
 log = "0.4"
 serde = { version = "1", features = ["derive", "rc"], optional = true }
 glam = { version = "0.22" }