f32: switch to f32 params

Author: Firestar99

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

@@ -147,9 +147,9 @@ pub(crate) fn property_from_type(
 		Type::Concrete(concrete_type) => {
 			match concrete_type.alias.as_ref().map(|x| x.as_ref()) {
 				// Aliased types (ambiguous values)
-				Some("Percentage") => number_widget(default_info, number_input.percentage().min(min(0.)).max(max(100.))).into(),
-				Some("SignedPercentage") => number_widget(default_info, number_input.percentage().min(min(-100.)).max(max(100.))).into(),
-				Some("Angle") => number_widget(default_info, number_input.mode_range().min(min(-180.)).max(max(180.)).unit(unit.unwrap_or("°"))).into(),
+				Some("Percentage") | Some("PercentageF32") => number_widget(default_info, number_input.percentage().min(min(0.)).max(max(100.))).into(),
+				Some("SignedPercentage") | Some("SignedPercentageF32") => number_widget(default_info, number_input.percentage().min(min(-100.)).max(max(100.))).into(),
+				Some("Angle") | Some("AngleF32") => number_widget(default_info, number_input.mode_range().min(min(-180.)).max(max(180.)).unit(unit.unwrap_or("°"))).into(),
 				Some("Multiplier") => number_widget(default_info, number_input.unit(unit.unwrap_or("x"))).into(),
 				Some("PixelLength") => number_widget(default_info, number_input.min(min(0.)).unit(unit.unwrap_or(" px"))).into(),
 				Some("Length") => number_widget(default_info, number_input.min(min(0.))).into(),

node-graph/gbrush/src/brush.rs

@@ -137,7 +137,7 @@ pub async fn create_brush_texture(brush_style: &BrushStyle) -> Raster<CPU> {
 }
 
 pub fn blend_with_mode(background: TableRow<Raster<CPU>>, foreground: TableRow<Raster<CPU>>, blend_mode: BlendMode, opacity: f64) -> TableRow<Raster<CPU>> {
-	let opacity = opacity / 100.;
+	let opacity = opacity as f32 / 100.;
 	match std::hint::black_box(blend_mode) {
 		// Normal group
 		BlendMode::Normal => blend_image_closure(foreground, background, |a, b| blend_colors(a, b, BlendMode::Normal, opacity)),

node-graph/gcore-shaders/src/registry.rs

@@ -1,10 +1,16 @@
 pub mod types {
 	/// 0% - 100%
 	pub type Percentage = f64;
+	/// 0% - 100%
+	pub type PercentageF32 = f32;
 	/// -100% - 100%
 	pub type SignedPercentage = f64;
+	/// -100% - 100%
+	pub type SignedPercentageF32 = f32;
 	/// -180° - 180°
 	pub type Angle = f64;
+	/// -180° - 180°
+	pub type AngleF32 = f32;
 	/// Ends in the unit of x
 	pub type Multiplier = f64;
 	/// Non-negative integer with px unit

node-graph/graster-nodes/src/adjustments.rs

@@ -11,7 +11,7 @@ use graphene_core::raster_types::{CPU, Raster};
 use graphene_core::table::Table;
 use graphene_core_shaders::color::Color;
 use graphene_core_shaders::context::Ctx;
-use graphene_core_shaders::registry::types::{Angle, Percentage, SignedPercentage};
+use graphene_core_shaders::registry::types::{AngleF32, PercentageF32, SignedPercentageF32};
 #[cfg(not(feature = "std"))]
 use num_traits::float::Float;
 
@@ -149,8 +149,8 @@ fn brightness_contrast<T: Adjust<Color>>(
 		GradientStops,
 	)]
 	mut input: T,
-	brightness: SignedPercentage,
-	contrast: SignedPercentage,
+	brightness: SignedPercentageF32,
+	contrast: SignedPercentageF32,
 	use_classic: bool,
 ) -> T {
 	if use_classic {
@@ -239,11 +239,11 @@ fn levels<T: Adjust<Color>>(
 		GradientStops,
 	)]
 	mut image: T,
-	#[default(0.)] shadows: Percentage,
-	#[default(50.)] midtones: Percentage,
-	#[default(100.)] highlights: Percentage,
-	#[default(0.)] output_minimums: Percentage,
-	#[default(100.)] output_maximums: Percentage,
+	#[default(0.)] shadows: PercentageF32,
+	#[default(50.)] midtones: PercentageF32,
+	#[default(100.)] highlights: PercentageF32,
+	#[default(0.)] output_minimums: PercentageF32,
+	#[default(100.)] output_maximums: PercentageF32,
 ) -> T {
 	image.adjust(|color| {
 		let color = color.to_gamma_srgb();
@@ -310,22 +310,22 @@ fn black_and_white<T: Adjust<Color>>(
 	#[default(Color::BLACK)] tint: Table<Color>,
 	#[default(40.)]
 	#[range((-200., 300.))]
-	reds: Percentage,
+	reds: PercentageF32,
 	#[default(60.)]
 	#[range((-200., 300.))]
-	yellows: Percentage,
+	yellows: PercentageF32,
 	#[default(40.)]
 	#[range((-200., 300.))]
-	greens: Percentage,
+	greens: PercentageF32,
 	#[default(60.)]
 	#[range((-200., 300.))]
-	cyans: Percentage,
+	cyans: PercentageF32,
 	#[default(20.)]
 	#[range((-200., 300.))]
-	blues: Percentage,
+	blues: PercentageF32,
 	#[default(80.)]
 	#[range((-200., 300.))]
-	magentas: Percentage,
+	magentas: PercentageF32,
 ) -> T {
 	let tint: Option<Color> = tint.into();
 	let tint = tint.unwrap_or(Color::BLACK);
@@ -383,9 +383,9 @@ fn hue_saturation<T: Adjust<Color>>(
 		GradientStops,
 	)]
 	mut input: T,
-	hue_shift: Angle,
-	saturation_shift: SignedPercentage,
-	lightness_shift: SignedPercentage,
+	hue_shift: AngleF32,
+	saturation_shift: SignedPercentageF32,
+	lightness_shift: SignedPercentageF32,
 ) -> T {
 	input.adjust(|color| {
 		let color = color.to_gamma_srgb();
@@ -441,8 +441,8 @@ fn threshold<T: Adjust<Color>>(
 		GradientStops,
 	)]
 	mut image: T,
-	#[default(50.)] min_luminance: Percentage,
-	#[default(100.)] max_luminance: Percentage,
+	#[default(50.)] min_luminance: PercentageF32,
+	#[default(100.)] max_luminance: PercentageF32,
 	luminance_calc: LuminanceCalculation,
 ) -> T {
 	image.adjust(|color| {
@@ -487,7 +487,7 @@ fn vibrance<T: Adjust<Color>>(
 		GradientStops,
 	)]
 	mut image: T,
-	vibrance: SignedPercentage,
+	vibrance: SignedPercentageF32,
 ) -> T {
 	image.adjust(|color| {
 		let vibrance = vibrance as f32 / 100.;
@@ -959,21 +959,21 @@ fn exposure<T: Adjust<Color>>(
 		GradientStops,
 	)]
 	mut input: T,
-	exposure: f64,
-	offset: f64,
+	exposure: f32,
+	offset: f32,
 	#[default(1.)]
 	#[range((0.01, 10.))]
 	#[hard_min(0.0001)]
-	gamma_correction: f64,
+	gamma_correction: f32,
 ) -> T {
 	input.adjust(|color| {
 		let adjusted = color
 		// Exposure
-		.map_rgb(|c: f32| c * 2_f32.powf(exposure as f32))
+		.map_rgb(|c: f32| c * 2_f32.powf(exposure))
 		// Offset
-		.map_rgb(|c: f32| c + offset as f32)
+		.map_rgb(|c: f32| c + offset)
 		// Gamma correction
-		.gamma(gamma_correction as f32);
+		.gamma(gamma_correction);
 
 		adjusted.map_rgb(|c: f32| c.clamp(0., 1.))
 	});

node-graph/graster-nodes/src/blending_nodes.rs

@@ -8,7 +8,7 @@ use graphene_core::table::Table;
 use graphene_core_shaders::Ctx;
 use graphene_core_shaders::blending::BlendMode;
 use graphene_core_shaders::color::{Color, Pixel};
-use graphene_core_shaders::registry::types::Percentage;
+use graphene_core_shaders::registry::types::PercentageF32;
 
 pub trait Blend<P: Pixel> {
 	fn blend(&self, under: &Self, blend_fn: impl Fn(P, P) -> P) -> Self;
@@ -81,7 +81,7 @@ mod blend_std {
 }
 
 #[inline(always)]
-pub fn blend_colors(foreground: Color, background: Color, blend_mode: BlendMode, opacity: f64) -> Color {
+pub fn blend_colors(foreground: Color, background: Color, blend_mode: BlendMode, opacity: f32) -> Color {
 	let target_color = match blend_mode {
 		// Other utility blend modes (hidden from the normal list) - do not have alpha blend
 		BlendMode::Erase => return background.alpha_subtract(foreground),
@@ -151,7 +151,7 @@ fn blend<T: Blend<Color> + Send>(
 	)]
 	under: T,
 	blend_mode: BlendMode,
-	#[default(100.)] opacity: Percentage,
+	#[default(100.)] opacity: PercentageF32,
 ) -> T {
 	over.blend(&under, |a, b| blend_colors(a, b, blend_mode, opacity / 100.))
 }
@@ -168,7 +168,7 @@ fn color_overlay<T: Adjust<Color>>(
 	mut image: T,
 	#[default(Color::BLACK)] color: Table<Color>,
 	blend_mode: BlendMode,
-	#[default(100.)] opacity: Percentage,
+	#[default(100.)] opacity: PercentageF32,
 ) -> T {
 	let opacity = (opacity as f32 / 100.).clamp(0., 1.);
 
@@ -204,7 +204,7 @@ mod test {
 		let overlay_color = Color::GREEN;
 
 		// 100% of the output should come from the multiplied value
-		let opacity = 100_f64;
+		let opacity = 100.;
 
 		let result = super::color_overlay(
 			(),