Add #[inline] to all color-related function

crates/ecolor/src/hsva.rs

@@ -21,11 +21,13 @@ pub struct Hsva {
 }
 
 impl Hsva {
+    #[inline]
     pub fn new(h: f32, s: f32, v: f32, a: f32) -> Self {
         Self { h, s, v, a }
     }
 
     /// From `sRGBA` with premultiplied alpha
+    #[inline]
     pub fn from_srgba_premultiplied(srgba: [u8; 4]) -> Self {
         Self::from_rgba_premultiplied(
             linear_f32_from_gamma_u8(srgba[0]),
@@ -36,6 +38,7 @@ impl Hsva {
     }
 
     /// From `sRGBA` without premultiplied alpha
+    #[inline]
     pub fn from_srgba_unmultiplied(srgba: [u8; 4]) -> Self {
         Self::from_rgba_unmultiplied(
             linear_f32_from_gamma_u8(srgba[0]),
@@ -46,6 +49,7 @@ impl Hsva {
     }
 
     /// From linear RGBA with premultiplied alpha
+    #[inline]
     pub fn from_rgba_premultiplied(r: f32, g: f32, b: f32, a: f32) -> Self {
         #![allow(clippy::many_single_char_names)]
         if a == 0.0 {
@@ -61,12 +65,14 @@ impl Hsva {
     }
 
     /// From linear RGBA without premultiplied alpha
+    #[inline]
     pub fn from_rgba_unmultiplied(r: f32, g: f32, b: f32, a: f32) -> Self {
         #![allow(clippy::many_single_char_names)]
         let (h, s, v) = hsv_from_rgb([r, g, b]);
         Hsva { h, s, v, a }
     }
 
+    #[inline]
     pub fn from_additive_rgb(rgb: [f32; 3]) -> Self {
         let (h, s, v) = hsv_from_rgb(rgb);
         Hsva {
@@ -77,11 +83,13 @@ impl Hsva {
         }
     }
 
+    #[inline]
     pub fn from_rgb(rgb: [f32; 3]) -> Self {
         let (h, s, v) = hsv_from_rgb(rgb);
         Hsva { h, s, v, a: 1.0 }
     }
 
+    #[inline]
     pub fn from_srgb([r, g, b]: [u8; 3]) -> Self {
         Self::from_rgb([
             linear_f32_from_gamma_u8(r),
@@ -92,14 +100,17 @@ impl Hsva {
 
     // ------------------------------------------------------------------------
 
+    #[inline]
     pub fn to_opaque(self) -> Self {
         Self { a: 1.0, ..self }
     }
 
+    #[inline]
     pub fn to_rgb(&self) -> [f32; 3] {
         rgb_from_hsv((self.h, self.s, self.v))
     }
 
+    #[inline]
     pub fn to_srgb(&self) -> [u8; 3] {
         let [r, g, b] = self.to_rgb();
         [
@@ -109,6 +120,7 @@ impl Hsva {
         ]
     }
 
+    #[inline]
     pub fn to_rgba_premultiplied(&self) -> [f32; 4] {
         let [r, g, b, a] = self.to_rgba_unmultiplied();
         let additive = a < 0.0;
@@ -120,12 +132,14 @@ impl Hsva {
     }
 
     /// Represents additive colors using a negative alpha.
+    #[inline]
     pub fn to_rgba_unmultiplied(&self) -> [f32; 4] {
         let Hsva { h, s, v, a } = *self;
         let [r, g, b] = rgb_from_hsv((h, s, v));
         [r, g, b, a]
     }
 
+    #[inline]
     pub fn to_srgba_premultiplied(&self) -> [u8; 4] {
         let [r, g, b, a] = self.to_rgba_premultiplied();
         [
@@ -136,6 +150,7 @@ impl Hsva {
         ]
     }
 
+    #[inline]
     pub fn to_srgba_unmultiplied(&self) -> [u8; 4] {
         let [r, g, b, a] = self.to_rgba_unmultiplied();
         [
@@ -148,30 +163,35 @@ impl Hsva {
 }
 
 impl From<Hsva> for Rgba {
+    #[inline]
     fn from(hsva: Hsva) -> Rgba {
         Rgba(hsva.to_rgba_premultiplied())
     }
 }
 
 impl From<Rgba> for Hsva {
+    #[inline]
     fn from(rgba: Rgba) -> Hsva {
         Self::from_rgba_premultiplied(rgba.0[0], rgba.0[1], rgba.0[2], rgba.0[3])
     }
 }
 
 impl From<Hsva> for Color32 {
+    #[inline]
     fn from(hsva: Hsva) -> Color32 {
         Color32::from(Rgba::from(hsva))
     }
 }
 
 impl From<Color32> for Hsva {
+    #[inline]
     fn from(srgba: Color32) -> Hsva {
         Hsva::from(Rgba::from(srgba))
     }
 }
 
 /// All ranges in 0-1, rgb is linear.
+#[inline]
 pub fn hsv_from_rgb([r, g, b]: [f32; 3]) -> (f32, f32, f32) {
     #![allow(clippy::many_single_char_names)]
     let min = r.min(g.min(b));
@@ -195,6 +215,7 @@ pub fn hsv_from_rgb([r, g, b]: [f32; 3]) -> (f32, f32, f32) {
 }
 
 /// All ranges in 0-1, rgb is linear.
+#[inline]
 pub fn rgb_from_hsv((h, s, v): (f32, f32, f32)) -> [f32; 3] {
     #![allow(clippy::many_single_char_names)]
     let h = (h.fract() + 1.0).fract(); // wrap