Bulk gcore cleanup, replace core and alloc with std (#2735)

* gcore: replace `core` and `alloc` paths with `std`

* node-graph: remove unnecessary path prefix

* gcore: remove most `#[cfg(target_arch = "spirv")]`, keep some potentially useful ones

---------

Co-authored-by: Keavon Chambers <keavon@keavon.com>

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

@@ -10,12 +10,9 @@ use crate::vector::VectorDataTable;
 use crate::vector::style::GradientStops;
 use crate::{Ctx, Node};
 use crate::{GraphicElement, GraphicGroupTable};
-use core::cmp::Ordering;
-use core::fmt::Debug;
 use dyn_any::DynAny;
-#[cfg(feature = "serde")]
-#[cfg(target_arch = "spirv")]
-use spirv_std::num_traits::float::Float;
+use std::cmp::Ordering;
+use std::fmt::Debug;
 
 // TODO: Implement the following:
 // Color Balance
@@ -183,8 +180,8 @@ impl BlendMode {
 	}
 }
 
-impl core::fmt::Display for BlendMode {
-	fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+impl std::fmt::Display for BlendMode {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 		match self {
 			// Normal group
 			BlendMode::Normal => write!(f, "Normal"),
@@ -346,7 +343,7 @@ fn brightness_contrast<T: Adjust<Color>>(
 		let brightness = brightness as f32 / 255.;
 
 		let contrast = contrast as f32 / 100.;
-		let contrast = if contrast > 0. { (contrast * core::f32::consts::FRAC_PI_2 - 0.01).tan() } else { contrast };
+		let contrast = if contrast > 0. { (contrast * std::f32::consts::FRAC_PI_2 - 0.01).tan() } else { contrast };
 
 		let offset = brightness * contrast + brightness - contrast / 2.;
 
@@ -368,13 +365,13 @@ fn brightness_contrast<T: Adjust<Color>>(
 		y: [0., 130. + brightness * 51., 233. + brightness * 10., 255.].map(|x| x / 255.),
 	};
 	let brightness_curve_solutions = brightness_curve_points.solve();
-	let mut brightness_lut: [f32; WINDOW_SIZE] = core::array::from_fn(|i| {
+	let mut brightness_lut: [f32; WINDOW_SIZE] = std::array::from_fn(|i| {
 		let x = i as f32 / (WINDOW_SIZE as f32 - 1.);
 		brightness_curve_points.interpolate(x, &brightness_curve_solutions)
 	});
 	// Special handling for when brightness is negative
 	if brightness_is_negative {
-		brightness_lut = core::array::from_fn(|i| {
+		brightness_lut = std::array::from_fn(|i| {
 			let mut x = i;
 			while x > 1 && brightness_lut[x] > i as f32 / WINDOW_SIZE as f32 {
 				x -= 1;
@@ -393,7 +390,7 @@ fn brightness_contrast<T: Adjust<Color>>(
 		y: [0., 64. - contrast * 30., 192. + contrast * 30., 255.].map(|x| x / 255.),
 	};
 	let contrast_curve_solutions = contrast_curve_points.solve();
-	let contrast_lut: [f32; WINDOW_SIZE] = core::array::from_fn(|i| {
+	let contrast_lut: [f32; WINDOW_SIZE] = std::array::from_fn(|i| {
 		let x = i as f32 / (WINDOW_SIZE as f32 - 1.);
 		contrast_curve_points.interpolate(x, &contrast_curve_solutions)
 	});
@@ -1419,7 +1416,7 @@ fn generate_curves<C: Channel + crate::raster::Linear>(_: impl Ctx, curve: Curve
 		anchor: [1.; 2],
 		handles: [curve.last_handle, [0.; 2]],
 	};
-	for sample in curve.manipulator_groups.iter().chain(core::iter::once(&end)) {
+	for sample in curve.manipulator_groups.iter().chain(std::iter::once(&end)) {
 		let [x0, y0, x1, y1, x2, y2, x3, y3] = [pos[0], pos[1], param[0], param[1], sample.handles[0][0], sample.handles[0][1], sample.anchor[0], sample.anchor[1]].map(f64::from);
 
 		let bezier = Bezier::from_cubic_coordinates(x0, y0, x1, y1, x2, y2, x3, y3);
@@ -1511,7 +1508,7 @@ mod test {
 	pub struct FutureWrapperNode<T: Clone>(T);
 
 	impl<'i, T: 'i + Clone + Send> Node<'i, ()> for FutureWrapperNode<T> {
-		type Output = Pin<Box<dyn core::future::Future<Output = T> + 'i + Send>>;
+		type Output = Pin<Box<dyn Future<Output = T> + 'i + Send>>;
 		fn eval(&'i self, _input: ()) -> Self::Output {
 			let value = self.0.clone();
 			Box::pin(async move { value })

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

@@ -1,8 +1,7 @@
 use dyn_any::DynAny;
 use glam::{DAffine2, DVec2};
 
-#[cfg_attr(not(target_arch = "spirv"), derive(Debug))]
-#[derive(Clone, DynAny)]
+#[derive(Clone, Debug, DynAny)]
 pub struct AxisAlignedBbox {
 	pub start: DVec2,
 	pub end: DVec2,
@@ -60,8 +59,7 @@ impl From<(DVec2, DVec2)> for AxisAlignedBbox {
 	}
 }
 
-#[cfg_attr(not(target_arch = "spirv"), derive(Debug))]
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct Bbox {
 	pub top_left: DVec2,
 	pub top_right: DVec2,

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

@@ -3,9 +3,9 @@ use crate::raster_types::CPU;
 use crate::raster_types::Raster;
 use crate::vector::brush_stroke::BrushStroke;
 use crate::vector::brush_stroke::BrushStyle;
-use core::hash::Hash;
 use dyn_any::DynAny;
 use std::collections::HashMap;
+use std::hash::Hash;
 use std::sync::Arc;
 use std::sync::Mutex;
 
@@ -53,7 +53,7 @@ impl BrushCacheImpl {
 
 		// Take our previous blended image (and invalidate the cache).
 		// Since we're about to replace our cache anyway, this saves a clone.
-		background = core::mem::take(&mut self.blended_image);
+		background = std::mem::take(&mut self.blended_image);
 
 		// Check if the first non-blended stroke is an extension of the last one.
 		let mut first_stroke_texture = Instance {
@@ -70,7 +70,7 @@ impl BrushCacheImpl {
 			let new_points = strokes[0].compute_blit_points();
 			let is_point_prefix = new_points.get(..prev_points.len()) == Some(&prev_points);
 			if same_style && is_point_prefix {
-				first_stroke_texture = core::mem::take(&mut self.last_stroke_texture);
+				first_stroke_texture = std::mem::take(&mut self.last_stroke_texture);
 				first_stroke_point_skip = prev_points.len();
 			}
 		}
@@ -93,7 +93,7 @@ impl BrushCacheImpl {
 
 impl Hash for BrushCacheImpl {
 	// Zero hash.
-	fn hash<H: core::hash::Hasher>(&self, _state: &mut H) {}
+	fn hash<H: std::hash::Hasher>(&self, _state: &mut H) {}
 }
 
 #[derive(Clone, Debug, Default)]
@@ -151,7 +151,7 @@ impl PartialEq for BrushCache {
 }
 
 impl Hash for BrushCache {
-	fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
+	fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
 		self.inner.lock().unwrap().hash(state);
 	}
 }

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

@@ -1,14 +1,13 @@
 use super::discrete_srgb::{float_to_srgb_u8, srgb_u8_to_float};
 use super::{Alpha, AlphaMut, AssociatedAlpha, Luminance, LuminanceMut, Pixel, RGB, RGBMut, Rec709Primaries, SRGB};
 use bytemuck::{Pod, Zeroable};
-use core::hash::Hash;
 use dyn_any::DynAny;
 use half::f16;
 #[cfg(target_arch = "spirv")]
 use spirv_std::num_traits::Euclid;
-#[cfg(feature = "serde")]
 #[cfg(target_arch = "spirv")]
 use spirv_std::num_traits::float::Float;
+use std::hash::Hash;
 
 #[repr(C)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -217,7 +216,7 @@ pub struct Color {
 
 #[allow(clippy::derived_hash_with_manual_eq)]
 impl Hash for Color {
-	fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
+	fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
 		self.red.to_bits().hash(state);
 		self.green.to_bits().hash(state);
 		self.blue.to_bits().hash(state);

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

@@ -1,7 +1,7 @@
 use super::{Channel, Linear, LuminanceMut};
 use crate::Node;
-use core::ops::{Add, Mul, Sub};
 use dyn_any::{DynAny, StaticType, StaticTypeSized};
+use std::ops::{Add, Mul, Sub};
 
 #[derive(Debug, Clone, PartialEq, DynAny, specta::Type)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -95,12 +95,7 @@ impl CubicSplines {
 		// Gaussian elimination: forward elimination
 		for row in 0..4 {
 			let pivot_row_index = (row..4)
-				.max_by(|&a_row, &b_row| {
-					augmented_matrix[a_row][row]
-						.abs()
-						.partial_cmp(&augmented_matrix[b_row][row].abs())
-						.unwrap_or(core::cmp::Ordering::Equal)
-				})
+				.max_by(|&a_row, &b_row| augmented_matrix[a_row][row].abs().partial_cmp(&augmented_matrix[b_row][row].abs()).unwrap_or(std::cmp::Ordering::Equal))
 				.unwrap();
 
 			// Swap the current row with the row that has the largest pivot element

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

@@ -69,7 +69,7 @@ pub fn float_to_srgb_u8(mut f: f32) -> u8 {
 		// We clamped f to [0, 1], and the integer representations
 		// of the positive finite non-NaN floats are monotonic.
 		// This makes the later LUT lookup panicless.
-		unsafe { core::hint::unreachable_unchecked() }
+		unsafe { std::hint::unreachable_unchecked() }
 	}
 
 	// Compute a piecewise linear interpolation that is always

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

@@ -1,15 +1,12 @@
-use crate::{
-	AlphaBlending,
-	instances::{Instance, Instances},
-	raster_types::Raster,
-};
-
 use super::Color;
 use super::discrete_srgb::float_to_srgb_u8;
-use alloc::vec::Vec;
+use crate::AlphaBlending;
+use crate::instances::{Instance, Instances};
+use crate::raster_types::Raster;
 use core::hash::{Hash, Hasher};
 use dyn_any::{DynAny, StaticType};
 use glam::{DAffine2, DVec2};
+use std::vec::Vec;
 
 #[cfg(feature = "serde")]
 mod base64_serde {
@@ -56,7 +53,7 @@ pub struct Image<P: Pixel> {
 }
 
 impl<P: Pixel + Debug> Debug for Image<P> {
-	fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 		let length = self.data.len();
 		f.debug_struct("Image")
 			.field("width", &self.width)
@@ -203,7 +200,7 @@ where
 
 impl<P: Pixel> IntoIterator for Image<P> {
 	type Item = P;
-	type IntoIter = alloc::vec::IntoIter<P>;
+	type IntoIter = std::vec::IntoIter<P>;
 	fn into_iter(self) -> Self::IntoIter {
 		self.data.into_iter()
 	}