From ac6b27925edccdf90f2ef4b7464be6b6cb50fd7c Mon Sep 17 00:00:00 2001
From: Carter Anderson <mcanders1@gmail.com>
Date: Thu, 1 Jul 2021 18:05:20 -0700
Subject: [PATCH] fix clippy

---
 crates/bevy_app/src/ci_testing.rs             |   12 +-
 crates/bevy_ecs/src/entity/mod.rs             |    5 +
 crates/bevy_window/src/raw_window_handle.rs   |    4 +-
 crates/crevice/crevice-derive/src/lib.rs      |    6 +-
 crates/crevice/src/lib.rs                     |    2 +
 examples/2d/sprite.rs                         |    2 +-
 examples/tools/bevymark_pipelined.rs          |    8 +-
 pipelined/bevy_pbr2/src/lib.rs                |    2 +-
 pipelined/bevy_pbr2/src/render/light.rs       |   10 +-
 pipelined/bevy_pbr2/src/render/mod.rs         |    5 +-
 pipelined/bevy_render2/src/camera/mod.rs      |    2 +-
 pipelined/bevy_render2/src/color/color.rs     | 1234 ----------------
 pipelined/bevy_render2/src/color/mod.rs       | 1237 ++++++++++++++++-
 .../bevy_render2/src/core_pipeline/mod.rs     |   24 +-
 pipelined/bevy_render2/src/mesh/mesh/mod.rs   |    7 +
 .../bevy_render2/src/render_graph/context.rs  |   18 +-
 .../bevy_render2/src/render_graph/graph.rs    |   15 +-
 .../src/render_resource/uniform_vec.rs        |   10 +
 pipelined/bevy_render2/src/texture/image.rs   |    6 +-
 pipelined/bevy_sprite2/src/render/mod.rs      |    5 +-
 20 files changed, 1315 insertions(+), 1299 deletions(-)
 delete mode 100644 pipelined/bevy_render2/src/color/color.rs

diff --git a/crates/bevy_app/src/ci_testing.rs b/crates/bevy_app/src/ci_testing.rs
index 21e22bec04..dc8865a166 100644
--- a/crates/bevy_app/src/ci_testing.rs
+++ b/crates/bevy_app/src/ci_testing.rs
@@ -1,7 +1,6 @@
-use serde::Deserialize;
-
-use crate::{app::AppExit, AppBuilder};
+use crate::app::{App, AppExit};
 use bevy_ecs::system::IntoSystem;
+use serde::Deserialize;
 
 /// Configuration for automated testing on CI
 #[derive(Deserialize)]
@@ -23,16 +22,15 @@ fn ci_testing_exit_after(
     *current_frame += 1;
 }
 
-pub(crate) fn setup_app(app_builder: &mut AppBuilder) -> &mut AppBuilder {
+pub(crate) fn setup_app(app: &mut App) -> &mut App {
     let filename =
         std::env::var("CI_TESTING_CONFIG").unwrap_or_else(|_| "ci_testing_config.ron".to_string());
     let config: CiTestingConfig = ron::from_str(
         &std::fs::read_to_string(filename).expect("error reading CI testing configuration file"),
     )
     .expect("error deserializing CI testing configuration file");
-    app_builder
-        .insert_resource(config)
+    app.insert_resource(config)
         .add_system(ci_testing_exit_after.system());
 
-    app_builder
+    app
 }
diff --git a/crates/bevy_ecs/src/entity/mod.rs b/crates/bevy_ecs/src/entity/mod.rs
index 7160ed6acc..7be98eac0e 100644
--- a/crates/bevy_ecs/src/entity/mod.rs
+++ b/crates/bevy_ecs/src/entity/mod.rs
@@ -428,6 +428,11 @@ impl Entities {
 
     /// Allocates space for entities previously reserved with `reserve_entity` or
     /// `reserve_entities`, then initializes each one using the supplied function.
+    ///
+    /// # Safety
+    /// Flush _must_ set the entity location to the correct ArchetypeId for the given Entity
+    /// each time init is called. This _can_ be ArchetypeId::invalid(), provided the Entity has
+    /// not been assigned to an Archetype.
     pub unsafe fn flush(&mut self, mut init: impl FnMut(Entity, &mut EntityLocation)) {
         let free_cursor = self.free_cursor.get_mut();
         let current_free_cursor = *free_cursor;
diff --git a/crates/bevy_window/src/raw_window_handle.rs b/crates/bevy_window/src/raw_window_handle.rs
index 2393975490..76f1411261 100644
--- a/crates/bevy_window/src/raw_window_handle.rs
+++ b/crates/bevy_window/src/raw_window_handle.rs
@@ -15,7 +15,7 @@ impl RawWindowHandleWrapper {
     /// have constraints on where/how this handle can be used. For example, some platforms don't support doing window
     /// operations off of the main thread. The caller must ensure the [`RawWindowHandle`] is only used in valid contexts.
     pub unsafe fn get_handle(&self) -> HasRawWindowHandleWrapper {
-        HasRawWindowHandleWrapper(self.0.clone())
+        HasRawWindowHandleWrapper(self.0)
     }
 }
 
@@ -32,6 +32,6 @@ pub struct HasRawWindowHandleWrapper(RawWindowHandle);
 // SAFE: the caller has validated that this is a valid context to get RawWindowHandle
 unsafe impl HasRawWindowHandle for HasRawWindowHandleWrapper {
     fn raw_window_handle(&self) -> RawWindowHandle {
-        self.0.clone()
+        self.0
     }
 }
diff --git a/crates/crevice/crevice-derive/src/lib.rs b/crates/crevice/crevice-derive/src/lib.rs
index ee7bfe1d34..a4fbac11ae 100644
--- a/crates/crevice/crevice-derive/src/lib.rs
+++ b/crates/crevice/crevice-derive/src/lib.rs
@@ -246,11 +246,7 @@ impl EmitOptions {
 
         // For testing purposes, we can optionally generate type layout
         // information using the type-layout crate.
-        let type_layout_derive = if cfg!(feature = "test_type_layout") {
-            quote!(#[derive(::type_layout::TypeLayout)])
-        } else {
-            quote!()
-        };
+        let type_layout_derive = quote!();
 
         quote! {
             #[allow(non_snake_case)]
diff --git a/crates/crevice/src/lib.rs b/crates/crevice/src/lib.rs
index 89b7d4fddb..076f2c7ce4 100644
--- a/crates/crevice/src/lib.rs
+++ b/crates/crevice/src/lib.rs
@@ -1,3 +1,5 @@
+#![allow(clippy::all)]
+
 /*!
 [![GitHub CI Status](https://github.com/LPGhatguy/crevice/workflows/CI/badge.svg)](https://github.com/LPGhatguy/crevice/actions)
 [![crevice on crates.io](https://img.shields.io/crates/v/crevice.svg)](https://crates.io/crates/crevice)
diff --git a/examples/2d/sprite.rs b/examples/2d/sprite.rs
index b55e237133..5bfe05a225 100644
--- a/examples/2d/sprite.rs
+++ b/examples/2d/sprite.rs
@@ -9,7 +9,7 @@ fn main() {
 
 fn setup(
     mut commands: Commands,
-    asset_server: Res<AssetServer>,
+    _asset_server: Res<AssetServer>,
     // mut materials: ResMut<Assets<ColorMaterial>>,
 ) {
     // let texture_handle = asset_server.load("branding/icon.png");
diff --git a/examples/tools/bevymark_pipelined.rs b/examples/tools/bevymark_pipelined.rs
index 4789853fe3..b2e80850e3 100644
--- a/examples/tools/bevymark_pipelined.rs
+++ b/examples/tools/bevymark_pipelined.rs
@@ -13,7 +13,7 @@ use bevy::{
 use rand::Rng;
 
 const BIRDS_PER_SECOND: u32 = 10000;
-const BASE_COLOR: Color = Color::rgb(5.0, 5.0, 5.0);
+const _BASE_COLOR: Color = Color::rgb(5.0, 5.0, 5.0);
 const GRAVITY: f32 = -9.8 * 100.0;
 const MAX_VELOCITY: f32 = 750.;
 const BIRD_SCALE: f32 = 0.15;
@@ -66,8 +66,8 @@ struct BirdTexture(Handle<Image>);
 
 fn setup(
     mut commands: Commands,
-    window: Res<WindowDescriptor>,
-    mut counter: ResMut<BevyCounter>,
+    _window: Res<WindowDescriptor>,
+    _counter: ResMut<BevyCounter>,
     asset_server: Res<AssetServer>,
 ) {
     // spawn_birds(&mut commands, &window, &mut counter, 10);
@@ -129,7 +129,7 @@ fn setup(
 #[allow(clippy::too_many_arguments)]
 fn mouse_handler(
     mut commands: Commands,
-    asset_server: Res<AssetServer>,
+    _asset_server: Res<AssetServer>,
     time: Res<Time>,
     mouse_button_input: Res<Input<MouseButton>>,
     window: Res<WindowDescriptor>,
diff --git a/pipelined/bevy_pbr2/src/lib.rs b/pipelined/bevy_pbr2/src/lib.rs
index f82bca92d7..290643ad0d 100644
--- a/pipelined/bevy_pbr2/src/lib.rs
+++ b/pipelined/bevy_pbr2/src/lib.rs
@@ -19,7 +19,7 @@ use bevy_render2::{
 
 pub mod draw_3d_graph {
     pub mod node {
-        pub const SHADOW_PASS: &'static str = "shadow_pass";
+        pub const SHADOW_PASS: &str = "shadow_pass";
     }
 }
 
diff --git a/pipelined/bevy_pbr2/src/render/light.rs b/pipelined/bevy_pbr2/src/render/light.rs
index df1be8368c..e25686d97b 100644
--- a/pipelined/bevy_pbr2/src/render/light.rs
+++ b/pipelined/bevy_pbr2/src/render/light.rs
@@ -190,7 +190,7 @@ pub fn extract_lights(
             intensity: light.intensity,
             range: light.range,
             radius: light.radius,
-            transform: transform.clone(),
+            transform: *transform,
         });
     }
 }
@@ -341,8 +341,8 @@ pub fn prepare_lights(
                 // premultiply color by intensity
                 // we don't use the alpha at all, so no reason to multiply only [0..3]
                 color: (light.color.as_rgba_linear() * light.intensity).into(),
-                radius: light.radius.into(),
-                position: light.transform.translation.into(),
+                radius: light.radius,
+                position: light.transform.translation,
                 inverse_square_range: 1.0 / (light.range * light.range),
                 near: 0.1,
                 far: light.range,
@@ -360,7 +360,7 @@ pub fn prepare_lights(
                     aspect: TextureAspect::All,
                     base_mip_level: 0,
                     mip_level_count: None,
-                    base_array_layer: 0 as u32,
+                    base_array_layer: 0,
                     array_layer_count: None,
                 });
 
@@ -412,7 +412,7 @@ impl Node for ShadowPassNode {
         world: &World,
     ) -> Result<(), NodeRunError> {
         let view_entity = graph.get_input_entity(Self::IN_VIEW)?;
-        if let Some(view_lights) = self.main_view_query.get_manual(world, view_entity).ok() {
+        if let Ok(view_lights) = self.main_view_query.get_manual(world, view_entity) {
             for view_light_entity in view_lights.lights.iter().copied() {
                 let (view_light, shadow_phase) = self
                     .view_light_query
diff --git a/pipelined/bevy_pbr2/src/render/mod.rs b/pipelined/bevy_pbr2/src/render/mod.rs
index c791f5c7e4..9494ee2a61 100644
--- a/pipelined/bevy_pbr2/src/render/mod.rs
+++ b/pipelined/bevy_pbr2/src/render/mod.rs
@@ -340,10 +340,10 @@ impl FromWorld for PbrShaders {
         };
         PbrShaders {
             pipeline,
+            shader_module,
             view_layout,
             material_layout,
             mesh_layout,
-            shader_module,
             dummy_white_gpu_image,
         }
     }
@@ -466,6 +466,7 @@ fn image_handle_to_view_sampler<'a>(
     )
 }
 
+#[allow(clippy::too_many_arguments)]
 pub fn queue_meshes(
     mut commands: Commands,
     draw_functions: Res<DrawFunctions>,
@@ -488,7 +489,7 @@ pub fn queue_meshes(
 ) {
     let mesh_meta = mesh_meta.into_inner();
 
-    if view_meta.uniforms.len() == 0 {
+    if view_meta.uniforms.is_empty() {
         return;
     }
 
diff --git a/pipelined/bevy_render2/src/camera/mod.rs b/pipelined/bevy_render2/src/camera/mod.rs
index 73bf01ca82..23b31691d9 100644
--- a/pipelined/bevy_render2/src/camera/mod.rs
+++ b/pipelined/bevy_render2/src/camera/mod.rs
@@ -80,7 +80,7 @@ fn extract_cameras(
                     },
                     ExtractedView {
                         projection: camera.projection_matrix,
-                        transform: transform.clone(),
+                        transform: *transform,
                         width: window.physical_width(),
                         height: window.physical_height(),
                     },
diff --git a/pipelined/bevy_render2/src/color/color.rs b/pipelined/bevy_render2/src/color/color.rs
deleted file mode 100644
index fdcfbb6e58..0000000000
--- a/pipelined/bevy_render2/src/color/color.rs
+++ /dev/null
@@ -1,1234 +0,0 @@
-use crate::color::{HslRepresentation, SrgbColorSpace};
-use bevy_core::Bytes;
-use bevy_math::{Vec3, Vec4};
-use bevy_reflect::{Reflect, ReflectDeserialize};
-use serde::{Deserialize, Serialize};
-use std::ops::{Add, AddAssign, Mul, MulAssign};
-
-#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize, Reflect)]
-#[reflect(PartialEq, Serialize, Deserialize)]
-pub enum Color {
-    /// sRGBA color
-    Rgba {
-        /// Red component. [0.0, 1.0]
-        red: f32,
-        /// Green component. [0.0, 1.0]
-        green: f32,
-        /// Blue component. [0.0, 1.0]
-        blue: f32,
-        /// Alpha component. [0.0, 1.0]
-        alpha: f32,
-    },
-    /// RGBA color in the Linear sRGB colorspace (often colloquially referred to as "linear", "RGB", or "linear RGB").
-    RgbaLinear {
-        /// Red component. [0.0, 1.0]
-        red: f32,
-        /// Green component. [0.0, 1.0]
-        green: f32,
-        /// Blue component. [0.0, 1.0]
-        blue: f32,
-        /// Alpha component. [0.0, 1.0]
-        alpha: f32,
-    },
-    /// HSL (hue, saturation, lightness) color with an alpha channel
-    Hsla {
-        /// Hue component. [0.0, 360.0]
-        hue: f32,
-        /// Saturation component. [0.0, 1.0]
-        saturation: f32,
-        /// Lightness component. [0.0, 1.0]
-        lightness: f32,
-        /// Alpha component. [0.0, 1.0]
-        alpha: f32,
-    },
-}
-
-impl Color {
-    pub const ALICE_BLUE: Color = Color::rgb(0.94, 0.97, 1.0);
-    pub const ANTIQUE_WHITE: Color = Color::rgb(0.98, 0.92, 0.84);
-    pub const AQUAMARINE: Color = Color::rgb(0.49, 1.0, 0.83);
-    pub const AZURE: Color = Color::rgb(0.94, 1.0, 1.0);
-    pub const BEIGE: Color = Color::rgb(0.96, 0.96, 0.86);
-    pub const BISQUE: Color = Color::rgb(1.0, 0.89, 0.77);
-    pub const BLACK: Color = Color::rgb(0.0, 0.0, 0.0);
-    pub const BLUE: Color = Color::rgb(0.0, 0.0, 1.0);
-    pub const CRIMSON: Color = Color::rgb(0.86, 0.08, 0.24);
-    pub const CYAN: Color = Color::rgb(0.0, 1.0, 1.0);
-    pub const DARK_GRAY: Color = Color::rgb(0.25, 0.25, 0.25);
-    pub const DARK_GREEN: Color = Color::rgb(0.0, 0.5, 0.0);
-    pub const FUCHSIA: Color = Color::rgb(1.0, 0.0, 1.0);
-    pub const GOLD: Color = Color::rgb(1.0, 0.84, 0.0);
-    pub const GRAY: Color = Color::rgb(0.5, 0.5, 0.5);
-    pub const GREEN: Color = Color::rgb(0.0, 1.0, 0.0);
-    pub const INDIGO: Color = Color::rgb(0.29, 0.0, 0.51);
-    pub const LIME_GREEN: Color = Color::rgb(0.2, 0.8, 0.2);
-    pub const MAROON: Color = Color::rgb(0.5, 0.0, 0.0);
-    pub const MIDNIGHT_BLUE: Color = Color::rgb(0.1, 0.1, 0.44);
-    pub const NAVY: Color = Color::rgb(0.0, 0.0, 0.5);
-    pub const NONE: Color = Color::rgba(0.0, 0.0, 0.0, 0.0);
-    pub const OLIVE: Color = Color::rgb(0.5, 0.5, 0.0);
-    pub const ORANGE: Color = Color::rgb(1.0, 0.65, 0.0);
-    pub const ORANGE_RED: Color = Color::rgb(1.0, 0.27, 0.0);
-    pub const PINK: Color = Color::rgb(1.0, 0.08, 0.58);
-    pub const PURPLE: Color = Color::rgb(0.5, 0.0, 0.5);
-    pub const RED: Color = Color::rgb(1.0, 0.0, 0.0);
-    pub const SALMON: Color = Color::rgb(0.98, 0.5, 0.45);
-    pub const SEA_GREEN: Color = Color::rgb(0.18, 0.55, 0.34);
-    pub const SILVER: Color = Color::rgb(0.75, 0.75, 0.75);
-    pub const TEAL: Color = Color::rgb(0.0, 0.5, 0.5);
-    pub const TOMATO: Color = Color::rgb(1.0, 0.39, 0.28);
-    pub const TURQUOISE: Color = Color::rgb(0.25, 0.88, 0.82);
-    pub const VIOLET: Color = Color::rgb(0.93, 0.51, 0.93);
-    pub const WHITE: Color = Color::rgb(1.0, 1.0, 1.0);
-    pub const YELLOW: Color = Color::rgb(1.0, 1.0, 0.0);
-    pub const YELLOW_GREEN: Color = Color::rgb(0.6, 0.8, 0.2);
-
-    /// New `Color` from sRGB colorspace.
-    pub const fn rgb(r: f32, g: f32, b: f32) -> Color {
-        Color::Rgba {
-            red: r,
-            green: g,
-            blue: b,
-            alpha: 1.0,
-        }
-    }
-
-    /// New `Color` from sRGB colorspace.
-    pub const fn rgba(r: f32, g: f32, b: f32, a: f32) -> Color {
-        Color::Rgba {
-            red: r,
-            green: g,
-            blue: b,
-            alpha: a,
-        }
-    }
-
-    /// New `Color` from linear RGB colorspace.
-    pub const fn rgb_linear(r: f32, g: f32, b: f32) -> Color {
-        Color::RgbaLinear {
-            red: r,
-            green: g,
-            blue: b,
-            alpha: 1.0,
-        }
-    }
-
-    /// New `Color` from linear RGB colorspace.
-    pub const fn rgba_linear(r: f32, g: f32, b: f32, a: f32) -> Color {
-        Color::RgbaLinear {
-            red: r,
-            green: g,
-            blue: b,
-            alpha: a,
-        }
-    }
-
-    /// New `Color` with HSL representation in sRGB colorspace.
-    pub const fn hsl(hue: f32, saturation: f32, lightness: f32) -> Color {
-        Color::Hsla {
-            hue,
-            saturation,
-            lightness,
-            alpha: 1.0,
-        }
-    }
-
-    /// New `Color` with HSL representation in sRGB colorspace.
-    pub const fn hsla(hue: f32, saturation: f32, lightness: f32, alpha: f32) -> Color {
-        Color::Hsla {
-            hue,
-            saturation,
-            lightness,
-            alpha,
-        }
-    }
-
-    /// New `Color` from sRGB colorspace.
-    pub fn hex<T: AsRef<str>>(hex: T) -> Result<Color, HexColorError> {
-        let hex = hex.as_ref();
-
-        // RGB
-        if hex.len() == 3 {
-            let mut data = [0; 6];
-            for (i, ch) in hex.chars().enumerate() {
-                data[i * 2] = ch as u8;
-                data[i * 2 + 1] = ch as u8;
-            }
-            return decode_rgb(&data);
-        }
-
-        // RGBA
-        if hex.len() == 4 {
-            let mut data = [0; 8];
-            for (i, ch) in hex.chars().enumerate() {
-                data[i * 2] = ch as u8;
-                data[i * 2 + 1] = ch as u8;
-            }
-            return decode_rgba(&data);
-        }
-
-        // RRGGBB
-        if hex.len() == 6 {
-            return decode_rgb(hex.as_bytes());
-        }
-
-        // RRGGBBAA
-        if hex.len() == 8 {
-            return decode_rgba(hex.as_bytes());
-        }
-
-        Err(HexColorError::Length)
-    }
-
-    /// New `Color` from sRGB colorspace.
-    pub fn rgb_u8(r: u8, g: u8, b: u8) -> Color {
-        Color::rgba_u8(r, g, b, u8::MAX)
-    }
-
-    // Float operations in const fn are not stable yet
-    // see https://github.com/rust-lang/rust/issues/57241
-    /// New `Color` from sRGB colorspace.
-    pub fn rgba_u8(r: u8, g: u8, b: u8, a: u8) -> Color {
-        Color::rgba(
-            r as f32 / u8::MAX as f32,
-            g as f32 / u8::MAX as f32,
-            b as f32 / u8::MAX as f32,
-            a as f32 / u8::MAX as f32,
-        )
-    }
-
-    /// Get red in sRGB colorspace.
-    pub fn r(&self) -> f32 {
-        match self.as_rgba() {
-            Color::Rgba { red, .. } => red,
-            _ => unreachable!(),
-        }
-    }
-
-    /// Get green in sRGB colorspace.
-    pub fn g(&self) -> f32 {
-        match self.as_rgba() {
-            Color::Rgba { green, .. } => green,
-            _ => unreachable!(),
-        }
-    }
-
-    /// Get blue in sRGB colorspace.
-    pub fn b(&self) -> f32 {
-        match self.as_rgba() {
-            Color::Rgba { blue, .. } => blue,
-            _ => unreachable!(),
-        }
-    }
-
-    /// Set red in sRGB colorspace.
-    pub fn set_r(&mut self, r: f32) -> &mut Self {
-        *self = self.as_rgba();
-        match self {
-            Color::Rgba { red, .. } => *red = r,
-            _ => unreachable!(),
-        }
-        self
-    }
-
-    /// Set green in sRGB colorspace.
-    pub fn set_g(&mut self, g: f32) -> &mut Self {
-        *self = self.as_rgba();
-        match self {
-            Color::Rgba { green, .. } => *green = g,
-            _ => unreachable!(),
-        }
-        self
-    }
-
-    /// Set blue in sRGB colorspace.
-    pub fn set_b(&mut self, b: f32) -> &mut Self {
-        *self = self.as_rgba();
-        match self {
-            Color::Rgba { blue, .. } => *blue = b,
-            _ => unreachable!(),
-        }
-        self
-    }
-
-    /// Get alpha.
-    pub fn a(&self) -> f32 {
-        match self {
-            Color::Rgba { alpha, .. }
-            | Color::RgbaLinear { alpha, .. }
-            | Color::Hsla { alpha, .. } => *alpha,
-        }
-    }
-
-    /// Set alpha.
-    pub fn set_a(&mut self, a: f32) -> &mut Self {
-        match self {
-            Color::Rgba { alpha, .. }
-            | Color::RgbaLinear { alpha, .. }
-            | Color::Hsla { alpha, .. } => {
-                *alpha = a;
-            }
-        }
-        self
-    }
-
-    /// Converts a `Color` to variant `Color::Rgba`
-    pub fn as_rgba(self: &Color) -> Color {
-        match self {
-            Color::Rgba { .. } => *self,
-            Color::RgbaLinear {
-                red,
-                green,
-                blue,
-                alpha,
-            } => Color::Rgba {
-                red: red.linear_to_nonlinear_srgb(),
-                green: green.linear_to_nonlinear_srgb(),
-                blue: blue.linear_to_nonlinear_srgb(),
-                alpha: *alpha,
-            },
-            Color::Hsla {
-                hue,
-                saturation,
-                lightness,
-                alpha,
-            } => {
-                let [red, green, blue] =
-                    HslRepresentation::hsl_to_nonlinear_srgb(*hue, *saturation, *lightness);
-                Color::Rgba {
-                    red,
-                    green,
-                    blue,
-                    alpha: *alpha,
-                }
-            }
-        }
-    }
-
-    /// Converts a `Color` to variant `Color::RgbaLinear`
-    pub fn as_rgba_linear(self: &Color) -> Color {
-        match self {
-            Color::Rgba {
-                red,
-                green,
-                blue,
-                alpha,
-            } => Color::Rgba {
-                red: red.nonlinear_to_linear_srgb(),
-                green: green.nonlinear_to_linear_srgb(),
-                blue: blue.nonlinear_to_linear_srgb(),
-                alpha: *alpha,
-            },
-            Color::RgbaLinear { .. } => *self,
-            Color::Hsla {
-                hue,
-                saturation,
-                lightness,
-                alpha,
-            } => {
-                let [red, green, blue] =
-                    HslRepresentation::hsl_to_nonlinear_srgb(*hue, *saturation, *lightness);
-                Color::RgbaLinear {
-                    red: red.nonlinear_to_linear_srgb(),
-                    green: green.nonlinear_to_linear_srgb(),
-                    blue: blue.nonlinear_to_linear_srgb(),
-                    alpha: *alpha,
-                }
-            }
-        }
-    }
-
-    /// Converts a `Color` to variant `Color::Hsla`
-    pub fn as_hsla(self: &Color) -> Color {
-        match self {
-            Color::Rgba {
-                red,
-                green,
-                blue,
-                alpha,
-            } => {
-                let (hue, saturation, lightness) =
-                    HslRepresentation::nonlinear_srgb_to_hsl([*red, *green, *blue]);
-                Color::Hsla {
-                    hue,
-                    saturation,
-                    lightness,
-                    alpha: *alpha,
-                }
-            }
-            Color::RgbaLinear {
-                red,
-                green,
-                blue,
-                alpha,
-            } => {
-                let (hue, saturation, lightness) = HslRepresentation::nonlinear_srgb_to_hsl([
-                    red.linear_to_nonlinear_srgb(),
-                    green.linear_to_nonlinear_srgb(),
-                    blue.linear_to_nonlinear_srgb(),
-                ]);
-                Color::Hsla {
-                    hue,
-                    saturation,
-                    lightness,
-                    alpha: *alpha,
-                }
-            }
-            Color::Hsla { .. } => *self,
-        }
-    }
-
-    /// Converts a `Color` to a `[f32; 4]` from sRBG colorspace
-    pub fn as_rgba_f32(self: Color) -> [f32; 4] {
-        match self {
-            Color::Rgba {
-                red,
-                green,
-                blue,
-                alpha,
-            } => [red, green, blue, alpha],
-            Color::RgbaLinear {
-                red,
-                green,
-                blue,
-                alpha,
-            } => [
-                red.linear_to_nonlinear_srgb(),
-                green.linear_to_nonlinear_srgb(),
-                blue.linear_to_nonlinear_srgb(),
-                alpha,
-            ],
-            Color::Hsla {
-                hue,
-                saturation,
-                lightness,
-                alpha,
-            } => {
-                let [red, green, blue] =
-                    HslRepresentation::hsl_to_nonlinear_srgb(hue, saturation, lightness);
-                [red, green, blue, alpha]
-            }
-        }
-    }
-
-    /// Converts a `Color` to a `[f32; 4]` from linear RBG colorspace
-    pub fn as_linear_rgba_f32(self: Color) -> [f32; 4] {
-        match self {
-            Color::Rgba {
-                red,
-                green,
-                blue,
-                alpha,
-            } => [
-                red.nonlinear_to_linear_srgb(),
-                green.nonlinear_to_linear_srgb(),
-                blue.nonlinear_to_linear_srgb(),
-                alpha,
-            ],
-            Color::RgbaLinear {
-                red,
-                green,
-                blue,
-                alpha,
-            } => [red, green, blue, alpha],
-            Color::Hsla {
-                hue,
-                saturation,
-                lightness,
-                alpha,
-            } => {
-                let [red, green, blue] =
-                    HslRepresentation::hsl_to_nonlinear_srgb(hue, saturation, lightness);
-                [
-                    red.nonlinear_to_linear_srgb(),
-                    green.nonlinear_to_linear_srgb(),
-                    blue.nonlinear_to_linear_srgb(),
-                    alpha,
-                ]
-            }
-        }
-    }
-
-    /// Converts a `Color` to a `[f32; 4]` from HLS colorspace
-    pub fn as_hlsa_f32(self: Color) -> [f32; 4] {
-        match self {
-            Color::Rgba {
-                red,
-                green,
-                blue,
-                alpha,
-            } => {
-                let (hue, saturation, lightness) =
-                    HslRepresentation::nonlinear_srgb_to_hsl([red, green, blue]);
-                [hue, saturation, lightness, alpha]
-            }
-            Color::RgbaLinear {
-                red,
-                green,
-                blue,
-                alpha,
-            } => {
-                let (hue, saturation, lightness) = HslRepresentation::nonlinear_srgb_to_hsl([
-                    red.linear_to_nonlinear_srgb(),
-                    green.linear_to_nonlinear_srgb(),
-                    blue.linear_to_nonlinear_srgb(),
-                ]);
-                [hue, saturation, lightness, alpha]
-            }
-            Color::Hsla {
-                hue,
-                saturation,
-                lightness,
-                alpha,
-            } => [hue, saturation, lightness, alpha],
-        }
-    }
-}
-
-impl Default for Color {
-    fn default() -> Self {
-        Color::WHITE
-    }
-}
-
-impl AddAssign<Color> for Color {
-    fn add_assign(&mut self, rhs: Color) {
-        match self {
-            Color::Rgba {
-                red,
-                green,
-                blue,
-                alpha,
-            } => {
-                let rhs = rhs.as_rgba_f32();
-                *red += rhs[0];
-                *green += rhs[1];
-                *blue += rhs[2];
-                *alpha += rhs[3];
-            }
-            Color::RgbaLinear {
-                red,
-                green,
-                blue,
-                alpha,
-            } => {
-                let rhs = rhs.as_linear_rgba_f32();
-                *red += rhs[0];
-                *green += rhs[1];
-                *blue += rhs[2];
-                *alpha += rhs[3];
-            }
-            Color::Hsla {
-                hue,
-                saturation,
-                lightness,
-                alpha,
-            } => {
-                let rhs = rhs.as_linear_rgba_f32();
-                *hue += rhs[0];
-                *saturation += rhs[1];
-                *lightness += rhs[2];
-                *alpha += rhs[3];
-            }
-        }
-    }
-}
-
-impl Add<Color> for Color {
-    type Output = Color;
-
-    fn add(self, rhs: Color) -> Self::Output {
-        match self {
-            Color::Rgba {
-                red,
-                green,
-                blue,
-                alpha,
-            } => {
-                let rhs = rhs.as_rgba_f32();
-                Color::Rgba {
-                    red: red + rhs[0],
-                    green: green + rhs[1],
-                    blue: blue + rhs[2],
-                    alpha: alpha + rhs[3],
-                }
-            }
-            Color::RgbaLinear {
-                red,
-                green,
-                blue,
-                alpha,
-            } => {
-                let rhs = rhs.as_linear_rgba_f32();
-                Color::RgbaLinear {
-                    red: red + rhs[0],
-                    green: green + rhs[1],
-                    blue: blue + rhs[2],
-                    alpha: alpha + rhs[3],
-                }
-            }
-            Color::Hsla {
-                hue,
-                saturation,
-                lightness,
-                alpha,
-            } => {
-                let rhs = rhs.as_linear_rgba_f32();
-                Color::Hsla {
-                    hue: hue + rhs[0],
-                    saturation: saturation + rhs[1],
-                    lightness: lightness + rhs[2],
-                    alpha: alpha + rhs[3],
-                }
-            }
-        }
-    }
-}
-
-impl AddAssign<Vec4> for Color {
-    fn add_assign(&mut self, rhs: Vec4) {
-        let rhs: Color = rhs.into();
-        *self += rhs
-    }
-}
-
-impl Add<Vec4> for Color {
-    type Output = Color;
-
-    fn add(self, rhs: Vec4) -> Self::Output {
-        let rhs: Color = rhs.into();
-        self + rhs
-    }
-}
-
-impl From<Color> for [f32; 4] {
-    fn from(color: Color) -> Self {
-        color.as_rgba_f32()
-    }
-}
-
-impl From<[f32; 4]> for Color {
-    fn from([r, g, b, a]: [f32; 4]) -> Self {
-        Color::rgba(r, g, b, a)
-    }
-}
-
-impl From<Color> for Vec4 {
-    fn from(color: Color) -> Self {
-        let color: [f32; 4] = color.into();
-        Vec4::new(color[0], color[1], color[2], color[3])
-    }
-}
-
-impl From<Vec4> for Color {
-    fn from(vec4: Vec4) -> Self {
-        Color::rgba(vec4.x, vec4.y, vec4.z, vec4.w)
-    }
-}
-
-impl From<Color> for wgpu::Color {
-    fn from(color: Color) -> Self {
-        let color = color.as_rgba_linear();
-        wgpu::Color {
-            r: color.r() as f64,
-            g: color.g() as f64,
-            b: color.b() as f64,
-            a: color.a() as f64,
-        }
-    }
-}
-
-impl Mul<f32> for Color {
-    type Output = Color;
-
-    fn mul(self, rhs: f32) -> Self::Output {
-        match self {
-            Color::Rgba {
-                red,
-                green,
-                blue,
-                alpha,
-            } => Color::Rgba {
-                red: red * rhs,
-                green: green * rhs,
-                blue: blue * rhs,
-                alpha,
-            },
-            Color::RgbaLinear {
-                red,
-                green,
-                blue,
-                alpha,
-            } => Color::RgbaLinear {
-                red: red * rhs,
-                green: green * rhs,
-                blue: blue * rhs,
-                alpha,
-            },
-            Color::Hsla {
-                hue,
-                saturation,
-                lightness,
-                alpha,
-            } => Color::Hsla {
-                hue: hue * rhs,
-                saturation: saturation * rhs,
-                lightness: lightness * rhs,
-                alpha,
-            },
-        }
-    }
-}
-
-impl MulAssign<f32> for Color {
-    fn mul_assign(&mut self, rhs: f32) {
-        match self {
-            Color::Rgba {
-                red, green, blue, ..
-            } => {
-                *red *= rhs;
-                *green *= rhs;
-                *blue *= rhs;
-            }
-            Color::RgbaLinear {
-                red, green, blue, ..
-            } => {
-                *red *= rhs;
-                *green *= rhs;
-                *blue *= rhs;
-            }
-            Color::Hsla {
-                hue,
-                saturation,
-                lightness,
-                ..
-            } => {
-                *hue *= rhs;
-                *saturation *= rhs;
-                *lightness *= rhs;
-            }
-        }
-    }
-}
-
-impl Mul<Vec4> for Color {
-    type Output = Color;
-
-    fn mul(self, rhs: Vec4) -> Self::Output {
-        match self {
-            Color::Rgba {
-                red,
-                green,
-                blue,
-                alpha,
-            } => Color::Rgba {
-                red: red * rhs.x,
-                green: green * rhs.y,
-                blue: blue * rhs.z,
-                alpha: alpha * rhs.w,
-            },
-            Color::RgbaLinear {
-                red,
-                green,
-                blue,
-                alpha,
-            } => Color::RgbaLinear {
-                red: red * rhs.x,
-                green: green * rhs.y,
-                blue: blue * rhs.z,
-                alpha: alpha * rhs.w,
-            },
-            Color::Hsla {
-                hue,
-                saturation,
-                lightness,
-                alpha,
-            } => Color::Hsla {
-                hue: hue * rhs.x,
-                saturation: saturation * rhs.y,
-                lightness: lightness * rhs.z,
-                alpha: alpha * rhs.w,
-            },
-        }
-    }
-}
-
-impl MulAssign<Vec4> for Color {
-    fn mul_assign(&mut self, rhs: Vec4) {
-        match self {
-            Color::Rgba {
-                red,
-                green,
-                blue,
-                alpha,
-            } => {
-                *red *= rhs.x;
-                *green *= rhs.y;
-                *blue *= rhs.z;
-                *alpha *= rhs.w;
-            }
-            Color::RgbaLinear {
-                red,
-                green,
-                blue,
-                alpha,
-            } => {
-                *red *= rhs.x;
-                *green *= rhs.y;
-                *blue *= rhs.z;
-                *alpha *= rhs.w;
-            }
-            Color::Hsla {
-                hue,
-                saturation,
-                lightness,
-                alpha,
-            } => {
-                *hue *= rhs.x;
-                *saturation *= rhs.y;
-                *lightness *= rhs.z;
-                *alpha *= rhs.w;
-            }
-        }
-    }
-}
-
-impl Mul<Vec3> for Color {
-    type Output = Color;
-
-    fn mul(self, rhs: Vec3) -> Self::Output {
-        match self {
-            Color::Rgba {
-                red,
-                green,
-                blue,
-                alpha,
-            } => Color::Rgba {
-                red: red * rhs.x,
-                green: green * rhs.y,
-                blue: blue * rhs.z,
-                alpha,
-            },
-            Color::RgbaLinear {
-                red,
-                green,
-                blue,
-                alpha,
-            } => Color::RgbaLinear {
-                red: red * rhs.x,
-                green: green * rhs.y,
-                blue: blue * rhs.z,
-                alpha,
-            },
-            Color::Hsla {
-                hue,
-                saturation,
-                lightness,
-                alpha,
-            } => Color::Hsla {
-                hue: hue * rhs.x,
-                saturation: saturation * rhs.y,
-                lightness: lightness * rhs.z,
-                alpha,
-            },
-        }
-    }
-}
-
-impl MulAssign<Vec3> for Color {
-    fn mul_assign(&mut self, rhs: Vec3) {
-        match self {
-            Color::Rgba {
-                red, green, blue, ..
-            } => {
-                *red *= rhs.x;
-                *green *= rhs.y;
-                *blue *= rhs.z;
-            }
-            Color::RgbaLinear {
-                red, green, blue, ..
-            } => {
-                *red *= rhs.x;
-                *green *= rhs.y;
-                *blue *= rhs.z;
-            }
-            Color::Hsla {
-                hue,
-                saturation,
-                lightness,
-                ..
-            } => {
-                *hue *= rhs.x;
-                *saturation *= rhs.y;
-                *lightness *= rhs.z;
-            }
-        }
-    }
-}
-
-impl Mul<[f32; 4]> for Color {
-    type Output = Color;
-
-    fn mul(self, rhs: [f32; 4]) -> Self::Output {
-        match self {
-            Color::Rgba {
-                red,
-                green,
-                blue,
-                alpha,
-            } => Color::Rgba {
-                red: red * rhs[0],
-                green: green * rhs[1],
-                blue: blue * rhs[2],
-                alpha: alpha * rhs[3],
-            },
-            Color::RgbaLinear {
-                red,
-                green,
-                blue,
-                alpha,
-            } => Color::RgbaLinear {
-                red: red * rhs[0],
-                green: green * rhs[1],
-                blue: blue * rhs[2],
-                alpha: alpha * rhs[3],
-            },
-            Color::Hsla {
-                hue,
-                saturation,
-                lightness,
-                alpha,
-            } => Color::Hsla {
-                hue: hue * rhs[0],
-                saturation: saturation * rhs[1],
-                lightness: lightness * rhs[2],
-                alpha: alpha * rhs[3],
-            },
-        }
-    }
-}
-
-impl MulAssign<[f32; 4]> for Color {
-    fn mul_assign(&mut self, rhs: [f32; 4]) {
-        match self {
-            Color::Rgba {
-                red,
-                green,
-                blue,
-                alpha,
-            } => {
-                *red *= rhs[0];
-                *green *= rhs[1];
-                *blue *= rhs[2];
-                *alpha *= rhs[3];
-            }
-            Color::RgbaLinear {
-                red,
-                green,
-                blue,
-                alpha,
-            } => {
-                *red *= rhs[0];
-                *green *= rhs[1];
-                *blue *= rhs[2];
-                *alpha *= rhs[3];
-            }
-            Color::Hsla {
-                hue,
-                saturation,
-                lightness,
-                alpha,
-            } => {
-                *hue *= rhs[0];
-                *saturation *= rhs[1];
-                *lightness *= rhs[2];
-                *alpha *= rhs[3];
-            }
-        }
-    }
-}
-
-impl Mul<[f32; 3]> for Color {
-    type Output = Color;
-
-    fn mul(self, rhs: [f32; 3]) -> Self::Output {
-        match self {
-            Color::Rgba {
-                red,
-                green,
-                blue,
-                alpha,
-            } => Color::Rgba {
-                red: red * rhs[0],
-                green: green * rhs[1],
-                blue: blue * rhs[2],
-                alpha,
-            },
-            Color::RgbaLinear {
-                red,
-                green,
-                blue,
-                alpha,
-            } => Color::RgbaLinear {
-                red: red * rhs[0],
-                green: green * rhs[1],
-                blue: blue * rhs[2],
-                alpha,
-            },
-            Color::Hsla {
-                hue,
-                saturation,
-                lightness,
-                alpha,
-            } => Color::Hsla {
-                hue: hue * rhs[0],
-                saturation: saturation * rhs[1],
-                lightness: lightness * rhs[2],
-                alpha,
-            },
-        }
-    }
-}
-
-impl MulAssign<[f32; 3]> for Color {
-    fn mul_assign(&mut self, rhs: [f32; 3]) {
-        match self {
-            Color::Rgba {
-                red, green, blue, ..
-            } => {
-                *red *= rhs[0];
-                *green *= rhs[1];
-                *blue *= rhs[2];
-            }
-            Color::RgbaLinear {
-                red, green, blue, ..
-            } => {
-                *red *= rhs[0];
-                *green *= rhs[1];
-                *blue *= rhs[2];
-            }
-            Color::Hsla {
-                hue,
-                saturation,
-                lightness,
-                ..
-            } => {
-                *hue *= rhs[0];
-                *saturation *= rhs[1];
-                *lightness *= rhs[2];
-            }
-        }
-    }
-}
-
-impl Bytes for Color {
-    fn write_bytes(&self, buffer: &mut [u8]) {
-        match *self {
-            Color::Rgba {
-                red,
-                green,
-                blue,
-                alpha,
-            } => {
-                red.nonlinear_to_linear_srgb().write_bytes(buffer);
-                green
-                    .nonlinear_to_linear_srgb()
-                    .write_bytes(&mut buffer[std::mem::size_of::<f32>()..]);
-                blue.nonlinear_to_linear_srgb()
-                    .write_bytes(&mut buffer[2 * std::mem::size_of::<f32>()..]);
-                alpha.write_bytes(&mut buffer[3 * std::mem::size_of::<f32>()..]);
-            }
-            Color::RgbaLinear {
-                red,
-                green,
-                blue,
-                alpha,
-            } => {
-                red.write_bytes(buffer);
-                green.write_bytes(&mut buffer[std::mem::size_of::<f32>()..]);
-                blue.write_bytes(&mut buffer[2 * std::mem::size_of::<f32>()..]);
-                alpha.write_bytes(&mut buffer[3 * std::mem::size_of::<f32>()..]);
-            }
-            Color::Hsla {
-                hue,
-                saturation,
-                lightness,
-                alpha,
-            } => {
-                let [red, green, blue] =
-                    HslRepresentation::hsl_to_nonlinear_srgb(hue, saturation, lightness);
-                red.nonlinear_to_linear_srgb().write_bytes(buffer);
-                green
-                    .nonlinear_to_linear_srgb()
-                    .write_bytes(&mut buffer[std::mem::size_of::<f32>()..]);
-                blue.nonlinear_to_linear_srgb()
-                    .write_bytes(&mut buffer[std::mem::size_of::<f32>() * 2..]);
-                alpha.write_bytes(&mut buffer[std::mem::size_of::<f32>() * 3..]);
-            }
-        }
-    }
-
-    fn byte_len(&self) -> usize {
-        std::mem::size_of::<f32>() * 4
-    }
-}
-
-#[derive(Debug)]
-pub enum HexColorError {
-    Length,
-    Hex(hex::FromHexError),
-}
-
-fn decode_rgb(data: &[u8]) -> Result<Color, HexColorError> {
-    let mut buf = [0; 3];
-    match hex::decode_to_slice(data, &mut buf) {
-        Ok(_) => {
-            let r = buf[0] as f32 / 255.0;
-            let g = buf[1] as f32 / 255.0;
-            let b = buf[2] as f32 / 255.0;
-            Ok(Color::rgb(r, g, b))
-        }
-        Err(err) => Err(HexColorError::Hex(err)),
-    }
-}
-
-fn decode_rgba(data: &[u8]) -> Result<Color, HexColorError> {
-    let mut buf = [0; 4];
-    match hex::decode_to_slice(data, &mut buf) {
-        Ok(_) => {
-            let r = buf[0] as f32 / 255.0;
-            let g = buf[1] as f32 / 255.0;
-            let b = buf[2] as f32 / 255.0;
-            let a = buf[3] as f32 / 255.0;
-            Ok(Color::rgba(r, g, b, a))
-        }
-        Err(err) => Err(HexColorError::Hex(err)),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn hex_color() {
-        assert_eq!(Color::hex("FFF").unwrap(), Color::rgb(1.0, 1.0, 1.0));
-        assert_eq!(Color::hex("000").unwrap(), Color::rgb(0.0, 0.0, 0.0));
-        assert!(Color::hex("---").is_err());
-
-        assert_eq!(Color::hex("FFFF").unwrap(), Color::rgba(1.0, 1.0, 1.0, 1.0));
-        assert_eq!(Color::hex("0000").unwrap(), Color::rgba(0.0, 0.0, 0.0, 0.0));
-        assert!(Color::hex("----").is_err());
-
-        assert_eq!(Color::hex("FFFFFF").unwrap(), Color::rgb(1.0, 1.0, 1.0));
-        assert_eq!(Color::hex("000000").unwrap(), Color::rgb(0.0, 0.0, 0.0));
-        assert!(Color::hex("------").is_err());
-
-        assert_eq!(
-            Color::hex("FFFFFFFF").unwrap(),
-            Color::rgba(1.0, 1.0, 1.0, 1.0)
-        );
-        assert_eq!(
-            Color::hex("00000000").unwrap(),
-            Color::rgba(0.0, 0.0, 0.0, 0.0)
-        );
-        assert!(Color::hex("--------").is_err());
-
-        assert!(Color::hex("1234567890").is_err());
-    }
-
-    #[test]
-    fn conversions_vec4() {
-        let starting_vec4 = Vec4::new(0.4, 0.5, 0.6, 1.0);
-        let starting_color = Color::from(starting_vec4);
-
-        assert_eq!(starting_vec4, Vec4::from(starting_color),);
-
-        let transformation = Vec4::new(0.5, 0.5, 0.5, 1.0);
-
-        assert_eq!(
-            starting_color * transformation,
-            Color::from(starting_vec4 * transformation),
-        );
-    }
-
-    #[test]
-    fn mul_and_mulassign_f32() {
-        let transformation = 0.5;
-        let starting_color = Color::rgba(0.4, 0.5, 0.6, 1.0);
-
-        assert_eq!(
-            starting_color * transformation,
-            Color::rgba(0.4 * 0.5, 0.5 * 0.5, 0.6 * 0.5, 1.0),
-        );
-
-        let mut mutated_color = starting_color;
-        mutated_color *= transformation;
-
-        assert_eq!(starting_color * transformation, mutated_color,);
-    }
-
-    #[test]
-    fn mul_and_mulassign_f32by3() {
-        let transformation = [0.4, 0.5, 0.6];
-        let starting_color = Color::rgba(0.4, 0.5, 0.6, 1.0);
-
-        assert_eq!(
-            starting_color * transformation,
-            Color::rgba(0.4 * 0.4, 0.5 * 0.5, 0.6 * 0.6, 1.0),
-        );
-
-        let mut mutated_color = starting_color;
-        mutated_color *= transformation;
-
-        assert_eq!(starting_color * transformation, mutated_color,);
-    }
-
-    #[test]
-    fn mul_and_mulassign_f32by4() {
-        let transformation = [0.4, 0.5, 0.6, 0.9];
-        let starting_color = Color::rgba(0.4, 0.5, 0.6, 1.0);
-
-        assert_eq!(
-            starting_color * transformation,
-            Color::rgba(0.4 * 0.4, 0.5 * 0.5, 0.6 * 0.6, 1.0 * 0.9),
-        );
-
-        let mut mutated_color = starting_color;
-        mutated_color *= transformation;
-
-        assert_eq!(starting_color * transformation, mutated_color,);
-    }
-
-    #[test]
-    fn mul_and_mulassign_vec3() {
-        let transformation = Vec3::new(0.2, 0.3, 0.4);
-        let starting_color = Color::rgba(0.4, 0.5, 0.6, 1.0);
-
-        assert_eq!(
-            starting_color * transformation,
-            Color::rgba(0.4 * 0.2, 0.5 * 0.3, 0.6 * 0.4, 1.0),
-        );
-
-        let mut mutated_color = starting_color;
-        mutated_color *= transformation;
-
-        assert_eq!(starting_color * transformation, mutated_color,);
-    }
-
-    #[test]
-    fn mul_and_mulassign_vec4() {
-        let transformation = Vec4::new(0.2, 0.3, 0.4, 0.5);
-        let starting_color = Color::rgba(0.4, 0.5, 0.6, 1.0);
-
-        assert_eq!(
-            starting_color * transformation,
-            Color::rgba(0.4 * 0.2, 0.5 * 0.3, 0.6 * 0.4, 1.0 * 0.5),
-        );
-
-        let mut mutated_color = starting_color;
-        mutated_color *= transformation;
-
-        assert_eq!(starting_color * transformation, mutated_color,);
-    }
-}
diff --git a/pipelined/bevy_render2/src/color/mod.rs b/pipelined/bevy_render2/src/color/mod.rs
index cba45f1b7e..0a6ab6e3a8 100644
--- a/pipelined/bevy_render2/src/color/mod.rs
+++ b/pipelined/bevy_render2/src/color/mod.rs
@@ -1,5 +1,1238 @@
-mod color;
 mod colorspace;
 
-pub use color::*;
 pub use colorspace::*;
+
+use crate::color::{HslRepresentation, SrgbColorSpace};
+use bevy_core::Bytes;
+use bevy_math::{Vec3, Vec4};
+use bevy_reflect::{Reflect, ReflectDeserialize};
+use serde::{Deserialize, Serialize};
+use std::ops::{Add, AddAssign, Mul, MulAssign};
+
+#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize, Reflect)]
+#[reflect(PartialEq, Serialize, Deserialize)]
+pub enum Color {
+    /// sRGBA color
+    Rgba {
+        /// Red component. [0.0, 1.0]
+        red: f32,
+        /// Green component. [0.0, 1.0]
+        green: f32,
+        /// Blue component. [0.0, 1.0]
+        blue: f32,
+        /// Alpha component. [0.0, 1.0]
+        alpha: f32,
+    },
+    /// RGBA color in the Linear sRGB colorspace (often colloquially referred to as "linear", "RGB", or "linear RGB").
+    RgbaLinear {
+        /// Red component. [0.0, 1.0]
+        red: f32,
+        /// Green component. [0.0, 1.0]
+        green: f32,
+        /// Blue component. [0.0, 1.0]
+        blue: f32,
+        /// Alpha component. [0.0, 1.0]
+        alpha: f32,
+    },
+    /// HSL (hue, saturation, lightness) color with an alpha channel
+    Hsla {
+        /// Hue component. [0.0, 360.0]
+        hue: f32,
+        /// Saturation component. [0.0, 1.0]
+        saturation: f32,
+        /// Lightness component. [0.0, 1.0]
+        lightness: f32,
+        /// Alpha component. [0.0, 1.0]
+        alpha: f32,
+    },
+}
+
+impl Color {
+    pub const ALICE_BLUE: Color = Color::rgb(0.94, 0.97, 1.0);
+    pub const ANTIQUE_WHITE: Color = Color::rgb(0.98, 0.92, 0.84);
+    pub const AQUAMARINE: Color = Color::rgb(0.49, 1.0, 0.83);
+    pub const AZURE: Color = Color::rgb(0.94, 1.0, 1.0);
+    pub const BEIGE: Color = Color::rgb(0.96, 0.96, 0.86);
+    pub const BISQUE: Color = Color::rgb(1.0, 0.89, 0.77);
+    pub const BLACK: Color = Color::rgb(0.0, 0.0, 0.0);
+    pub const BLUE: Color = Color::rgb(0.0, 0.0, 1.0);
+    pub const CRIMSON: Color = Color::rgb(0.86, 0.08, 0.24);
+    pub const CYAN: Color = Color::rgb(0.0, 1.0, 1.0);
+    pub const DARK_GRAY: Color = Color::rgb(0.25, 0.25, 0.25);
+    pub const DARK_GREEN: Color = Color::rgb(0.0, 0.5, 0.0);
+    pub const FUCHSIA: Color = Color::rgb(1.0, 0.0, 1.0);
+    pub const GOLD: Color = Color::rgb(1.0, 0.84, 0.0);
+    pub const GRAY: Color = Color::rgb(0.5, 0.5, 0.5);
+    pub const GREEN: Color = Color::rgb(0.0, 1.0, 0.0);
+    pub const INDIGO: Color = Color::rgb(0.29, 0.0, 0.51);
+    pub const LIME_GREEN: Color = Color::rgb(0.2, 0.8, 0.2);
+    pub const MAROON: Color = Color::rgb(0.5, 0.0, 0.0);
+    pub const MIDNIGHT_BLUE: Color = Color::rgb(0.1, 0.1, 0.44);
+    pub const NAVY: Color = Color::rgb(0.0, 0.0, 0.5);
+    pub const NONE: Color = Color::rgba(0.0, 0.0, 0.0, 0.0);
+    pub const OLIVE: Color = Color::rgb(0.5, 0.5, 0.0);
+    pub const ORANGE: Color = Color::rgb(1.0, 0.65, 0.0);
+    pub const ORANGE_RED: Color = Color::rgb(1.0, 0.27, 0.0);
+    pub const PINK: Color = Color::rgb(1.0, 0.08, 0.58);
+    pub const PURPLE: Color = Color::rgb(0.5, 0.0, 0.5);
+    pub const RED: Color = Color::rgb(1.0, 0.0, 0.0);
+    pub const SALMON: Color = Color::rgb(0.98, 0.5, 0.45);
+    pub const SEA_GREEN: Color = Color::rgb(0.18, 0.55, 0.34);
+    pub const SILVER: Color = Color::rgb(0.75, 0.75, 0.75);
+    pub const TEAL: Color = Color::rgb(0.0, 0.5, 0.5);
+    pub const TOMATO: Color = Color::rgb(1.0, 0.39, 0.28);
+    pub const TURQUOISE: Color = Color::rgb(0.25, 0.88, 0.82);
+    pub const VIOLET: Color = Color::rgb(0.93, 0.51, 0.93);
+    pub const WHITE: Color = Color::rgb(1.0, 1.0, 1.0);
+    pub const YELLOW: Color = Color::rgb(1.0, 1.0, 0.0);
+    pub const YELLOW_GREEN: Color = Color::rgb(0.6, 0.8, 0.2);
+
+    /// New `Color` from sRGB colorspace.
+    pub const fn rgb(r: f32, g: f32, b: f32) -> Color {
+        Color::Rgba {
+            red: r,
+            green: g,
+            blue: b,
+            alpha: 1.0,
+        }
+    }
+
+    /// New `Color` from sRGB colorspace.
+    pub const fn rgba(r: f32, g: f32, b: f32, a: f32) -> Color {
+        Color::Rgba {
+            red: r,
+            green: g,
+            blue: b,
+            alpha: a,
+        }
+    }
+
+    /// New `Color` from linear RGB colorspace.
+    pub const fn rgb_linear(r: f32, g: f32, b: f32) -> Color {
+        Color::RgbaLinear {
+            red: r,
+            green: g,
+            blue: b,
+            alpha: 1.0,
+        }
+    }
+
+    /// New `Color` from linear RGB colorspace.
+    pub const fn rgba_linear(r: f32, g: f32, b: f32, a: f32) -> Color {
+        Color::RgbaLinear {
+            red: r,
+            green: g,
+            blue: b,
+            alpha: a,
+        }
+    }
+
+    /// New `Color` with HSL representation in sRGB colorspace.
+    pub const fn hsl(hue: f32, saturation: f32, lightness: f32) -> Color {
+        Color::Hsla {
+            hue,
+            saturation,
+            lightness,
+            alpha: 1.0,
+        }
+    }
+
+    /// New `Color` with HSL representation in sRGB colorspace.
+    pub const fn hsla(hue: f32, saturation: f32, lightness: f32, alpha: f32) -> Color {
+        Color::Hsla {
+            hue,
+            saturation,
+            lightness,
+            alpha,
+        }
+    }
+
+    /// New `Color` from sRGB colorspace.
+    pub fn hex<T: AsRef<str>>(hex: T) -> Result<Color, HexColorError> {
+        let hex = hex.as_ref();
+
+        // RGB
+        if hex.len() == 3 {
+            let mut data = [0; 6];
+            for (i, ch) in hex.chars().enumerate() {
+                data[i * 2] = ch as u8;
+                data[i * 2 + 1] = ch as u8;
+            }
+            return decode_rgb(&data);
+        }
+
+        // RGBA
+        if hex.len() == 4 {
+            let mut data = [0; 8];
+            for (i, ch) in hex.chars().enumerate() {
+                data[i * 2] = ch as u8;
+                data[i * 2 + 1] = ch as u8;
+            }
+            return decode_rgba(&data);
+        }
+
+        // RRGGBB
+        if hex.len() == 6 {
+            return decode_rgb(hex.as_bytes());
+        }
+
+        // RRGGBBAA
+        if hex.len() == 8 {
+            return decode_rgba(hex.as_bytes());
+        }
+
+        Err(HexColorError::Length)
+    }
+
+    /// New `Color` from sRGB colorspace.
+    pub fn rgb_u8(r: u8, g: u8, b: u8) -> Color {
+        Color::rgba_u8(r, g, b, u8::MAX)
+    }
+
+    // Float operations in const fn are not stable yet
+    // see https://github.com/rust-lang/rust/issues/57241
+    /// New `Color` from sRGB colorspace.
+    pub fn rgba_u8(r: u8, g: u8, b: u8, a: u8) -> Color {
+        Color::rgba(
+            r as f32 / u8::MAX as f32,
+            g as f32 / u8::MAX as f32,
+            b as f32 / u8::MAX as f32,
+            a as f32 / u8::MAX as f32,
+        )
+    }
+
+    /// Get red in sRGB colorspace.
+    pub fn r(&self) -> f32 {
+        match self.as_rgba() {
+            Color::Rgba { red, .. } => red,
+            _ => unreachable!(),
+        }
+    }
+
+    /// Get green in sRGB colorspace.
+    pub fn g(&self) -> f32 {
+        match self.as_rgba() {
+            Color::Rgba { green, .. } => green,
+            _ => unreachable!(),
+        }
+    }
+
+    /// Get blue in sRGB colorspace.
+    pub fn b(&self) -> f32 {
+        match self.as_rgba() {
+            Color::Rgba { blue, .. } => blue,
+            _ => unreachable!(),
+        }
+    }
+
+    /// Set red in sRGB colorspace.
+    pub fn set_r(&mut self, r: f32) -> &mut Self {
+        *self = self.as_rgba();
+        match self {
+            Color::Rgba { red, .. } => *red = r,
+            _ => unreachable!(),
+        }
+        self
+    }
+
+    /// Set green in sRGB colorspace.
+    pub fn set_g(&mut self, g: f32) -> &mut Self {
+        *self = self.as_rgba();
+        match self {
+            Color::Rgba { green, .. } => *green = g,
+            _ => unreachable!(),
+        }
+        self
+    }
+
+    /// Set blue in sRGB colorspace.
+    pub fn set_b(&mut self, b: f32) -> &mut Self {
+        *self = self.as_rgba();
+        match self {
+            Color::Rgba { blue, .. } => *blue = b,
+            _ => unreachable!(),
+        }
+        self
+    }
+
+    /// Get alpha.
+    pub fn a(&self) -> f32 {
+        match self {
+            Color::Rgba { alpha, .. }
+            | Color::RgbaLinear { alpha, .. }
+            | Color::Hsla { alpha, .. } => *alpha,
+        }
+    }
+
+    /// Set alpha.
+    pub fn set_a(&mut self, a: f32) -> &mut Self {
+        match self {
+            Color::Rgba { alpha, .. }
+            | Color::RgbaLinear { alpha, .. }
+            | Color::Hsla { alpha, .. } => {
+                *alpha = a;
+            }
+        }
+        self
+    }
+
+    /// Converts a `Color` to variant `Color::Rgba`
+    pub fn as_rgba(self: &Color) -> Color {
+        match self {
+            Color::Rgba { .. } => *self,
+            Color::RgbaLinear {
+                red,
+                green,
+                blue,
+                alpha,
+            } => Color::Rgba {
+                red: red.linear_to_nonlinear_srgb(),
+                green: green.linear_to_nonlinear_srgb(),
+                blue: blue.linear_to_nonlinear_srgb(),
+                alpha: *alpha,
+            },
+            Color::Hsla {
+                hue,
+                saturation,
+                lightness,
+                alpha,
+            } => {
+                let [red, green, blue] =
+                    HslRepresentation::hsl_to_nonlinear_srgb(*hue, *saturation, *lightness);
+                Color::Rgba {
+                    red,
+                    green,
+                    blue,
+                    alpha: *alpha,
+                }
+            }
+        }
+    }
+
+    /// Converts a `Color` to variant `Color::RgbaLinear`
+    pub fn as_rgba_linear(self: &Color) -> Color {
+        match self {
+            Color::Rgba {
+                red,
+                green,
+                blue,
+                alpha,
+            } => Color::Rgba {
+                red: red.nonlinear_to_linear_srgb(),
+                green: green.nonlinear_to_linear_srgb(),
+                blue: blue.nonlinear_to_linear_srgb(),
+                alpha: *alpha,
+            },
+            Color::RgbaLinear { .. } => *self,
+            Color::Hsla {
+                hue,
+                saturation,
+                lightness,
+                alpha,
+            } => {
+                let [red, green, blue] =
+                    HslRepresentation::hsl_to_nonlinear_srgb(*hue, *saturation, *lightness);
+                Color::RgbaLinear {
+                    red: red.nonlinear_to_linear_srgb(),
+                    green: green.nonlinear_to_linear_srgb(),
+                    blue: blue.nonlinear_to_linear_srgb(),
+                    alpha: *alpha,
+                }
+            }
+        }
+    }
+
+    /// Converts a `Color` to variant `Color::Hsla`
+    pub fn as_hsla(self: &Color) -> Color {
+        match self {
+            Color::Rgba {
+                red,
+                green,
+                blue,
+                alpha,
+            } => {
+                let (hue, saturation, lightness) =
+                    HslRepresentation::nonlinear_srgb_to_hsl([*red, *green, *blue]);
+                Color::Hsla {
+                    hue,
+                    saturation,
+                    lightness,
+                    alpha: *alpha,
+                }
+            }
+            Color::RgbaLinear {
+                red,
+                green,
+                blue,
+                alpha,
+            } => {
+                let (hue, saturation, lightness) = HslRepresentation::nonlinear_srgb_to_hsl([
+                    red.linear_to_nonlinear_srgb(),
+                    green.linear_to_nonlinear_srgb(),
+                    blue.linear_to_nonlinear_srgb(),
+                ]);
+                Color::Hsla {
+                    hue,
+                    saturation,
+                    lightness,
+                    alpha: *alpha,
+                }
+            }
+            Color::Hsla { .. } => *self,
+        }
+    }
+
+    /// Converts a `Color` to a `[f32; 4]` from sRBG colorspace
+    pub fn as_rgba_f32(self: Color) -> [f32; 4] {
+        match self {
+            Color::Rgba {
+                red,
+                green,
+                blue,
+                alpha,
+            } => [red, green, blue, alpha],
+            Color::RgbaLinear {
+                red,
+                green,
+                blue,
+                alpha,
+            } => [
+                red.linear_to_nonlinear_srgb(),
+                green.linear_to_nonlinear_srgb(),
+                blue.linear_to_nonlinear_srgb(),
+                alpha,
+            ],
+            Color::Hsla {
+                hue,
+                saturation,
+                lightness,
+                alpha,
+            } => {
+                let [red, green, blue] =
+                    HslRepresentation::hsl_to_nonlinear_srgb(hue, saturation, lightness);
+                [red, green, blue, alpha]
+            }
+        }
+    }
+
+    /// Converts a `Color` to a `[f32; 4]` from linear RBG colorspace
+    pub fn as_linear_rgba_f32(self: Color) -> [f32; 4] {
+        match self {
+            Color::Rgba {
+                red,
+                green,
+                blue,
+                alpha,
+            } => [
+                red.nonlinear_to_linear_srgb(),
+                green.nonlinear_to_linear_srgb(),
+                blue.nonlinear_to_linear_srgb(),
+                alpha,
+            ],
+            Color::RgbaLinear {
+                red,
+                green,
+                blue,
+                alpha,
+            } => [red, green, blue, alpha],
+            Color::Hsla {
+                hue,
+                saturation,
+                lightness,
+                alpha,
+            } => {
+                let [red, green, blue] =
+                    HslRepresentation::hsl_to_nonlinear_srgb(hue, saturation, lightness);
+                [
+                    red.nonlinear_to_linear_srgb(),
+                    green.nonlinear_to_linear_srgb(),
+                    blue.nonlinear_to_linear_srgb(),
+                    alpha,
+                ]
+            }
+        }
+    }
+
+    /// Converts a `Color` to a `[f32; 4]` from HLS colorspace
+    pub fn as_hlsa_f32(self: Color) -> [f32; 4] {
+        match self {
+            Color::Rgba {
+                red,
+                green,
+                blue,
+                alpha,
+            } => {
+                let (hue, saturation, lightness) =
+                    HslRepresentation::nonlinear_srgb_to_hsl([red, green, blue]);
+                [hue, saturation, lightness, alpha]
+            }
+            Color::RgbaLinear {
+                red,
+                green,
+                blue,
+                alpha,
+            } => {
+                let (hue, saturation, lightness) = HslRepresentation::nonlinear_srgb_to_hsl([
+                    red.linear_to_nonlinear_srgb(),
+                    green.linear_to_nonlinear_srgb(),
+                    blue.linear_to_nonlinear_srgb(),
+                ]);
+                [hue, saturation, lightness, alpha]
+            }
+            Color::Hsla {
+                hue,
+                saturation,
+                lightness,
+                alpha,
+            } => [hue, saturation, lightness, alpha],
+        }
+    }
+}
+
+impl Default for Color {
+    fn default() -> Self {
+        Color::WHITE
+    }
+}
+
+impl AddAssign<Color> for Color {
+    fn add_assign(&mut self, rhs: Color) {
+        match self {
+            Color::Rgba {
+                red,
+                green,
+                blue,
+                alpha,
+            } => {
+                let rhs = rhs.as_rgba_f32();
+                *red += rhs[0];
+                *green += rhs[1];
+                *blue += rhs[2];
+                *alpha += rhs[3];
+            }
+            Color::RgbaLinear {
+                red,
+                green,
+                blue,
+                alpha,
+            } => {
+                let rhs = rhs.as_linear_rgba_f32();
+                *red += rhs[0];
+                *green += rhs[1];
+                *blue += rhs[2];
+                *alpha += rhs[3];
+            }
+            Color::Hsla {
+                hue,
+                saturation,
+                lightness,
+                alpha,
+            } => {
+                let rhs = rhs.as_linear_rgba_f32();
+                *hue += rhs[0];
+                *saturation += rhs[1];
+                *lightness += rhs[2];
+                *alpha += rhs[3];
+            }
+        }
+    }
+}
+
+impl Add<Color> for Color {
+    type Output = Color;
+
+    fn add(self, rhs: Color) -> Self::Output {
+        match self {
+            Color::Rgba {
+                red,
+                green,
+                blue,
+                alpha,
+            } => {
+                let rhs = rhs.as_rgba_f32();
+                Color::Rgba {
+                    red: red + rhs[0],
+                    green: green + rhs[1],
+                    blue: blue + rhs[2],
+                    alpha: alpha + rhs[3],
+                }
+            }
+            Color::RgbaLinear {
+                red,
+                green,
+                blue,
+                alpha,
+            } => {
+                let rhs = rhs.as_linear_rgba_f32();
+                Color::RgbaLinear {
+                    red: red + rhs[0],
+                    green: green + rhs[1],
+                    blue: blue + rhs[2],
+                    alpha: alpha + rhs[3],
+                }
+            }
+            Color::Hsla {
+                hue,
+                saturation,
+                lightness,
+                alpha,
+            } => {
+                let rhs = rhs.as_linear_rgba_f32();
+                Color::Hsla {
+                    hue: hue + rhs[0],
+                    saturation: saturation + rhs[1],
+                    lightness: lightness + rhs[2],
+                    alpha: alpha + rhs[3],
+                }
+            }
+        }
+    }
+}
+
+impl AddAssign<Vec4> for Color {
+    fn add_assign(&mut self, rhs: Vec4) {
+        let rhs: Color = rhs.into();
+        *self += rhs
+    }
+}
+
+impl Add<Vec4> for Color {
+    type Output = Color;
+
+    fn add(self, rhs: Vec4) -> Self::Output {
+        let rhs: Color = rhs.into();
+        self + rhs
+    }
+}
+
+impl From<Color> for [f32; 4] {
+    fn from(color: Color) -> Self {
+        color.as_rgba_f32()
+    }
+}
+
+impl From<[f32; 4]> for Color {
+    fn from([r, g, b, a]: [f32; 4]) -> Self {
+        Color::rgba(r, g, b, a)
+    }
+}
+
+impl From<Color> for Vec4 {
+    fn from(color: Color) -> Self {
+        let color: [f32; 4] = color.into();
+        Vec4::new(color[0], color[1], color[2], color[3])
+    }
+}
+
+impl From<Vec4> for Color {
+    fn from(vec4: Vec4) -> Self {
+        Color::rgba(vec4.x, vec4.y, vec4.z, vec4.w)
+    }
+}
+
+impl From<Color> for wgpu::Color {
+    fn from(color: Color) -> Self {
+        let color = color.as_rgba_linear();
+        wgpu::Color {
+            r: color.r() as f64,
+            g: color.g() as f64,
+            b: color.b() as f64,
+            a: color.a() as f64,
+        }
+    }
+}
+
+impl Mul<f32> for Color {
+    type Output = Color;
+
+    fn mul(self, rhs: f32) -> Self::Output {
+        match self {
+            Color::Rgba {
+                red,
+                green,
+                blue,
+                alpha,
+            } => Color::Rgba {
+                red: red * rhs,
+                green: green * rhs,
+                blue: blue * rhs,
+                alpha,
+            },
+            Color::RgbaLinear {
+                red,
+                green,
+                blue,
+                alpha,
+            } => Color::RgbaLinear {
+                red: red * rhs,
+                green: green * rhs,
+                blue: blue * rhs,
+                alpha,
+            },
+            Color::Hsla {
+                hue,
+                saturation,
+                lightness,
+                alpha,
+            } => Color::Hsla {
+                hue: hue * rhs,
+                saturation: saturation * rhs,
+                lightness: lightness * rhs,
+                alpha,
+            },
+        }
+    }
+}
+
+impl MulAssign<f32> for Color {
+    fn mul_assign(&mut self, rhs: f32) {
+        match self {
+            Color::Rgba {
+                red, green, blue, ..
+            } => {
+                *red *= rhs;
+                *green *= rhs;
+                *blue *= rhs;
+            }
+            Color::RgbaLinear {
+                red, green, blue, ..
+            } => {
+                *red *= rhs;
+                *green *= rhs;
+                *blue *= rhs;
+            }
+            Color::Hsla {
+                hue,
+                saturation,
+                lightness,
+                ..
+            } => {
+                *hue *= rhs;
+                *saturation *= rhs;
+                *lightness *= rhs;
+            }
+        }
+    }
+}
+
+impl Mul<Vec4> for Color {
+    type Output = Color;
+
+    fn mul(self, rhs: Vec4) -> Self::Output {
+        match self {
+            Color::Rgba {
+                red,
+                green,
+                blue,
+                alpha,
+            } => Color::Rgba {
+                red: red * rhs.x,
+                green: green * rhs.y,
+                blue: blue * rhs.z,
+                alpha: alpha * rhs.w,
+            },
+            Color::RgbaLinear {
+                red,
+                green,
+                blue,
+                alpha,
+            } => Color::RgbaLinear {
+                red: red * rhs.x,
+                green: green * rhs.y,
+                blue: blue * rhs.z,
+                alpha: alpha * rhs.w,
+            },
+            Color::Hsla {
+                hue,
+                saturation,
+                lightness,
+                alpha,
+            } => Color::Hsla {
+                hue: hue * rhs.x,
+                saturation: saturation * rhs.y,
+                lightness: lightness * rhs.z,
+                alpha: alpha * rhs.w,
+            },
+        }
+    }
+}
+
+impl MulAssign<Vec4> for Color {
+    fn mul_assign(&mut self, rhs: Vec4) {
+        match self {
+            Color::Rgba {
+                red,
+                green,
+                blue,
+                alpha,
+            } => {
+                *red *= rhs.x;
+                *green *= rhs.y;
+                *blue *= rhs.z;
+                *alpha *= rhs.w;
+            }
+            Color::RgbaLinear {
+                red,
+                green,
+                blue,
+                alpha,
+            } => {
+                *red *= rhs.x;
+                *green *= rhs.y;
+                *blue *= rhs.z;
+                *alpha *= rhs.w;
+            }
+            Color::Hsla {
+                hue,
+                saturation,
+                lightness,
+                alpha,
+            } => {
+                *hue *= rhs.x;
+                *saturation *= rhs.y;
+                *lightness *= rhs.z;
+                *alpha *= rhs.w;
+            }
+        }
+    }
+}
+
+impl Mul<Vec3> for Color {
+    type Output = Color;
+
+    fn mul(self, rhs: Vec3) -> Self::Output {
+        match self {
+            Color::Rgba {
+                red,
+                green,
+                blue,
+                alpha,
+            } => Color::Rgba {
+                red: red * rhs.x,
+                green: green * rhs.y,
+                blue: blue * rhs.z,
+                alpha,
+            },
+            Color::RgbaLinear {
+                red,
+                green,
+                blue,
+                alpha,
+            } => Color::RgbaLinear {
+                red: red * rhs.x,
+                green: green * rhs.y,
+                blue: blue * rhs.z,
+                alpha,
+            },
+            Color::Hsla {
+                hue,
+                saturation,
+                lightness,
+                alpha,
+            } => Color::Hsla {
+                hue: hue * rhs.x,
+                saturation: saturation * rhs.y,
+                lightness: lightness * rhs.z,
+                alpha,
+            },
+        }
+    }
+}
+
+impl MulAssign<Vec3> for Color {
+    fn mul_assign(&mut self, rhs: Vec3) {
+        match self {
+            Color::Rgba {
+                red, green, blue, ..
+            } => {
+                *red *= rhs.x;
+                *green *= rhs.y;
+                *blue *= rhs.z;
+            }
+            Color::RgbaLinear {
+                red, green, blue, ..
+            } => {
+                *red *= rhs.x;
+                *green *= rhs.y;
+                *blue *= rhs.z;
+            }
+            Color::Hsla {
+                hue,
+                saturation,
+                lightness,
+                ..
+            } => {
+                *hue *= rhs.x;
+                *saturation *= rhs.y;
+                *lightness *= rhs.z;
+            }
+        }
+    }
+}
+
+impl Mul<[f32; 4]> for Color {
+    type Output = Color;
+
+    fn mul(self, rhs: [f32; 4]) -> Self::Output {
+        match self {
+            Color::Rgba {
+                red,
+                green,
+                blue,
+                alpha,
+            } => Color::Rgba {
+                red: red * rhs[0],
+                green: green * rhs[1],
+                blue: blue * rhs[2],
+                alpha: alpha * rhs[3],
+            },
+            Color::RgbaLinear {
+                red,
+                green,
+                blue,
+                alpha,
+            } => Color::RgbaLinear {
+                red: red * rhs[0],
+                green: green * rhs[1],
+                blue: blue * rhs[2],
+                alpha: alpha * rhs[3],
+            },
+            Color::Hsla {
+                hue,
+                saturation,
+                lightness,
+                alpha,
+            } => Color::Hsla {
+                hue: hue * rhs[0],
+                saturation: saturation * rhs[1],
+                lightness: lightness * rhs[2],
+                alpha: alpha * rhs[3],
+            },
+        }
+    }
+}
+
+impl MulAssign<[f32; 4]> for Color {
+    fn mul_assign(&mut self, rhs: [f32; 4]) {
+        match self {
+            Color::Rgba {
+                red,
+                green,
+                blue,
+                alpha,
+            } => {
+                *red *= rhs[0];
+                *green *= rhs[1];
+                *blue *= rhs[2];
+                *alpha *= rhs[3];
+            }
+            Color::RgbaLinear {
+                red,
+                green,
+                blue,
+                alpha,
+            } => {
+                *red *= rhs[0];
+                *green *= rhs[1];
+                *blue *= rhs[2];
+                *alpha *= rhs[3];
+            }
+            Color::Hsla {
+                hue,
+                saturation,
+                lightness,
+                alpha,
+            } => {
+                *hue *= rhs[0];
+                *saturation *= rhs[1];
+                *lightness *= rhs[2];
+                *alpha *= rhs[3];
+            }
+        }
+    }
+}
+
+impl Mul<[f32; 3]> for Color {
+    type Output = Color;
+
+    fn mul(self, rhs: [f32; 3]) -> Self::Output {
+        match self {
+            Color::Rgba {
+                red,
+                green,
+                blue,
+                alpha,
+            } => Color::Rgba {
+                red: red * rhs[0],
+                green: green * rhs[1],
+                blue: blue * rhs[2],
+                alpha,
+            },
+            Color::RgbaLinear {
+                red,
+                green,
+                blue,
+                alpha,
+            } => Color::RgbaLinear {
+                red: red * rhs[0],
+                green: green * rhs[1],
+                blue: blue * rhs[2],
+                alpha,
+            },
+            Color::Hsla {
+                hue,
+                saturation,
+                lightness,
+                alpha,
+            } => Color::Hsla {
+                hue: hue * rhs[0],
+                saturation: saturation * rhs[1],
+                lightness: lightness * rhs[2],
+                alpha,
+            },
+        }
+    }
+}
+
+impl MulAssign<[f32; 3]> for Color {
+    fn mul_assign(&mut self, rhs: [f32; 3]) {
+        match self {
+            Color::Rgba {
+                red, green, blue, ..
+            } => {
+                *red *= rhs[0];
+                *green *= rhs[1];
+                *blue *= rhs[2];
+            }
+            Color::RgbaLinear {
+                red, green, blue, ..
+            } => {
+                *red *= rhs[0];
+                *green *= rhs[1];
+                *blue *= rhs[2];
+            }
+            Color::Hsla {
+                hue,
+                saturation,
+                lightness,
+                ..
+            } => {
+                *hue *= rhs[0];
+                *saturation *= rhs[1];
+                *lightness *= rhs[2];
+            }
+        }
+    }
+}
+
+impl Bytes for Color {
+    fn write_bytes(&self, buffer: &mut [u8]) {
+        match *self {
+            Color::Rgba {
+                red,
+                green,
+                blue,
+                alpha,
+            } => {
+                red.nonlinear_to_linear_srgb().write_bytes(buffer);
+                green
+                    .nonlinear_to_linear_srgb()
+                    .write_bytes(&mut buffer[std::mem::size_of::<f32>()..]);
+                blue.nonlinear_to_linear_srgb()
+                    .write_bytes(&mut buffer[2 * std::mem::size_of::<f32>()..]);
+                alpha.write_bytes(&mut buffer[3 * std::mem::size_of::<f32>()..]);
+            }
+            Color::RgbaLinear {
+                red,
+                green,
+                blue,
+                alpha,
+            } => {
+                red.write_bytes(buffer);
+                green.write_bytes(&mut buffer[std::mem::size_of::<f32>()..]);
+                blue.write_bytes(&mut buffer[2 * std::mem::size_of::<f32>()..]);
+                alpha.write_bytes(&mut buffer[3 * std::mem::size_of::<f32>()..]);
+            }
+            Color::Hsla {
+                hue,
+                saturation,
+                lightness,
+                alpha,
+            } => {
+                let [red, green, blue] =
+                    HslRepresentation::hsl_to_nonlinear_srgb(hue, saturation, lightness);
+                red.nonlinear_to_linear_srgb().write_bytes(buffer);
+                green
+                    .nonlinear_to_linear_srgb()
+                    .write_bytes(&mut buffer[std::mem::size_of::<f32>()..]);
+                blue.nonlinear_to_linear_srgb()
+                    .write_bytes(&mut buffer[std::mem::size_of::<f32>() * 2..]);
+                alpha.write_bytes(&mut buffer[std::mem::size_of::<f32>() * 3..]);
+            }
+        }
+    }
+
+    fn byte_len(&self) -> usize {
+        std::mem::size_of::<f32>() * 4
+    }
+}
+
+#[derive(Debug)]
+pub enum HexColorError {
+    Length,
+    Hex(hex::FromHexError),
+}
+
+fn decode_rgb(data: &[u8]) -> Result<Color, HexColorError> {
+    let mut buf = [0; 3];
+    match hex::decode_to_slice(data, &mut buf) {
+        Ok(_) => {
+            let r = buf[0] as f32 / 255.0;
+            let g = buf[1] as f32 / 255.0;
+            let b = buf[2] as f32 / 255.0;
+            Ok(Color::rgb(r, g, b))
+        }
+        Err(err) => Err(HexColorError::Hex(err)),
+    }
+}
+
+fn decode_rgba(data: &[u8]) -> Result<Color, HexColorError> {
+    let mut buf = [0; 4];
+    match hex::decode_to_slice(data, &mut buf) {
+        Ok(_) => {
+            let r = buf[0] as f32 / 255.0;
+            let g = buf[1] as f32 / 255.0;
+            let b = buf[2] as f32 / 255.0;
+            let a = buf[3] as f32 / 255.0;
+            Ok(Color::rgba(r, g, b, a))
+        }
+        Err(err) => Err(HexColorError::Hex(err)),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn hex_color() {
+        assert_eq!(Color::hex("FFF").unwrap(), Color::rgb(1.0, 1.0, 1.0));
+        assert_eq!(Color::hex("000").unwrap(), Color::rgb(0.0, 0.0, 0.0));
+        assert!(Color::hex("---").is_err());
+
+        assert_eq!(Color::hex("FFFF").unwrap(), Color::rgba(1.0, 1.0, 1.0, 1.0));
+        assert_eq!(Color::hex("0000").unwrap(), Color::rgba(0.0, 0.0, 0.0, 0.0));
+        assert!(Color::hex("----").is_err());
+
+        assert_eq!(Color::hex("FFFFFF").unwrap(), Color::rgb(1.0, 1.0, 1.0));
+        assert_eq!(Color::hex("000000").unwrap(), Color::rgb(0.0, 0.0, 0.0));
+        assert!(Color::hex("------").is_err());
+
+        assert_eq!(
+            Color::hex("FFFFFFFF").unwrap(),
+            Color::rgba(1.0, 1.0, 1.0, 1.0)
+        );
+        assert_eq!(
+            Color::hex("00000000").unwrap(),
+            Color::rgba(0.0, 0.0, 0.0, 0.0)
+        );
+        assert!(Color::hex("--------").is_err());
+
+        assert!(Color::hex("1234567890").is_err());
+    }
+
+    #[test]
+    fn conversions_vec4() {
+        let starting_vec4 = Vec4::new(0.4, 0.5, 0.6, 1.0);
+        let starting_color = Color::from(starting_vec4);
+
+        assert_eq!(starting_vec4, Vec4::from(starting_color),);
+
+        let transformation = Vec4::new(0.5, 0.5, 0.5, 1.0);
+
+        assert_eq!(
+            starting_color * transformation,
+            Color::from(starting_vec4 * transformation),
+        );
+    }
+
+    #[test]
+    fn mul_and_mulassign_f32() {
+        let transformation = 0.5;
+        let starting_color = Color::rgba(0.4, 0.5, 0.6, 1.0);
+
+        assert_eq!(
+            starting_color * transformation,
+            Color::rgba(0.4 * 0.5, 0.5 * 0.5, 0.6 * 0.5, 1.0),
+        );
+
+        let mut mutated_color = starting_color;
+        mutated_color *= transformation;
+
+        assert_eq!(starting_color * transformation, mutated_color,);
+    }
+
+    #[test]
+    fn mul_and_mulassign_f32by3() {
+        let transformation = [0.4, 0.5, 0.6];
+        let starting_color = Color::rgba(0.4, 0.5, 0.6, 1.0);
+
+        assert_eq!(
+            starting_color * transformation,
+            Color::rgba(0.4 * 0.4, 0.5 * 0.5, 0.6 * 0.6, 1.0),
+        );
+
+        let mut mutated_color = starting_color;
+        mutated_color *= transformation;
+
+        assert_eq!(starting_color * transformation, mutated_color,);
+    }
+
+    #[test]
+    fn mul_and_mulassign_f32by4() {
+        let transformation = [0.4, 0.5, 0.6, 0.9];
+        let starting_color = Color::rgba(0.4, 0.5, 0.6, 1.0);
+
+        assert_eq!(
+            starting_color * transformation,
+            Color::rgba(0.4 * 0.4, 0.5 * 0.5, 0.6 * 0.6, 1.0 * 0.9),
+        );
+
+        let mut mutated_color = starting_color;
+        mutated_color *= transformation;
+
+        assert_eq!(starting_color * transformation, mutated_color,);
+    }
+
+    #[test]
+    fn mul_and_mulassign_vec3() {
+        let transformation = Vec3::new(0.2, 0.3, 0.4);
+        let starting_color = Color::rgba(0.4, 0.5, 0.6, 1.0);
+
+        assert_eq!(
+            starting_color * transformation,
+            Color::rgba(0.4 * 0.2, 0.5 * 0.3, 0.6 * 0.4, 1.0),
+        );
+
+        let mut mutated_color = starting_color;
+        mutated_color *= transformation;
+
+        assert_eq!(starting_color * transformation, mutated_color,);
+    }
+
+    #[test]
+    fn mul_and_mulassign_vec4() {
+        let transformation = Vec4::new(0.2, 0.3, 0.4, 0.5);
+        let starting_color = Color::rgba(0.4, 0.5, 0.6, 1.0);
+
+        assert_eq!(
+            starting_color * transformation,
+            Color::rgba(0.4 * 0.2, 0.5 * 0.3, 0.6 * 0.4, 1.0 * 0.5),
+        );
+
+        let mut mutated_color = starting_color;
+        mutated_color *= transformation;
+
+        assert_eq!(starting_color * transformation, mutated_color,);
+    }
+}
diff --git a/pipelined/bevy_render2/src/core_pipeline/mod.rs b/pipelined/bevy_render2/src/core_pipeline/mod.rs
index 7dbc355c23..36769ec92e 100644
--- a/pipelined/bevy_render2/src/core_pipeline/mod.rs
+++ b/pipelined/bevy_render2/src/core_pipeline/mod.rs
@@ -26,31 +26,31 @@ use wgpu::{Extent3d, TextureDescriptor, TextureDimension, TextureFormat, Texture
 // 3. "sub graph" modules should be nested beneath their parent graph module
 
 pub mod node {
-    pub const MAIN_PASS_DEPENDENCIES: &'static str = "main_pass_dependencies";
-    pub const MAIN_PASS_DRIVER: &'static str = "main_pass_driver";
-    pub const VIEW: &'static str = "view";
+    pub const MAIN_PASS_DEPENDENCIES: &str = "main_pass_dependencies";
+    pub const MAIN_PASS_DRIVER: &str = "main_pass_driver";
+    pub const VIEW: &str = "view";
 }
 
 pub mod draw_2d_graph {
-    pub const NAME: &'static str = "draw_2d";
+    pub const NAME: &str = "draw_2d";
     pub mod input {
-        pub const VIEW_ENTITY: &'static str = "view_entity";
-        pub const RENDER_TARGET: &'static str = "render_target";
+        pub const VIEW_ENTITY: &str = "view_entity";
+        pub const RENDER_TARGET: &str = "render_target";
     }
     pub mod node {
-        pub const MAIN_PASS: &'static str = "main_pass";
+        pub const MAIN_PASS: &str = "main_pass";
     }
 }
 
 pub mod draw_3d_graph {
-    pub const NAME: &'static str = "draw_3d";
+    pub const NAME: &str = "draw_3d";
     pub mod input {
-        pub const VIEW_ENTITY: &'static str = "view_entity";
-        pub const RENDER_TARGET: &'static str = "render_target";
-        pub const DEPTH: &'static str = "depth";
+        pub const VIEW_ENTITY: &str = "view_entity";
+        pub const RENDER_TARGET: &str = "render_target";
+        pub const DEPTH: &str = "depth";
     }
     pub mod node {
-        pub const MAIN_PASS: &'static str = "main_pass";
+        pub const MAIN_PASS: &str = "main_pass";
     }
 }
 
diff --git a/pipelined/bevy_render2/src/mesh/mesh/mod.rs b/pipelined/bevy_render2/src/mesh/mesh/mod.rs
index 9f1946b668..4f04b66a50 100644
--- a/pipelined/bevy_render2/src/mesh/mesh/mod.rs
+++ b/pipelined/bevy_render2/src/mesh/mesh/mod.rs
@@ -493,6 +493,13 @@ impl Indices {
             Indices::U32(vec) => vec.len(),
         }
     }
+
+    pub fn is_empty(&self) -> bool {
+        match self {
+            Indices::U16(vec) => vec.is_empty(),
+            Indices::U32(vec) => vec.is_empty(),
+        }
+    }
 }
 enum IndicesIter<'a> {
     U16(std::slice::Iter<'a, u16>),
diff --git a/pipelined/bevy_render2/src/render_graph/context.rs b/pipelined/bevy_render2/src/render_graph/context.rs
index b15db6b674..26f784b8ea 100644
--- a/pipelined/bevy_render2/src/render_graph/context.rs
+++ b/pipelined/bevy_render2/src/render_graph/context.rs
@@ -65,7 +65,7 @@ impl<'a> RenderGraphContext<'a> {
         let label = label.into();
         match self.get_input(label.clone())? {
             SlotValue::TextureView(value) => Ok(value),
-            value @ _ => Err(InputSlotError::MismatchedSlotType {
+            value => Err(InputSlotError::MismatchedSlotType {
                 label,
                 actual: value.slot_type(),
                 expected: SlotType::TextureView,
@@ -80,7 +80,7 @@ impl<'a> RenderGraphContext<'a> {
         let label = label.into();
         match self.get_input(label.clone())? {
             SlotValue::Sampler(value) => Ok(value),
-            value @ _ => Err(InputSlotError::MismatchedSlotType {
+            value => Err(InputSlotError::MismatchedSlotType {
                 label,
                 actual: value.slot_type(),
                 expected: SlotType::Sampler,
@@ -92,7 +92,7 @@ impl<'a> RenderGraphContext<'a> {
         let label = label.into();
         match self.get_input(label.clone())? {
             SlotValue::Buffer(value) => Ok(value),
-            value @ _ => Err(InputSlotError::MismatchedSlotType {
+            value => Err(InputSlotError::MismatchedSlotType {
                 label,
                 actual: value.slot_type(),
                 expected: SlotType::Buffer,
@@ -104,7 +104,7 @@ impl<'a> RenderGraphContext<'a> {
         let label = label.into();
         match self.get_input(label.clone())? {
             SlotValue::Entity(value) => Ok(*value),
-            value @ _ => Err(InputSlotError::MismatchedSlotType {
+            value => Err(InputSlotError::MismatchedSlotType {
                 label,
                 actual: value.slot_type(),
                 expected: SlotType::Entity,
@@ -122,7 +122,7 @@ impl<'a> RenderGraphContext<'a> {
         let slot_index = self
             .output_info()
             .get_slot_index(label.clone())
-            .ok_or(OutputSlotError::InvalidSlot(label.clone()))?;
+            .ok_or_else(|| OutputSlotError::InvalidSlot(label.clone()))?;
         let slot = self
             .output_info()
             .get_slot(slot_index)
@@ -147,7 +147,7 @@ impl<'a> RenderGraphContext<'a> {
         let sub_graph = self
             .graph
             .get_sub_graph(&name)
-            .ok_or(RunSubGraphError::MissingSubGraph(name.clone()))?;
+            .ok_or_else(|| RunSubGraphError::MissingSubGraph(name.clone()))?;
         if let Some(input_node) = sub_graph.input_node() {
             for (i, input_slot) in input_node.input_slots.iter().enumerate() {
                 if let Some(input_value) = inputs.get(i) {
@@ -168,10 +168,8 @@ impl<'a> RenderGraphContext<'a> {
                     });
                 }
             }
-        } else {
-            if !inputs.is_empty() {
-                return Err(RunSubGraphError::SubGraphHasNoInputs(name));
-            }
+        } else if !inputs.is_empty() {
+            return Err(RunSubGraphError::SubGraphHasNoInputs(name));
         }
 
         self.run_sub_graphs.push(RunSubGraph { name, inputs });
diff --git a/pipelined/bevy_render2/src/render_graph/graph.rs b/pipelined/bevy_render2/src/render_graph/graph.rs
index 19f70e8084..daf5d37be9 100644
--- a/pipelined/bevy_render2/src/render_graph/graph.rs
+++ b/pipelined/bevy_render2/src/render_graph/graph.rs
@@ -194,15 +194,12 @@ impl RenderGraph {
                 let output_slot = output_node_state
                     .output_slots
                     .get_slot(output_index)
-                    .ok_or_else(|| {
-                        RenderGraphError::InvalidOutputNodeSlot(SlotLabel::Index(output_index))
-                    })?;
-                let input_slot = input_node_state
-                    .input_slots
-                    .get_slot(input_index)
-                    .ok_or_else(|| {
-                        RenderGraphError::InvalidInputNodeSlot(SlotLabel::Index(input_index))
-                    })?;
+                    .ok_or(RenderGraphError::InvalidOutputNodeSlot(SlotLabel::Index(
+                        output_index,
+                    )))?;
+                let input_slot = input_node_state.input_slots.get_slot(input_index).ok_or(
+                    RenderGraphError::InvalidInputNodeSlot(SlotLabel::Index(input_index)),
+                )?;
 
                 if let Some(Edge::SlotEdge {
                     output_node: current_output_node,
diff --git a/pipelined/bevy_render2/src/render_resource/uniform_vec.rs b/pipelined/bevy_render2/src/render_resource/uniform_vec.rs
index 164b1c895e..6a380a14ad 100644
--- a/pipelined/bevy_render2/src/render_resource/uniform_vec.rs
+++ b/pipelined/bevy_render2/src/render_resource/uniform_vec.rs
@@ -49,6 +49,11 @@ impl<T: AsStd140> UniformVec<T> {
         self.values.len()
     }
 
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.values.is_empty()
+    }
+
     #[inline]
     pub fn capacity(&self) -> usize {
         self.capacity
@@ -155,6 +160,11 @@ impl<T: AsStd140> DynamicUniformVec<T> {
         self.uniform_vec.len()
     }
 
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.uniform_vec.is_empty()
+    }
+
     #[inline]
     pub fn capacity(&self) -> usize {
         self.uniform_vec.capacity()
diff --git a/pipelined/bevy_render2/src/texture/image.rs b/pipelined/bevy_render2/src/texture/image.rs
index 026095a088..d0294ab265 100644
--- a/pipelined/bevy_render2/src/texture/image.rs
+++ b/pipelined/bevy_render2/src/texture/image.rs
@@ -57,8 +57,10 @@ impl Image {
             data.len(),
             "Pixel data, size and format have to match",
         );
-        let mut image = Self::default();
-        image.data = data;
+        let mut image = Self {
+            data,
+            ..Default::default()
+        };
         image.texture_descriptor.dimension = dimension;
         image.texture_descriptor.size = size;
         image.texture_descriptor.format = format;
diff --git a/pipelined/bevy_sprite2/src/render/mod.rs b/pipelined/bevy_sprite2/src/render/mod.rs
index 1c2e1b8006..9f55cca8af 100644
--- a/pipelined/bevy_sprite2/src/render/mod.rs
+++ b/pipelined/bevy_sprite2/src/render/mod.rs
@@ -212,7 +212,7 @@ pub fn prepare_sprites(
     extracted_sprites: Res<ExtractedSprites>,
 ) {
     // dont create buffers when there are no sprites
-    if extracted_sprites.sprites.len() == 0 {
+    if extracted_sprites.sprites.is_empty() {
         return;
     }
 
@@ -277,6 +277,7 @@ pub fn prepare_sprites(
     sprite_meta.indices.write_to_staging_buffer(&render_device);
 }
 
+#[allow(clippy::too_many_arguments)]
 pub fn queue_sprites(
     draw_functions: Res<DrawFunctions>,
     render_device: Res<RenderDevice>,
@@ -287,7 +288,7 @@ pub fn queue_sprites(
     gpu_images: Res<RenderAssets<Image>>,
     mut views: Query<&mut RenderPhase<Transparent2dPhase>>,
 ) {
-    if view_meta.uniforms.len() == 0 {
+    if view_meta.uniforms.is_empty() {
         return;
     }