shaders: switch to f32 params

Author: Firestar99

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

@@ -149,9 +149,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

@@ -10,7 +10,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;
 
@@ -148,8 +148,8 @@ fn brightness_contrast<T: Adjust<Color>>(
 	)]
 	#[gpu_image]
 	mut input: T,
-	brightness: SignedPercentage,
-	contrast: SignedPercentage,
+	brightness: SignedPercentageF32,
+	contrast: SignedPercentageF32,
 	use_classic: bool,
 ) -> T {
 	if use_classic {
@@ -238,11 +238,11 @@ fn levels<T: Adjust<Color>>(
 	)]
 	#[gpu_image]
 	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();
@@ -309,22 +309,22 @@ fn black_and_white<T: Adjust<Color>>(
 	#[default(Color::BLACK)] tint: 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 {
 	image.adjust(|color| {
 		let color = color.to_gamma_srgb();
@@ -379,9 +379,9 @@ fn hue_saturation<T: Adjust<Color>>(
 	)]
 	#[gpu_image]
 	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();
@@ -437,8 +437,8 @@ fn threshold<T: Adjust<Color>>(
 	)]
 	#[gpu_image]
 	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| {
@@ -483,7 +483,7 @@ fn vibrance<T: Adjust<Color>>(
 	)]
 	#[gpu_image]
 	mut image: T,
-	vibrance: SignedPercentage,
+	vibrance: SignedPercentageF32,
 ) -> T {
 	image.adjust(|color| {
 		let vibrance = vibrance as f32 / 100.;
@@ -955,21 +955,21 @@ fn exposure<T: Adjust<Color>>(
 	)]
 	#[gpu_image]
 	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

@@ -7,7 +7,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::{Percentage, PercentageF32};
 
 pub trait Blend<P: Pixel> {
 	fn blend(&self, under: &Self, blend_fn: impl Fn(P, P) -> P) -> Self;
@@ -71,7 +71,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),
@@ -141,7 +141,7 @@ fn blend<T: Blend<Color> + Send>(
 	#[gpu_image]
 	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.))
 }
@@ -158,7 +158,7 @@ fn color_overlay<T: Adjust<Color>>(
 	mut image: T,
 	#[default(Color::BLACK)] color: Color,
 	blend_mode: BlendMode,
-	#[default(100.)] opacity: Percentage,
+	#[default(100.)] opacity: PercentageF32,
 ) -> T {
 	let opacity = (opacity as f32 / 100.).clamp(0., 1.);
 
@@ -183,7 +183,7 @@ where
 {
 	let blend_mode = blend_mode.eval(());
 	let opacity = opacity.eval(());
-	blend_colors(input.0, input.1, blend_mode, opacity / 100.)
+	blend_colors(input.0, input.1, blend_mode, opacity as f32 / 100.)
 }
 
 #[cfg(all(feature = "std", test))]