diff --git a/crates/bevy_app/src/ci_testing.rs b/crates/bevy_app/src/ci_testing.rs
index 21e22bec04e9a..dc8865a166696 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_core/src/time/timer.rs b/crates/bevy_core/src/time/timer.rs
index 290d73e7c197f..329fcbeb1b94e 100644
--- a/crates/bevy_core/src/time/timer.rs
+++ b/crates/bevy_core/src/time/timer.rs
@@ -375,10 +375,10 @@ mod tests {
         t.tick(Duration::from_secs_f32(0.25));
         assert_eq!(t.elapsed_secs(), 0.25);
         assert_eq!(t.duration(), Duration::from_secs_f32(10.0));
-        assert_eq!(t.finished(), false);
-        assert_eq!(t.just_finished(), false);
+        assert!(!t.finished());
+        assert!(!t.just_finished());
         assert_eq!(t.times_finished(), 0);
-        assert_eq!(t.repeating(), false);
+        assert!(!t.repeating());
         assert_eq!(t.percent(), 0.025);
         assert_eq!(t.percent_left(), 0.975);
         // Ticking while paused changes nothing
@@ -386,26 +386,26 @@ mod tests {
         t.tick(Duration::from_secs_f32(500.0));
         assert_eq!(t.elapsed_secs(), 0.25);
         assert_eq!(t.duration(), Duration::from_secs_f32(10.0));
-        assert_eq!(t.finished(), false);
-        assert_eq!(t.just_finished(), false);
+        assert!(!t.finished());
+        assert!(!t.just_finished());
         assert_eq!(t.times_finished(), 0);
-        assert_eq!(t.repeating(), false);
+        assert!(!t.repeating());
         assert_eq!(t.percent(), 0.025);
         assert_eq!(t.percent_left(), 0.975);
         // Tick past the end and make sure elapsed doesn't go past 0.0 and other things update
         t.unpause();
         t.tick(Duration::from_secs_f32(500.0));
         assert_eq!(t.elapsed_secs(), 10.0);
-        assert_eq!(t.finished(), true);
-        assert_eq!(t.just_finished(), true);
+        assert!(t.finished());
+        assert!(t.just_finished());
         assert_eq!(t.times_finished(), 1);
         assert_eq!(t.percent(), 1.0);
         assert_eq!(t.percent_left(), 0.0);
         // Continuing to tick when finished should only change just_finished
         t.tick(Duration::from_secs_f32(1.0));
         assert_eq!(t.elapsed_secs(), 10.0);
-        assert_eq!(t.finished(), true);
-        assert_eq!(t.just_finished(), false);
+        assert!(t.finished());
+        assert!(!t.just_finished());
         assert_eq!(t.times_finished(), 0);
         assert_eq!(t.percent(), 1.0);
         assert_eq!(t.percent_left(), 0.0);
@@ -418,25 +418,25 @@ mod tests {
         t.tick(Duration::from_secs_f32(0.75));
         assert_eq!(t.elapsed_secs(), 0.75);
         assert_eq!(t.duration(), Duration::from_secs_f32(2.0));
-        assert_eq!(t.finished(), false);
-        assert_eq!(t.just_finished(), false);
+        assert!(!t.finished());
+        assert!(!t.just_finished());
         assert_eq!(t.times_finished(), 0);
-        assert_eq!(t.repeating(), true);
+        assert!(t.repeating());
         assert_eq!(t.percent(), 0.375);
         assert_eq!(t.percent_left(), 0.625);
         // Tick past the end and make sure elapsed wraps
         t.tick(Duration::from_secs_f32(1.5));
         assert_eq!(t.elapsed_secs(), 0.25);
-        assert_eq!(t.finished(), true);
-        assert_eq!(t.just_finished(), true);
+        assert!(t.finished());
+        assert!(t.just_finished());
         assert_eq!(t.times_finished(), 1);
         assert_eq!(t.percent(), 0.125);
         assert_eq!(t.percent_left(), 0.875);
         // Continuing to tick should turn off both finished & just_finished for repeating timers
         t.tick(Duration::from_secs_f32(1.0));
         assert_eq!(t.elapsed_secs(), 1.25);
-        assert_eq!(t.finished(), false);
-        assert_eq!(t.just_finished(), false);
+        assert!(!t.finished());
+        assert!(!t.just_finished());
         assert_eq!(t.times_finished(), 0);
         assert_eq!(t.percent(), 0.625);
         assert_eq!(t.percent_left(), 0.375);
diff --git a/crates/bevy_dylib/src/lib.rs b/crates/bevy_dylib/src/lib.rs
index 9cea45597b66e..b39929bea6c71 100644
--- a/crates/bevy_dylib/src/lib.rs
+++ b/crates/bevy_dylib/src/lib.rs
@@ -1,3 +1,5 @@
+#![allow(clippy::single_component_path_imports)]
+
 //! Forces dynamic linking of Bevy.
 //!
 //! Dynamically linking Bevy makes the "link" step much faster. This can be achieved by adding
@@ -8,5 +10,4 @@
 
 // Force linking of the main bevy crate
 #[allow(unused_imports)]
-#[allow(clippy::single_component_path_imports)]
 use bevy_internal;
diff --git a/crates/bevy_ecs/src/entity/mod.rs b/crates/bevy_ecs/src/entity/mod.rs
index 7160ed6acc3c2..7be98eac0e621 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_ecs/src/system/mod.rs b/crates/bevy_ecs/src/system/mod.rs
index 2dc7716a54b72..c05dfc7f80b3c 100644
--- a/crates/bevy_ecs/src/system/mod.rs
+++ b/crates/bevy_ecs/src/system/mod.rs
@@ -324,7 +324,7 @@ mod tests {
         run_system(&mut world, sys.system());
 
         // ensure the system actually ran
-        assert_eq!(*world.get_resource::<bool>().unwrap(), true);
+        assert!(*world.get_resource::<bool>().unwrap());
     }
 
     #[test]
@@ -353,7 +353,7 @@ mod tests {
         }
 
         run_system(&mut world, validate_removed.system());
-        assert_eq!(*world.get_resource::<bool>().unwrap(), true, "system ran");
+        assert!(*world.get_resource::<bool>().unwrap(), "system ran");
     }
 
     #[test]
@@ -371,7 +371,7 @@ mod tests {
         );
 
         // ensure the system actually ran
-        assert_eq!(*world.get_resource::<bool>().unwrap(), true);
+        assert!(*world.get_resource::<bool>().unwrap());
     }
     #[test]
     fn world_collections_system() {
@@ -414,7 +414,7 @@ mod tests {
         run_system(&mut world, sys.system());
 
         // ensure the system actually ran
-        assert_eq!(*world.get_resource::<bool>().unwrap(), true);
+        assert!(*world.get_resource::<bool>().unwrap());
     }
 
     #[test]
diff --git a/crates/bevy_render/src/camera/visible_entities.rs b/crates/bevy_render/src/camera/visible_entities.rs
index 1fd0a9da460bc..46b7f3b31867a 100644
--- a/crates/bevy_render/src/camera/visible_entities.rs
+++ b/crates/bevy_render/src/camera/visible_entities.rs
@@ -167,14 +167,12 @@ mod rendering_mask_tests {
             "default masks match each other"
         );
 
-        assert_eq!(
-            RenderLayers::layer(0).intersects(&RenderLayers::layer(1)),
-            false,
+        assert!(
+            !RenderLayers::layer(0).intersects(&RenderLayers::layer(1)),
             "masks with differing layers do not match"
         );
-        assert_eq!(
-            RenderLayers(0).intersects(&RenderLayers(0)),
-            false,
+        assert!(
+            !RenderLayers(0).intersects(&RenderLayers(0)),
             "empty masks don't match"
         );
         assert_eq!(
diff --git a/crates/bevy_tasks/src/countdown_event.rs b/crates/bevy_tasks/src/countdown_event.rs
index 84f5b7213a4c0..9f672fe16ba0b 100644
--- a/crates/bevy_tasks/src/countdown_event.rs
+++ b/crates/bevy_tasks/src/countdown_event.rs
@@ -125,10 +125,7 @@ mod tests {
         let listener3 = event.listen();
 
         // Verify that we are still blocked
-        assert_eq!(
-            false,
-            listener2.wait_timeout(instant::Duration::from_millis(10))
-        );
+        assert!(!listener2.wait_timeout(instant::Duration::from_millis(10)));
 
         // Notify all and verify the remaining listener is notified
         event.notify(std::usize::MAX);
diff --git a/crates/bevy_transform/src/hierarchy/hierarchy.rs b/crates/bevy_transform/src/hierarchy/hierarchy.rs
index 2bbbd946bd4c3..338a6e12733c2 100644
--- a/crates/bevy_transform/src/hierarchy/hierarchy.rs
+++ b/crates/bevy_transform/src/hierarchy/hierarchy.rs
@@ -123,9 +123,8 @@ mod tests {
 
         {
             let children = world.get::<Children>(grandparent_entity).unwrap();
-            assert_eq!(
-                children.iter().any(|&i| i == parent_entity),
-                false,
+            assert!(
+                !children.iter().any(|&i| i == parent_entity),
                 "grandparent should no longer know about its child which has been removed"
             );
         }
diff --git a/crates/bevy_wgpu/Cargo.toml b/crates/bevy_wgpu/Cargo.toml
index 66940cb55a17b..30b4581e99a10 100644
--- a/crates/bevy_wgpu/Cargo.toml
+++ b/crates/bevy_wgpu/Cargo.toml
@@ -29,7 +29,7 @@ bevy_winit = { path = "../bevy_winit", optional = true, version = "0.5.0" }
 bevy_utils = { path = "../bevy_utils", version = "0.5.0" }
 
 # other
-wgpu = "0.8"
+wgpu = "0.9"
 futures-lite = "1.4.0"
 crossbeam-channel = "0.5.0"
 crossbeam-utils = "0.8.1"
diff --git a/crates/bevy_window/src/raw_window_handle.rs b/crates/bevy_window/src/raw_window_handle.rs
index 2393975490f9d..76f1411261c80 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 ee7bfe1d3434c..a4fbac11ae8e4 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 89b7d4fddbeed..076f2c7ce4d78 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 b71d3b6407f12..1c5e9c8a7c6a5 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/3d/3d_scene_pipelined.rs b/examples/3d/3d_scene_pipelined.rs
index 4f3fe65eb1cea..fc11b15ea5e47 100644
--- a/examples/3d/3d_scene_pipelined.rs
+++ b/examples/3d/3d_scene_pipelined.rs
@@ -3,12 +3,12 @@ use bevy::{
     diagnostic::{FrameTimeDiagnosticsPlugin, LogDiagnosticsPlugin},
     ecs::prelude::*,
     input::Input,
-    math::Vec3,
+    math::{Quat, Vec3},
     pbr2::{
-        AmbientLight, DirectionalLight, DirectionalLightBundle, OmniLight, OmniLightBundle,
-        PbrBundle, StandardMaterial,
+        AmbientLight, DirectionalLight, DirectionalLightBundle, PbrBundle, PointLight,
+        PointLightBundle, StandardMaterial,
     },
-    prelude::{App, Assets, KeyCode, Transform},
+    prelude::{App, Assets, BuildChildren, KeyCode, Transform},
     render2::{
         camera::{OrthographicProjection, PerspectiveCameraBundle},
         color::Color,
@@ -50,6 +50,32 @@ fn setup(
         }),
         ..Default::default()
     });
+
+    let mut transform = Transform::from_xyz(2.5, 2.5, 0.0);
+    transform.rotate(Quat::from_rotation_z(std::f32::consts::FRAC_PI_2));
+    commands.spawn_bundle(PbrBundle {
+        mesh: meshes.add(Mesh::from(shape::Plane { size: 5.0 })),
+        transform,
+        material: materials.add(StandardMaterial {
+            base_color: Color::INDIGO,
+            perceptual_roughness: 1.0,
+            ..Default::default()
+        }),
+        ..Default::default()
+    });
+
+    let mut transform = Transform::from_xyz(0.0, 2.5, -2.5);
+    transform.rotate(Quat::from_rotation_x(std::f32::consts::FRAC_PI_2));
+    commands.spawn_bundle(PbrBundle {
+        mesh: meshes.add(Mesh::from(shape::Plane { size: 5.0 })),
+        transform,
+        material: materials.add(StandardMaterial {
+            base_color: Color::INDIGO,
+            perceptual_roughness: 1.0,
+            ..Default::default()
+        }),
+        ..Default::default()
+    });
     // cube
     commands
         .spawn_bundle(PbrBundle {
@@ -77,26 +103,94 @@ fn setup(
             ..Default::default()
         })
         .insert(Movable);
+
+    // light
+    commands
+        .spawn_bundle(PointLightBundle {
+            // transform: Transform::from_xyz(5.0, 8.0, 2.0),
+            transform: Transform::from_xyz(1.0, 2.0, 0.0),
+            point_light: PointLight {
+                color: Color::RED,
+                ..Default::default()
+            },
+            ..Default::default()
+        })
+        .with_children(|builder| {
+            builder.spawn_bundle(PbrBundle {
+                mesh: meshes.add(Mesh::from(shape::UVSphere {
+                    radius: 0.1,
+                    ..Default::default()
+                })),
+                material: materials.add(StandardMaterial {
+                    base_color: Color::RED,
+                    emissive: Color::rgba_linear(100.0, 0.0, 0.0, 0.0),
+                    ..Default::default()
+                }),
+                ..Default::default()
+            });
+        });
+
     // light
-    commands.spawn_bundle(OmniLightBundle {
-        omni_light: OmniLight {
-            color: Color::RED,
+    commands
+        .spawn_bundle(PointLightBundle {
+            // transform: Transform::from_xyz(5.0, 8.0, 2.0),
+            transform: Transform::from_xyz(-1.0, 2.0, 0.0),
+            point_light: PointLight {
+                color: Color::GREEN,
+                ..Default::default()
+            },
             ..Default::default()
-        },
-        transform: Transform::from_xyz(5.0, 8.0, 2.0),
-        ..Default::default()
-    });
-    commands.spawn_bundle(OmniLightBundle {
-        omni_light: OmniLight {
-            color: Color::GREEN,
+        })
+        .with_children(|builder| {
+            builder.spawn_bundle(PbrBundle {
+                mesh: meshes.add(Mesh::from(shape::UVSphere {
+                    radius: 0.1,
+                    ..Default::default()
+                })),
+                material: materials.add(StandardMaterial {
+                    base_color: Color::GREEN,
+                    emissive: Color::rgba_linear(0.0, 100.0, 0.0, 0.0),
+                    ..Default::default()
+                }),
+                ..Default::default()
+            });
+        });
+
+    // light
+    commands
+        .spawn_bundle(PointLightBundle {
+            // transform: Transform::from_xyz(5.0, 8.0, 2.0),
+            transform: Transform::from_xyz(0.0, 4.0, 0.0),
+            point_light: PointLight {
+                color: Color::BLUE,
+                ..Default::default()
+            },
             ..Default::default()
-        },
-        transform: Transform::from_xyz(5.0, 8.0, -2.0),
+        })
+        .with_children(|builder| {
+            builder.spawn_bundle(PbrBundle {
+                mesh: meshes.add(Mesh::from(shape::UVSphere {
+                    radius: 0.1,
+                    ..Default::default()
+                })),
+                material: materials.add(StandardMaterial {
+                    base_color: Color::BLUE,
+                    emissive: Color::rgba_linear(0.0, 0.0, 100.0, 0.0),
+                    ..Default::default()
+                }),
+                ..Default::default()
+            });
+        });
+
+    // camera
+    commands.spawn_bundle(PerspectiveCameraBundle {
+        transform: Transform::from_xyz(-2.0, 5.0, 7.5)
+            .looking_at(Vec3::new(0.0, 2.0, 0.0), Vec3::Y),
         ..Default::default()
     });
-    const HALF_SIZE: f32 = 5.0;
+    const HALF_SIZE: f32 = 10.0;
     let mut directional_light = DirectionalLight::default();
-    directional_light.color = Color::BLUE;
+    directional_light.color = Color::WHITE;
     directional_light.shadow_projection = OrthographicProjection {
         left: -HALF_SIZE,
         right: HALF_SIZE,
diff --git a/examples/3d/pbr_pipelined.rs b/examples/3d/pbr_pipelined.rs
index 2aa96016291a5..470326cab3e9d 100644
--- a/examples/3d/pbr_pipelined.rs
+++ b/examples/3d/pbr_pipelined.rs
@@ -1,7 +1,7 @@
 use bevy::{
     ecs::prelude::*,
     math::Vec3,
-    pbr2::{OmniLight, OmniLightBundle, PbrBundle, StandardMaterial},
+    pbr2::{PbrBundle, PointLight, PointLightBundle, StandardMaterial},
     prelude::{App, Assets, Transform},
     render2::{
         camera::{OrthographicCameraBundle, OrthographicProjection},
@@ -64,9 +64,9 @@ fn setup(
         ..Default::default()
     });
     // light
-    commands.spawn_bundle(OmniLightBundle {
+    commands.spawn_bundle(PointLightBundle {
         transform: Transform::from_translation(Vec3::new(50.0, 50.0, 50.0)),
-        omni_light: OmniLight {
+        point_light: PointLight {
             intensity: 50000.,
             range: 100.,
             ..Default::default()
diff --git a/examples/tools/bevymark_pipelined.rs b/examples/tools/bevymark_pipelined.rs
index 4789853fe30e1..b2e80850e381e 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/Cargo.toml b/pipelined/bevy_pbr2/Cargo.toml
index e59352a998a6f..613b36a298b2e 100644
--- a/pipelined/bevy_pbr2/Cargo.toml
+++ b/pipelined/bevy_pbr2/Cargo.toml
@@ -29,4 +29,4 @@ bitflags = "1.2"
 # direct dependency required for derive macro
 bytemuck = { version = "1", features = ["derive"] }
 crevice = { path = "../../crates/crevice" }
-wgpu = "0.8"
+wgpu = "0.9"
diff --git a/pipelined/bevy_pbr2/src/bundle.rs b/pipelined/bevy_pbr2/src/bundle.rs
index 034c166dcd706..cc7a6b51987d1 100644
--- a/pipelined/bevy_pbr2/src/bundle.rs
+++ b/pipelined/bevy_pbr2/src/bundle.rs
@@ -1,4 +1,4 @@
-use crate::{DirectionalLight, OmniLight, StandardMaterial};
+use crate::{DirectionalLight, PointLight, StandardMaterial};
 use bevy_asset::Handle;
 use bevy_ecs::bundle::Bundle;
 use bevy_render2::mesh::Mesh;
@@ -23,10 +23,10 @@ impl Default for PbrBundle {
     }
 }
 
-/// A component bundle for "omni light" entities
+/// A component bundle for "point light" entities
 #[derive(Debug, Bundle, Default)]
-pub struct OmniLightBundle {
-    pub omni_light: OmniLight,
+pub struct PointLightBundle {
+    pub point_light: PointLight,
     pub transform: Transform,
     pub global_transform: GlobalTransform,
 }
diff --git a/pipelined/bevy_pbr2/src/lib.rs b/pipelined/bevy_pbr2/src/lib.rs
index f82bca92d7e66..290643ad0dbb3 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/light.rs b/pipelined/bevy_pbr2/src/light.rs
index ff944a0190b63..2fe8629318735 100644
--- a/pipelined/bevy_pbr2/src/light.rs
+++ b/pipelined/bevy_pbr2/src/light.rs
@@ -1,27 +1,29 @@
-use bevy_math::{Vec2, Vec3};
+use bevy_math::Vec3;
 use bevy_render2::{camera::OrthographicProjection, color::Color};
 
 pub const DEFAULT_SHADOW_BIAS_MIN: f32 = 0.00005;
 pub const DEFAULT_SHADOW_BIAS_MAX: f32 = 0.002;
 
-/// An omnidirectional light
+/// A light that emits light in all directions from a central point.
 #[derive(Debug, Clone, Copy)]
-pub struct OmniLight {
+pub struct PointLight {
     pub color: Color,
     pub intensity: f32,
     pub range: f32,
     pub radius: f32,
-    pub shadow_bias_min_max: Vec2,
+    pub shadow_bias_min: f32,
+    pub shadow_bias_max: f32,
 }
 
-impl Default for OmniLight {
+impl Default for PointLight {
     fn default() -> Self {
-        OmniLight {
+        PointLight {
             color: Color::rgb(1.0, 1.0, 1.0),
             intensity: 200.0,
             range: 20.0,
             radius: 0.0,
-            shadow_bias_min_max: Vec2::new(DEFAULT_SHADOW_BIAS_MIN, DEFAULT_SHADOW_BIAS_MAX),
+            shadow_bias_min: DEFAULT_SHADOW_BIAS_MIN,
+            shadow_bias_max: DEFAULT_SHADOW_BIAS_MAX,
         }
     }
 }
@@ -58,7 +60,8 @@ pub struct DirectionalLight {
     pub illuminance: f32,
     direction: Vec3,
     pub shadow_projection: OrthographicProjection,
-    pub shadow_bias_min_max: Vec2,
+    pub shadow_bias_min: f32,
+    pub shadow_bias_max: f32,
 }
 
 impl DirectionalLight {
@@ -68,14 +71,16 @@ impl DirectionalLight {
         illuminance: f32,
         direction: Vec3,
         shadow_projection: OrthographicProjection,
-        shadow_bias_min_max: Vec2,
+        shadow_bias_min: f32,
+        shadow_bias_max: f32,
     ) -> Self {
         DirectionalLight {
             color,
             illuminance,
             direction: direction.normalize(),
             shadow_projection,
-            shadow_bias_min_max,
+            shadow_bias_min,
+            shadow_bias_max,
         }
     }
 
@@ -105,7 +110,8 @@ impl Default for DirectionalLight {
                 far: size,
                 ..Default::default()
             },
-            shadow_bias_min_max: Vec2::new(DEFAULT_SHADOW_BIAS_MIN, DEFAULT_SHADOW_BIAS_MAX),
+            shadow_bias_min: DEFAULT_SHADOW_BIAS_MIN,
+            shadow_bias_max: DEFAULT_SHADOW_BIAS_MAX,
         }
     }
 }
diff --git a/pipelined/bevy_pbr2/src/render/light.rs b/pipelined/bevy_pbr2/src/render/light.rs
index 0388b82bfb0af..5337954b36353 100644
--- a/pipelined/bevy_pbr2/src/render/light.rs
+++ b/pipelined/bevy_pbr2/src/render/light.rs
@@ -1,6 +1,6 @@
-use crate::{AmbientLight, DirectionalLight, ExtractedMeshes, MeshMeta, OmniLight, PbrShaders};
+use crate::{AmbientLight, DirectionalLight, ExtractedMeshes, MeshMeta, PbrShaders, PointLight};
 use bevy_ecs::{prelude::*, system::SystemState};
-use bevy_math::{Mat4, UVec4, Vec2, Vec3, Vec4};
+use bevy_math::{const_vec3, Mat4, Vec3, Vec4};
 use bevy_render2::{
     camera::CameraProjection,
     color::Color,
@@ -23,13 +23,14 @@ pub struct ExtractedAmbientLight {
     brightness: f32,
 }
 
-pub struct ExtractedOmniLight {
+pub struct ExtractedPointLight {
     color: Color,
     intensity: f32,
     range: f32,
     radius: f32,
     transform: GlobalTransform,
-    shadow_bias_min_max: Vec2,
+    shadow_bias_min: f32,
+    shadow_bias_max: f32,
 }
 
 pub struct ExtractedDirectionalLight {
@@ -37,17 +38,20 @@ pub struct ExtractedDirectionalLight {
     illuminance: f32,
     direction: Vec3,
     projection: Mat4,
-    shadow_bias_min_max: Vec2,
+    shadow_bias_min: f32,
+    shadow_bias_max: f32,
 }
 
 #[repr(C)]
 #[derive(Copy, Clone, AsStd140, Default, Debug)]
-pub struct GpuOmniLight {
-    view_proj: Mat4,
+pub struct GpuPointLight {
     color: Vec4,
+    // proj: Mat4,
     position: Vec3,
-    range: f32,
+    inverse_square_range: f32,
     radius: f32,
+    near: f32,
+    far: f32,
     shadow_bias_min: f32,
     shadow_bias_max: f32,
 }
@@ -65,27 +69,34 @@ pub struct GpuDirectionalLight {
 #[repr(C)]
 #[derive(Copy, Clone, Debug, AsStd140)]
 pub struct GpuLights {
-    omni_lights: [GpuOmniLight; MAX_OMNI_LIGHTS],
+    // TODO: this comes first to work around a WGSL alignment issue. We need to solve this issue before releasing the renderer rework
+    point_lights: [GpuPointLight; MAX_POINT_LIGHTS],
     directional_lights: [GpuDirectionalLight; MAX_DIRECTIONAL_LIGHTS],
     ambient_color: Vec4,
-    n_omni_lights: u32,
+    n_point_lights: u32,
     n_directional_lights: u32,
 }
 
 // NOTE: this must be kept in sync with the same constants in pbr.frag
-pub const MAX_OMNI_LIGHTS: usize = 10;
+pub const MAX_POINT_LIGHTS: usize = 10;
 pub const MAX_DIRECTIONAL_LIGHTS: usize = 1;
-pub const SHADOW_SIZE: Extent3d = Extent3d {
+pub const POINT_SHADOW_SIZE: Extent3d = Extent3d {
     width: 1024,
     height: 1024,
-    depth_or_array_layers: (MAX_OMNI_LIGHTS + MAX_DIRECTIONAL_LIGHTS) as u32,
+    depth_or_array_layers: (6 * MAX_POINT_LIGHTS) as u32,
+};
+pub const DIRECTIONAL_SHADOW_SIZE: Extent3d = Extent3d {
+    width: 4096,
+    height: 4096,
+    depth_or_array_layers: MAX_DIRECTIONAL_LIGHTS as u32,
 };
 pub const SHADOW_FORMAT: TextureFormat = TextureFormat::Depth32Float;
 
 pub struct ShadowShaders {
     pub pipeline: RenderPipeline,
     pub view_layout: BindGroupLayout,
-    pub light_sampler: Sampler,
+    pub point_light_sampler: Sampler,
+    pub directional_light_sampler: Sampler,
 }
 
 // TODO: this pattern for initializing the shaders / pipeline isn't ideal. this should be handled by the asset system
@@ -174,7 +185,7 @@ impl FromWorld for ShadowShaders {
                 topology: PrimitiveTopology::TriangleList,
                 strip_index_format: None,
                 front_face: FrontFace::Ccw,
-                cull_mode: Some(Face::Back),
+                cull_mode: None,
                 polygon_mode: PolygonMode::Fill,
                 clamp_depth: false,
                 conservative: false,
@@ -184,7 +195,17 @@ impl FromWorld for ShadowShaders {
         ShadowShaders {
             pipeline,
             view_layout,
-            light_sampler: render_device.create_sampler(&SamplerDescriptor {
+            point_light_sampler: render_device.create_sampler(&SamplerDescriptor {
+                address_mode_u: AddressMode::ClampToEdge,
+                address_mode_v: AddressMode::ClampToEdge,
+                address_mode_w: AddressMode::ClampToEdge,
+                mag_filter: FilterMode::Linear,
+                min_filter: FilterMode::Linear,
+                mipmap_filter: FilterMode::Nearest,
+                compare: Some(CompareFunction::LessEqual),
+                ..Default::default()
+            }),
+            directional_light_sampler: render_device.create_sampler(&SamplerDescriptor {
                 address_mode_u: AddressMode::ClampToEdge,
                 address_mode_v: AddressMode::ClampToEdge,
                 address_mode_w: AddressMode::ClampToEdge,
@@ -202,21 +223,22 @@ impl FromWorld for ShadowShaders {
 pub fn extract_lights(
     mut commands: Commands,
     ambient_light: Res<AmbientLight>,
-    omni_lights: Query<(Entity, &OmniLight, &GlobalTransform)>,
+    point_lights: Query<(Entity, &PointLight, &GlobalTransform)>,
     directional_lights: Query<(Entity, &DirectionalLight)>,
 ) {
     commands.insert_resource(ExtractedAmbientLight {
         color: ambient_light.color,
         brightness: ambient_light.brightness,
     });
-    for (entity, omni_light, transform) in omni_lights.iter() {
-        commands.get_or_spawn(entity).insert(ExtractedOmniLight {
-            color: omni_light.color,
-            intensity: omni_light.intensity,
-            range: omni_light.range,
-            radius: omni_light.radius,
-            transform: transform.clone(),
-            shadow_bias_min_max: omni_light.shadow_bias_min_max,
+    for (entity, point_light, transform) in point_lights.iter() {
+        commands.get_or_spawn(entity).insert(ExtractedPointLight {
+            color: point_light.color,
+            intensity: point_light.intensity,
+            range: point_light.range,
+            radius: point_light.radius,
+            transform: *transform,
+            shadow_bias_min: point_light.shadow_bias_min,
+            shadow_bias_max: point_light.shadow_bias_max,
         });
     }
     for (entity, directional_light) in directional_lights.iter() {
@@ -227,18 +249,78 @@ pub fn extract_lights(
                 illuminance: directional_light.illuminance,
                 direction: directional_light.get_direction(),
                 projection: directional_light.shadow_projection.get_projection_matrix(),
-                shadow_bias_min_max: directional_light.shadow_bias_min_max,
+                shadow_bias_min: directional_light.shadow_bias_min,
+                shadow_bias_max: directional_light.shadow_bias_max,
             });
     }
 }
 
+// Can't do `Vec3::Y * -1.0` because mul isn't const
+const NEGATIVE_X: Vec3 = const_vec3!([-1.0, 0.0, 0.0]);
+const NEGATIVE_Y: Vec3 = const_vec3!([0.0, -1.0, 0.0]);
+const NEGATIVE_Z: Vec3 = const_vec3!([0.0, 0.0, -1.0]);
+
+struct CubeMapFace {
+    target: Vec3,
+    up: Vec3,
+}
+
+// see https://www.khronos.org/opengl/wiki/Cubemap_Texture
+const CUBE_MAP_FACES: [CubeMapFace; 6] = [
+    // 0 	GL_TEXTURE_CUBE_MAP_POSITIVE_X
+    CubeMapFace {
+        target: NEGATIVE_X,
+        up: NEGATIVE_Y,
+    },
+    // 1 	GL_TEXTURE_CUBE_MAP_NEGATIVE_X
+    CubeMapFace {
+        target: Vec3::X,
+        up: NEGATIVE_Y,
+    },
+    // 2 	GL_TEXTURE_CUBE_MAP_POSITIVE_Y
+    CubeMapFace {
+        target: NEGATIVE_Y,
+        up: Vec3::Z,
+    },
+    // 3 	GL_TEXTURE_CUBE_MAP_NEGATIVE_Y
+    CubeMapFace {
+        target: Vec3::Y,
+        up: NEGATIVE_Z,
+    },
+    // 4 	GL_TEXTURE_CUBE_MAP_POSITIVE_Z
+    CubeMapFace {
+        target: NEGATIVE_Z,
+        up: NEGATIVE_Y,
+    },
+    // 5 	GL_TEXTURE_CUBE_MAP_NEGATIVE_Z
+    CubeMapFace {
+        target: Vec3::Z,
+        up: NEGATIVE_Y,
+    },
+];
+
+fn face_index_to_name(face_index: usize) -> &'static str {
+    match face_index {
+        0 => "+x",
+        1 => "-x",
+        2 => "+y",
+        3 => "-y",
+        4 => "+z",
+        5 => "-z",
+        _ => "invalid",
+    }
+}
+
 pub struct ViewLight {
-    pub depth_texture: TextureView,
+    pub depth_texture_view: TextureView,
+    pub pass_name: String,
 }
 
 pub struct ViewLights {
-    pub light_depth_texture: Texture,
-    pub light_depth_texture_view: TextureView,
+    pub point_light_depth_texture: Texture,
+    pub point_light_depth_texture_view: TextureView,
+    pub directional_light_depth_texture: Texture,
+    pub directional_light_depth_texture_view: TextureView,
     pub lights: Vec<Entity>,
     pub gpu_light_binding_index: u32,
 }
@@ -256,7 +338,7 @@ pub fn prepare_lights(
     mut light_meta: ResMut<LightMeta>,
     views: Query<Entity, With<RenderPhase<Transparent3dPhase>>>,
     ambient_light: Res<ExtractedAmbientLight>,
-    omni_lights: Query<&ExtractedOmniLight>,
+    point_lights: Query<&ExtractedPointLight>,
     directional_lights: Query<&ExtractedDirectionalLight>,
 ) {
     // PERF: view.iter().count() could be views.iter().len() if we implemented ExactSizeIterator for archetype-only filters
@@ -267,10 +349,22 @@ pub fn prepare_lights(
     let ambient_color = ambient_light.color.as_rgba_linear() * ambient_light.brightness;
     // set up light data for each view
     for entity in views.iter() {
-        let light_depth_texture = texture_cache.get(
+        let point_light_depth_texture = texture_cache.get(
+            &render_device,
+            TextureDescriptor {
+                size: POINT_SHADOW_SIZE,
+                mip_level_count: 1,
+                sample_count: 1,
+                dimension: TextureDimension::D2,
+                format: SHADOW_FORMAT,
+                usage: TextureUsage::RENDER_ATTACHMENT | TextureUsage::SAMPLED,
+                label: None,
+            },
+        );
+        let directional_light_depth_texture = texture_cache.get(
             &render_device,
             TextureDescriptor {
-                size: SHADOW_SIZE,
+                size: DIRECTIONAL_SHADOW_SIZE,
                 mip_level_count: 1,
                 sample_count: 1,
                 dimension: TextureDimension::D2,
@@ -283,66 +377,78 @@ pub fn prepare_lights(
 
         let mut gpu_lights = GpuLights {
             ambient_color: ambient_color.into(),
-            n_omni_lights: omni_lights.iter().len() as u32,
+            n_point_lights: point_lights.iter().len() as u32,
             n_directional_lights: directional_lights.iter().len() as u32,
-            omni_lights: [GpuOmniLight::default(); MAX_OMNI_LIGHTS],
+            point_lights: [GpuPointLight::default(); MAX_POINT_LIGHTS],
             directional_lights: [GpuDirectionalLight::default(); MAX_DIRECTIONAL_LIGHTS],
         };
 
         // TODO: this should select lights based on relevance to the view instead of the first ones that show up in a query
-        for (i, light) in omni_lights.iter().enumerate().take(MAX_OMNI_LIGHTS) {
-            let depth_texture_view =
-                light_depth_texture
-                    .texture
-                    .create_view(&TextureViewDescriptor {
-                        label: None,
-                        format: None,
-                        dimension: Some(TextureViewDimension::D2),
-                        aspect: TextureAspect::All,
-                        base_mip_level: 0,
-                        mip_level_count: None,
-                        base_array_layer: i as u32,
-                        array_layer_count: NonZeroU32::new(1),
-                    });
-
-            let view_transform = GlobalTransform::from_translation(light.transform.translation)
-                .looking_at(Vec3::default(), Vec3::Y);
-            // TODO: configure light projection based on light configuration
+        for (light_index, light) in point_lights.iter().enumerate().take(MAX_POINT_LIGHTS) {
             let projection =
                 Mat4::perspective_rh(std::f32::consts::FRAC_PI_2, 1.0, 0.1, light.range);
 
-            gpu_lights.omni_lights[i] = GpuOmniLight {
+            // ignore scale because we don't want to effectively scale light radius and range
+            // by applying those as a view transform to shadow map rendering of objects
+            // and ignore rotation because we want the shadow map projections to align with the axes
+            let view_translation = GlobalTransform::from_translation(light.transform.translation);
+
+            for (face_index, CubeMapFace { target, up }) in CUBE_MAP_FACES.iter().enumerate() {
+                // use the cubemap projection direction
+                let view_rotation = GlobalTransform::identity().looking_at(*target, *up);
+
+                let depth_texture_view =
+                    point_light_depth_texture
+                        .texture
+                        .create_view(&TextureViewDescriptor {
+                            label: None,
+                            format: None,
+                            dimension: Some(TextureViewDimension::D2),
+                            aspect: TextureAspect::All,
+                            base_mip_level: 0,
+                            mip_level_count: None,
+                            base_array_layer: (light_index * 6 + face_index) as u32,
+                            array_layer_count: NonZeroU32::new(1),
+                        });
+
+                let view_light_entity = commands
+                    .spawn()
+                    .insert_bundle((
+                        ViewLight {
+                            depth_texture_view,
+                            pass_name: format!(
+                                "shadow pass point light {} {}",
+                                light_index,
+                                face_index_to_name(face_index)
+                            ),
+                        },
+                        ExtractedView {
+                            width: POINT_SHADOW_SIZE.width,
+                            height: POINT_SHADOW_SIZE.height,
+                            transform: view_translation * view_rotation,
+                            projection,
+                        },
+                        RenderPhase::<ShadowPhase>::default(),
+                    ))
+                    .id();
+                view_lights.push(view_light_entity);
+            }
+
+            gpu_lights.point_lights[light_index] = GpuPointLight {
                 // 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,
                 position: light.transform.translation,
-                range: 1.0 / (light.range * light.range),
-                // this could technically be copied to the gpu from the light's ViewUniforms
-                view_proj: projection * view_transform.compute_matrix().inverse(),
-                shadow_bias_min: light.shadow_bias_min_max.x,
-                shadow_bias_max: light.shadow_bias_min_max.y,
+                inverse_square_range: 1.0 / (light.range * light.range),
+                near: 0.1,
+                far: light.range,
+                // proj: projection,
+                shadow_bias_min: light.shadow_bias_min,
+                shadow_bias_max: light.shadow_bias_max,
             };
-
-            let view_light_entity = commands
-                .spawn()
-                .insert_bundle((
-                    ViewLight {
-                        depth_texture: depth_texture_view,
-                    },
-                    ExtractedView {
-                        width: SHADOW_SIZE.width,
-                        height: SHADOW_SIZE.height,
-                        transform: view_transform.clone(),
-                        projection,
-                    },
-                    RenderPhase::<ShadowPhase>::default(),
-                ))
-                .id();
-            view_lights.push(view_light_entity);
         }
 
-        let n_omni_lights = view_lights.len();
         for (i, light) in directional_lights
             .iter()
             .enumerate()
@@ -377,12 +483,12 @@ pub fn prepare_lights(
                 dir_to_light,
                 // NOTE: * view is correct, it should not be view.inverse() here
                 view_projection: projection * view,
-                shadow_bias_min: light.shadow_bias_min_max.x,
-                shadow_bias_max: light.shadow_bias_min_max.y,
+                shadow_bias_min: light.shadow_bias_min,
+                shadow_bias_max: light.shadow_bias_max,
             };
 
             let depth_texture_view =
-                light_depth_texture
+                directional_light_depth_texture
                     .texture
                     .create_view(&TextureViewDescriptor {
                         label: None,
@@ -391,7 +497,7 @@ pub fn prepare_lights(
                         aspect: TextureAspect::All,
                         base_mip_level: 0,
                         mip_level_count: None,
-                        base_array_layer: (n_omni_lights + i) as u32,
+                        base_array_layer: i as u32,
                         array_layer_count: NonZeroU32::new(1),
                     });
 
@@ -399,11 +505,12 @@ pub fn prepare_lights(
                 .spawn()
                 .insert_bundle((
                     ViewLight {
-                        depth_texture: depth_texture_view,
+                        depth_texture_view,
+                        pass_name: format!("shadow pass directional light {}", i),
                     },
                     ExtractedView {
-                        width: SHADOW_SIZE.width,
-                        height: SHADOW_SIZE.height,
+                        width: DIRECTIONAL_SHADOW_SIZE.width,
+                        height: DIRECTIONAL_SHADOW_SIZE.height,
                         transform: GlobalTransform::from_matrix(view.inverse()),
                         projection,
                     },
@@ -412,10 +519,37 @@ pub fn prepare_lights(
                 .id();
             view_lights.push(view_light_entity);
         }
+        let point_light_depth_texture_view =
+            point_light_depth_texture
+                .texture
+                .create_view(&TextureViewDescriptor {
+                    label: None,
+                    format: None,
+                    dimension: Some(TextureViewDimension::CubeArray),
+                    aspect: TextureAspect::All,
+                    base_mip_level: 0,
+                    mip_level_count: None,
+                    base_array_layer: 0,
+                    array_layer_count: None,
+                });
+        let directional_light_depth_texture_view = directional_light_depth_texture
+            .texture
+            .create_view(&TextureViewDescriptor {
+                label: None,
+                format: None,
+                dimension: Some(TextureViewDimension::D2Array),
+                aspect: TextureAspect::All,
+                base_mip_level: 0,
+                mip_level_count: None,
+                base_array_layer: 0,
+                array_layer_count: None,
+            });
 
         commands.entity(entity).insert(ViewLights {
-            light_depth_texture: light_depth_texture.texture,
-            light_depth_texture_view: light_depth_texture.default_view,
+            point_light_depth_texture: point_light_depth_texture.texture,
+            point_light_depth_texture_view,
+            directional_light_depth_texture: directional_light_depth_texture.texture,
+            directional_light_depth_texture_view,
             lights: view_lights,
             gpu_light_binding_index: light_meta.view_gpu_lights.push(gpu_lights),
         });
@@ -461,17 +595,17 @@ 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
                     .get_manual(world, view_light_entity)
                     .unwrap();
                 let pass_descriptor = RenderPassDescriptor {
-                    label: Some("shadow_pass"),
+                    label: Some(&view_light.pass_name),
                     color_attachments: &[],
                     depth_stencil_attachment: Some(RenderPassDepthStencilAttachment {
-                        view: &view_light.depth_texture,
+                        view: &view_light.depth_texture_view,
                         depth_ops: Some(Operations {
                             load: LoadOp::Clear(1.0),
                             store: true,
@@ -537,7 +671,8 @@ impl Draw for DrawShadowMesh {
             self.params.get(world);
         let view_uniform_offset = views.get(view).unwrap();
         let extracted_mesh = &extracted_meshes.into_inner().meshes[draw_key];
-        pass.set_render_pipeline(&shadow_shaders.into_inner().pipeline);
+        let shadow_shaders = shadow_shaders.into_inner();
+        pass.set_render_pipeline(&shadow_shaders.pipeline);
         pass.set_bind_group(
             0,
             light_meta
@@ -548,12 +683,13 @@ impl Draw for DrawShadowMesh {
             &[view_uniform_offset.offset],
         );
 
+        let transform_bindgroup_key = mesh_meta.mesh_transform_bind_group_key.unwrap();
         pass.set_bind_group(
             1,
             mesh_meta
                 .into_inner()
                 .mesh_transform_bind_group
-                .as_ref()
+                .get_value(transform_bindgroup_key)
                 .unwrap(),
             &[extracted_mesh.transform_binding_offset],
         );
diff --git a/pipelined/bevy_pbr2/src/render/mod.rs b/pipelined/bevy_pbr2/src/render/mod.rs
index b2ed3e4170c0c..680b433c6def4 100644
--- a/pipelined/bevy_pbr2/src/render/mod.rs
+++ b/pipelined/bevy_pbr2/src/render/mod.rs
@@ -76,18 +76,18 @@ impl FromWorld for PbrShaders {
                     },
                     count: None,
                 },
-                // Shadow Texture Array
+                // Point Shadow Texture Cube Array
                 BindGroupLayoutEntry {
                     binding: 2,
                     visibility: ShaderStage::FRAGMENT,
                     ty: BindingType::Texture {
                         multisampled: false,
                         sample_type: TextureSampleType::Depth,
-                        view_dimension: TextureViewDimension::D2Array,
+                        view_dimension: TextureViewDimension::CubeArray,
                     },
                     count: None,
                 },
-                // Shadow Texture Array Sampler
+                // Point Shadow Texture Array Sampler
                 BindGroupLayoutEntry {
                     binding: 3,
                     visibility: ShaderStage::FRAGMENT,
@@ -97,6 +97,27 @@ impl FromWorld for PbrShaders {
                     },
                     count: None,
                 },
+                // Directional Shadow Texture Array
+                BindGroupLayoutEntry {
+                    binding: 4,
+                    visibility: ShaderStage::FRAGMENT,
+                    ty: BindingType::Texture {
+                        multisampled: false,
+                        sample_type: TextureSampleType::Depth,
+                        view_dimension: TextureViewDimension::D2Array,
+                    },
+                    count: None,
+                },
+                // Directional Shadow Texture Array Sampler
+                BindGroupLayoutEntry {
+                    binding: 5,
+                    visibility: ShaderStage::FRAGMENT,
+                    ty: BindingType::Sampler {
+                        comparison: true,
+                        filtering: true,
+                    },
+                    count: None,
+                },
             ],
             label: None,
         });
@@ -344,10 +365,10 @@ impl FromWorld for PbrShaders {
         };
         PbrShaders {
             pipeline,
+            shader_module,
             view_layout,
             material_layout,
             mesh_layout,
-            shader_module,
             dummy_white_gpu_image,
         }
     }
@@ -383,7 +404,6 @@ pub fn extract_meshes(
                     continue;
                 }
             }
-
             if let Some(ref image) = material.emissive_texture {
                 if !images.contains(image) {
                     continue;
@@ -424,7 +444,8 @@ struct MeshDrawInfo {
 pub struct MeshMeta {
     transform_uniforms: DynamicUniformVec<Mat4>,
     material_bind_groups: FrameSlabMap<BufferId, BindGroup>,
-    mesh_transform_bind_group: Option<BindGroup>,
+    mesh_transform_bind_group: FrameSlabMap<BufferId, BindGroup>,
+    mesh_transform_bind_group_key: Option<FrameSlabMapKey<BufferId, BindGroup>>,
     mesh_draw_info: Vec<MeshDrawInfo>,
 }
 
@@ -469,6 +490,7 @@ fn image_handle_to_view_sampler<'a>(
     )
 }
 
+#[allow(clippy::too_many_arguments)]
 pub fn queue_meshes(
     mut commands: Commands,
     draw_functions: Res<DrawFunctions>,
@@ -491,6 +513,10 @@ pub fn queue_meshes(
 ) {
     let mesh_meta = mesh_meta.into_inner();
 
+    if view_meta.uniforms.is_empty() {
+        return;
+    }
+
     light_meta.shadow_view_bind_group.get_or_insert_with(|| {
         render_device.create_bind_group(&BindGroupDescriptor {
             entries: &[BindGroupEntry {
@@ -506,16 +532,21 @@ pub fn queue_meshes(
     }
 
     let transform_uniforms = &mesh_meta.transform_uniforms;
-    mesh_meta.mesh_transform_bind_group.get_or_insert_with(|| {
-        render_device.create_bind_group(&BindGroupDescriptor {
-            entries: &[BindGroupEntry {
-                binding: 0,
-                resource: transform_uniforms.binding(),
-            }],
-            label: None,
-            layout: &pbr_shaders.mesh_layout,
-        })
-    });
+    mesh_meta.mesh_transform_bind_group.next_frame();
+    mesh_meta.mesh_transform_bind_group_key =
+        Some(mesh_meta.mesh_transform_bind_group.get_or_insert_with(
+            transform_uniforms.uniform_buffer().unwrap().id(),
+            || {
+                render_device.create_bind_group(&BindGroupDescriptor {
+                    entries: &[BindGroupEntry {
+                        binding: 0,
+                        resource: transform_uniforms.binding(),
+                    }],
+                    label: None,
+                    layout: &pbr_shaders.mesh_layout,
+                })
+            },
+        ));
     for (entity, view, view_lights, mut transparent_phase) in views.iter_mut() {
         // TODO: cache this?
         let view_bind_group = render_device.create_bind_group(&BindGroupDescriptor {
@@ -530,11 +561,23 @@ pub fn queue_meshes(
                 },
                 BindGroupEntry {
                     binding: 2,
-                    resource: BindingResource::TextureView(&view_lights.light_depth_texture_view),
+                    resource: BindingResource::TextureView(
+                        &view_lights.point_light_depth_texture_view,
+                    ),
                 },
                 BindGroupEntry {
                     binding: 3,
-                    resource: BindingResource::Sampler(&shadow_shaders.light_sampler),
+                    resource: BindingResource::Sampler(&shadow_shaders.point_light_sampler),
+                },
+                BindGroupEntry {
+                    binding: 4,
+                    resource: BindingResource::TextureView(
+                        &view_lights.directional_light_depth_texture_view,
+                    ),
+                },
+                BindGroupEntry {
+                    binding: 5,
+                    resource: BindingResource::Sampler(&shadow_shaders.directional_light_sampler),
                 },
             ],
             label: None,
@@ -740,7 +783,10 @@ impl Draw for DrawPbr {
         );
         pass.set_bind_group(
             1,
-            mesh_meta.mesh_transform_bind_group.as_ref().unwrap(),
+            mesh_meta
+                .mesh_transform_bind_group
+                .get_value(mesh_meta.mesh_transform_bind_group_key.unwrap())
+                .unwrap(),
             &[extracted_mesh.transform_binding_offset],
         );
         let mesh_draw_info = &mesh_meta.mesh_draw_info[draw_key];
diff --git a/pipelined/bevy_pbr2/src/render/pbr.frag b/pipelined/bevy_pbr2/src/render/pbr.frag
deleted file mode 100644
index 31f272b2b950c..0000000000000
--- a/pipelined/bevy_pbr2/src/render/pbr.frag
+++ /dev/null
@@ -1,465 +0,0 @@
-#version 450
-
-// From the Filament design doc
-// https://google.github.io/filament/Filament.html#table_symbols
-// Symbol Definition
-// v    View unit vector
-// l    Incident light unit vector
-// n    Surface normal unit vector
-// h    Half unit vector between l and v
-// f    BRDF
-// f_d    Diffuse component of a BRDF
-// f_r    Specular component of a BRDF
-// α    Roughness, remapped from using input perceptualRoughness
-// σ    Diffuse reflectance
-// Ω    Spherical domain
-// f0    Reflectance at normal incidence
-// f90    Reflectance at grazing angle
-// χ+(a)    Heaviside function (1 if a>0 and 0 otherwise)
-// nior    Index of refraction (IOR) of an interface
-// ⟨n⋅l⟩    Dot product clamped to [0..1]
-// ⟨a⟩    Saturated value (clamped to [0..1])
-
-// The Bidirectional Reflectance Distribution Function (BRDF) describes the surface response of a standard material
-// and consists of two components, the diffuse component (f_d) and the specular component (f_r):
-// f(v,l) = f_d(v,l) + f_r(v,l)
-//
-// The form of the microfacet model is the same for diffuse and specular
-// f_r(v,l) = f_d(v,l) = 1 / { |n⋅v||n⋅l| } ∫_Ω D(m,α) G(v,l,m) f_m(v,l,m) (v⋅m) (l⋅m) dm
-//
-// In which:
-// D, also called the Normal Distribution Function (NDF) models the distribution of the microfacets
-// G models the visibility (or occlusion or shadow-masking) of the microfacets
-// f_m is the microfacet BRDF and differs between specular and diffuse components
-//
-// The above integration needs to be approximated.
-
-layout(location = 0) in vec4 v_WorldPosition;
-layout(location = 1) in vec3 v_WorldNormal;
-layout(location = 2) in vec2 v_Uv;
-
-layout(location = 0) out vec4 o_Target;
-
-struct OmniLight {
-    vec4 color;
-    float range;
-    float radius;
-    vec3 position;
-    vec2 shadow_bias_min_max;
-    mat4 view_projection;
-};
- 
-struct DirectionalLight {
-    vec4 color;
-    vec3 dir_to_light;
-    vec2 shadow_bias_min_max;
-    mat4 view_projection;
-};
-
-// NOTE: this must be kept in sync with the constants defined bevy_pbr2/src/render/light.rs
-// TODO: this can be removed if we move to storage buffers for light arrays
-const int MAX_OMNI_LIGHTS = 10;
-const int MAX_DIRECTIONAL_LIGHTS = 1;
-
-struct StandardMaterial_t {
-    vec4 base_color;
-    vec4 emissive;
-    float perceptual_roughness;
-    float metallic;
-    float reflectance;
-    // 'flags' is a bit field indicating various option. uint is 32 bits so we have up to 32 options.
-    uint flags;
-};
-
-// NOTE: These must match those defined in bevy_pbr2/src/material.rs
-const uint FLAGS_BASE_COLOR_TEXTURE_BIT         = (1 << 0);
-const uint FLAGS_EMISSIVE_TEXTURE_BIT           = (1 << 1);
-const uint FLAGS_METALLIC_ROUGHNESS_TEXTURE_BIT = (1 << 2);
-const uint FLAGS_OCCLUSION_TEXTURE_BIT          = (1 << 3);
-const uint FLAGS_DOUBLE_SIDED_BIT               = (1 << 4);
-const uint FLAGS_UNLIT_BIT                      = (1 << 5);
-
-// View bindings - set 0
-layout(set = 0, binding = 0) uniform View {
-    mat4 ViewProj;
-    vec3 ViewWorldPosition;
-};
-layout(std140, set = 0, binding = 1) uniform Lights {
-    vec4 AmbientColor;
-    uvec4 NumLights; // x is omni lights, y is directional lights
-    OmniLight OmniLights[MAX_OMNI_LIGHTS];
-    DirectionalLight DirectionalLights[MAX_DIRECTIONAL_LIGHTS];
-};
-layout(set = 0, binding = 2) uniform texture2DArray shadow_texture;
-layout(set = 0, binding = 3) uniform samplerShadow shadow_sampler;
-
-// Material bindings - set 2
-layout(set = 2, binding = 0) uniform StandardMaterial {
-    StandardMaterial_t Material;
-};
-
-layout(set = 2, binding = 1) uniform texture2D base_color_texture;
-layout(set = 2, binding = 2) uniform sampler base_color_sampler;
-
-layout(set = 2, binding = 3) uniform texture2D emissive_texture;
-layout(set = 2, binding = 4) uniform sampler emissive_sampler;
-
-layout(set = 2, binding = 5) uniform texture2D metallic_roughness_texture;
-layout(set = 2, binding = 6) uniform sampler metallic_roughness_sampler;
-
-layout(set = 2, binding = 7) uniform texture2D occlusion_texture;
-layout(set = 2, binding = 8) uniform sampler occlusion_sampler;
-
-#    define saturate(x) clamp(x, 0.0, 1.0)
-const float PI = 3.141592653589793;
-
-float pow5(float x) {
-    float x2 = x * x;
-    return x2 * x2 * x;
-}
-
-// distanceAttenuation is simply the square falloff of light intensity
-// combined with a smooth attenuation at the edge of the light radius
-//
-// light radius is a non-physical construct for efficiency purposes,
-// because otherwise every light affects every fragment in the scene
-float getDistanceAttenuation(float distanceSquare, float inverseRangeSquared) {
-    float factor = distanceSquare * inverseRangeSquared;
-    float smoothFactor = saturate(1.0 - factor * factor);
-    float attenuation = smoothFactor * smoothFactor;
-    return attenuation * 1.0 / max(distanceSquare, 1e-4);
-}
-
-// Normal distribution function (specular D)
-// Based on https://google.github.io/filament/Filament.html#citation-walter07
-
-// D_GGX(h,α) = α^2 / { π ((n⋅h)^2 (α2−1) + 1)^2 }
-
-// Simple implementation, has precision problems when using fp16 instead of fp32
-// see https://google.github.io/filament/Filament.html#listing_speculardfp16
-float D_GGX(float roughness, float NoH, const vec3 h) {
-    float oneMinusNoHSquared = 1.0 - NoH * NoH;
-    float a = NoH * roughness;
-    float k = roughness / (oneMinusNoHSquared + a * a);
-    float d = k * k * (1.0 / PI);
-    return d;
-}
-
-// Visibility function (Specular G)
-// V(v,l,a) = G(v,l,α) / { 4 (n⋅v) (n⋅l) }
-// such that f_r becomes
-// f_r(v,l) = D(h,α) V(v,l,α) F(v,h,f0)
-// where
-// V(v,l,α) = 0.5 / { n⋅l sqrt((n⋅v)^2 (1−α2) + α2) + n⋅v sqrt((n⋅l)^2 (1−α2) + α2) }
-// Note the two sqrt's, that may be slow on mobile, see https://google.github.io/filament/Filament.html#listing_approximatedspecularv
-float V_SmithGGXCorrelated(float roughness, float NoV, float NoL) {
-    float a2 = roughness * roughness;
-    float lambdaV = NoL * sqrt((NoV - a2 * NoV) * NoV + a2);
-    float lambdaL = NoV * sqrt((NoL - a2 * NoL) * NoL + a2);
-    float v = 0.5 / (lambdaV + lambdaL);
-    return v;
-}
-
-// Fresnel function
-// see https://google.github.io/filament/Filament.html#citation-schlick94
-// F_Schlick(v,h,f_0,f_90) = f_0 + (f_90 − f_0) (1 − v⋅h)^5
-vec3 F_Schlick(const vec3 f0, float f90, float VoH) {
-    // not using mix to keep the vec3 and float versions identical
-    return f0 + (f90 - f0) * pow5(1.0 - VoH);
-}
-
-float F_Schlick(float f0, float f90, float VoH) {
-    // not using mix to keep the vec3 and float versions identical
-    return f0 + (f90 - f0) * pow5(1.0 - VoH);
-}
-
-vec3 fresnel(vec3 f0, float LoH) {
-    // f_90 suitable for ambient occlusion
-    // see https://google.github.io/filament/Filament.html#lighting/occlusion
-    float f90 = saturate(dot(f0, vec3(50.0 * 0.33)));
-    return F_Schlick(f0, f90, LoH);
-}
-
-// Specular BRDF
-// https://google.github.io/filament/Filament.html#materialsystem/specularbrdf
-
-// Cook-Torrance approximation of the microfacet model integration using Fresnel law F to model f_m
-// f_r(v,l) = { D(h,α) G(v,l,α) F(v,h,f0) } / { 4 (n⋅v) (n⋅l) }
-vec3 specular(vec3 f0, float roughness, const vec3 h, float NoV, float NoL,
-              float NoH, float LoH, float specularIntensity) {
-    float D = D_GGX(roughness, NoH, h);
-    float V = V_SmithGGXCorrelated(roughness, NoV, NoL);
-    vec3 F = fresnel(f0, LoH);
-
-    return (specularIntensity * D * V) * F;
-}
-
-// Diffuse BRDF
-// https://google.github.io/filament/Filament.html#materialsystem/diffusebrdf
-// fd(v,l) = σ/π * 1 / { |n⋅v||n⋅l| } ∫Ω D(m,α) G(v,l,m) (v⋅m) (l⋅m) dm
-
-// simplest approximation
-// float Fd_Lambert() {
-//     return 1.0 / PI;
-// }
-//
-// vec3 Fd = diffuseColor * Fd_Lambert();
-
-// Disney approximation
-// See https://google.github.io/filament/Filament.html#citation-burley12
-// minimal quality difference
-float Fd_Burley(float roughness, float NoV, float NoL, float LoH) {
-    float f90 = 0.5 + 2.0 * roughness * LoH * LoH;
-    float lightScatter = F_Schlick(1.0, f90, NoL);
-    float viewScatter = F_Schlick(1.0, f90, NoV);
-    return lightScatter * viewScatter * (1.0 / PI);
-}
-
-// From https://www.unrealengine.com/en-US/blog/physically-based-shading-on-mobile
-vec3 EnvBRDFApprox(vec3 f0, float perceptual_roughness, float NoV) {
-    const vec4 c0 = { -1, -0.0275, -0.572, 0.022 };
-    const vec4 c1 = { 1, 0.0425, 1.04, -0.04 };
-    vec4 r = perceptual_roughness * c0 + c1;
-    float a004 = min(r.x * r.x, exp2(-9.28 * NoV)) * r.x + r.y;
-    vec2 AB = vec2(-1.04, 1.04) * a004 + r.zw;
-    return f0 * AB.x + AB.y;
-}
-
-float perceptualRoughnessToRoughness(float perceptualRoughness) {
-    // clamp perceptual roughness to prevent precision problems
-    // According to Filament design 0.089 is recommended for mobile
-    // Filament uses 0.045 for non-mobile
-    float clampedPerceptualRoughness = clamp(perceptualRoughness, 0.089, 1.0);
-    return clampedPerceptualRoughness * clampedPerceptualRoughness;
-}
-
-// from https://64.github.io/tonemapping/
-// reinhard on RGB oversaturates colors
-vec3 reinhard(vec3 color) {
-    return color / (1.0 + color);
-}
-
-vec3 reinhard_extended(vec3 color, float max_white) {
-    vec3 numerator = color * (1.0f + (color / vec3(max_white * max_white)));
-    return numerator / (1.0 + color);
-}
-
-// luminance coefficients from Rec. 709.
-// https://en.wikipedia.org/wiki/Rec._709
-float luminance(vec3 v) {
-    return dot(v, vec3(0.2126, 0.7152, 0.0722));
-}
-
-vec3 change_luminance(vec3 c_in, float l_out) {
-    float l_in = luminance(c_in);
-    return c_in * (l_out / l_in);
-}
-
-vec3 reinhard_luminance(vec3 color) {
-    float l_old = luminance(color);
-    float l_new = l_old / (1.0f + l_old);
-    return change_luminance(color, l_new);
-}
-
-vec3 reinhard_extended_luminance(vec3 color, float max_white_l) {
-    float l_old = luminance(color);
-    float numerator = l_old * (1.0f + (l_old / (max_white_l * max_white_l)));
-    float l_new = numerator / (1.0f + l_old);
-    return change_luminance(color, l_new);
-}
-
-vec3 omni_light(OmniLight light, float roughness, float NdotV, vec3 N, vec3 V, vec3 R, vec3 F0, vec3 diffuseColor) {
-    vec3 light_to_frag = light.position.xyz - v_WorldPosition.xyz;
-    float distance_square = dot(light_to_frag, light_to_frag);
-    float rangeAttenuation =
-        getDistanceAttenuation(distance_square, light.range);
-
-    // Specular.
-    // Representative Point Area Lights.
-    // see http://blog.selfshadow.com/publications/s2013-shading-course/karis/s2013_pbs_epic_notes_v2.pdf p14-16
-    float a = roughness;
-    vec3 centerToRay = dot(light_to_frag, R) * R - light_to_frag;
-    vec3 closestPoint = light_to_frag + centerToRay * saturate(light.radius * inversesqrt(dot(centerToRay, centerToRay)));
-    float LspecLengthInverse = inversesqrt(dot(closestPoint, closestPoint));
-    float normalizationFactor = a / saturate(a + (light.radius * 0.5 * LspecLengthInverse));
-    float specularIntensity = normalizationFactor * normalizationFactor;
-
-    vec3 L = closestPoint * LspecLengthInverse; // normalize() equivalent?
-    vec3 H = normalize(L + V);
-    float NoL = saturate(dot(N, L));
-    float NoH = saturate(dot(N, H));
-    float LoH = saturate(dot(L, H));
-
-    vec3 specular = specular(F0, roughness, H, NdotV, NoL, NoH, LoH, specularIntensity);
-
-    // Diffuse.
-    // Comes after specular since its NoL is used in the lighting equation.
-    L = normalize(light_to_frag);
-    H = normalize(L + V);
-    NoL = saturate(dot(N, L));
-    NoH = saturate(dot(N, H));
-    LoH = saturate(dot(L, H));
-
-    vec3 diffuse = diffuseColor * Fd_Burley(roughness, NdotV, NoL, LoH);
-
-    // Lout = f(v,l) Φ / { 4 π d^2 }⟨n⋅l⟩
-    // where
-    // f(v,l) = (f_d(v,l) + f_r(v,l)) * light_color
-    // Φ is light intensity
-
-    // our rangeAttentuation = 1 / d^2 multiplied with an attenuation factor for smoothing at the edge of the non-physical maximum light radius
-    // It's not 100% clear where the 1/4π goes in the derivation, but we follow the filament shader and leave it out
-
-    // See https://google.github.io/filament/Filament.html#mjx-eqn-pointLightLuminanceEquation
-    // TODO compensate for energy loss https://google.github.io/filament/Filament.html#materialsystem/improvingthebrdfs/energylossinspecularreflectance
-    // light.color.rgb is premultiplied with light.intensity on the CPU
-    return ((diffuse + specular) * light.color.rgb) * (rangeAttenuation * NoL);
-}
-
-vec3 directional_light(DirectionalLight light, float roughness, float NdotV, vec3 normal, vec3 view, vec3 R, vec3 F0, vec3 diffuseColor) {
-    vec3 incident_light = light.dir_to_light.xyz;
-
-    vec3 half_vector = normalize(incident_light + view);
-    float NoL = saturate(dot(normal, incident_light));
-    float NoH = saturate(dot(normal, half_vector));
-    float LoH = saturate(dot(incident_light, half_vector));
-
-    vec3 diffuse = diffuseColor * Fd_Burley(roughness, NdotV, NoL, LoH);
-    float specularIntensity = 1.0;
-    vec3 specular = specular(F0, roughness, half_vector, NdotV, NoL, NoH, LoH, specularIntensity);
-
-    return (specular + diffuse) * light.color.rgb * NoL;
-}
-
-float fetch_shadow(int light_id, vec4 homogeneous_coords, float shadow_bias) {
-    if (homogeneous_coords.w <= 0.0) {
-        return 1.0;
-    }
-    // compensate for the Y-flip difference between the NDC and texture coordinates
-    const vec2 flip_correction = vec2(0.5, -0.5);
-    // compute texture coordinates for shadow lookup
-    vec4 light_local = vec4(
-        homogeneous_coords.xy * flip_correction/homogeneous_coords.w + 0.5,
-        light_id,
-        homogeneous_coords.z / homogeneous_coords.w - shadow_bias
-    );
-    // do the lookup, using HW PCF and comparison
-    return texture(sampler2DArrayShadow(shadow_texture, shadow_sampler), light_local);
-}
-
-void main() {
-    vec4 output_color = Material.base_color;
-    if ((Material.flags & FLAGS_BASE_COLOR_TEXTURE_BIT) != 0) {
-        output_color *= texture(sampler2D(base_color_texture, base_color_sampler), v_Uv);
-    }
-
-    // NOTE: Unlit bit not set means == 0 is true, so the true case is if lit
-    if ((Material.flags & FLAGS_UNLIT_BIT) == 0) {
-        // TODO use .a for exposure compensation in HDR
-        vec4 emissive = Material.emissive;
-        if ((Material.flags & FLAGS_EMISSIVE_TEXTURE_BIT) != 0) {
-            emissive.rgb *= texture(sampler2D(emissive_texture, emissive_sampler), v_Uv).rgb;
-        }
-
-        // calculate non-linear roughness from linear perceptualRoughness
-        float metallic = Material.metallic;
-        float perceptual_roughness = Material.perceptual_roughness;
-        if ((Material.flags & FLAGS_METALLIC_ROUGHNESS_TEXTURE_BIT) != 0) {
-            vec4 metallic_roughness = texture(sampler2D(metallic_roughness_texture, metallic_roughness_sampler), v_Uv);
-            // Sampling from GLTF standard channels for now
-            metallic *= metallic_roughness.b;
-            perceptual_roughness *= metallic_roughness.g;
-        }
-        float roughness = perceptualRoughnessToRoughness(perceptual_roughness);
-
-        float occlusion = 1.0;
-        if ((Material.flags & FLAGS_OCCLUSION_TEXTURE_BIT) != 0) {
-            occlusion = texture(sampler2D(occlusion_texture, occlusion_sampler), v_Uv).r;
-        }
-
-        vec3 N = normalize(v_WorldNormal);
-
-    // FIXME: Normal maps need an additional vertex attribute and vertex stage output/fragment stage input
-    //        Just use a separate shader for lit with normal maps?
-    // #    ifdef STANDARDMATERIAL_NORMAL_MAP
-    //     vec3 T = normalize(v_WorldTangent.xyz);
-    //     vec3 B = cross(N, T) * v_WorldTangent.w;
-    // #    endif
-
-        if ((Material.flags & FLAGS_DOUBLE_SIDED_BIT) != 0) {
-            N = gl_FrontFacing ? N : -N;
-    // #        ifdef STANDARDMATERIAL_NORMAL_MAP
-    //     T = gl_FrontFacing ? T : -T;
-    //     B = gl_FrontFacing ? B : -B;
-    // #        endif
-        }
-
-    // #    ifdef STANDARDMATERIAL_NORMAL_MAP
-    //     mat3 TBN = mat3(T, B, N);
-    //     N = TBN * normalize(texture(sampler2D(normal_map, normal_map_sampler), v_Uv).rgb * 2.0 - 1.0);
-    // #    endif
-
-        vec3 V;
-        if (ViewProj[3][3] != 1.0) { // If the projection is not orthographic
-            // Only valid for a perpective projection
-            V = normalize(ViewWorldPosition.xyz - v_WorldPosition.xyz);
-        } else {
-            // Ortho view vec
-            V = normalize(vec3(-ViewProj[0][2], -ViewProj[1][2], -ViewProj[2][2]));
-        }
-
-        // Neubelt and Pettineo 2013, "Crafting a Next-gen Material Pipeline for The Order: 1886"
-        float NdotV = max(dot(N, V), 1e-4);
-
-        // Remapping [0,1] reflectance to F0
-        // See https://google.github.io/filament/Filament.html#materialsystem/parameterization/remapping
-        float reflectance = Material.reflectance;
-        vec3 F0 = 0.16 * reflectance * reflectance * (1.0 - metallic) + output_color.rgb * metallic;
-
-        // Diffuse strength inversely related to metallicity
-        vec3 diffuse_color = output_color.rgb * (1.0 - metallic);
-
-        vec3 R = reflect(-V, N);
-
-        const int n_omni_lights = int(NumLights.x);
-        const int n_dir_lights = int(NumLights.y);
-        // accumulate color
-        vec3 light_accum = vec3(0.0);
-        for (int i = 0; i < n_omni_lights && i < MAX_OMNI_LIGHTS; ++i) {
-            OmniLight light = OmniLights[i];
-            vec3 light_contrib = omni_light(light, roughness, NdotV, N, V, R, F0, diffuse_color);
-            vec3 dir_to_light = normalize(light.position.xyz - v_WorldPosition.xyz);
-            float shadow_bias = max(
-                light.shadow_bias_min_max.y * (1.0 - dot(v_WorldNormal, dir_to_light)),
-                light.shadow_bias_min_max.x
-            );
-            float shadow = fetch_shadow(i, light.view_projection * v_WorldPosition, shadow_bias);
-            light_accum += light_contrib * shadow;
-        }
-        for (int i = 0; i < n_dir_lights && i < MAX_DIRECTIONAL_LIGHTS; ++i) {
-            DirectionalLight light = DirectionalLights[i];
-            vec3 light_contrib = directional_light(light, roughness, NdotV, N, V, R, F0, diffuse_color);
-            float shadow_bias = max(
-                light.shadow_bias_min_max.y * (1.0 - dot(v_WorldNormal, light.dir_to_light)),
-                light.shadow_bias_min_max.x
-            );
-            float shadow = fetch_shadow(n_omni_lights + i, light.view_projection * v_WorldPosition, shadow_bias);
-            light_accum += light_contrib * shadow;
-        }
-
-        vec3 diffuse_ambient = EnvBRDFApprox(diffuse_color, 1.0, NdotV);
-        vec3 specular_ambient = EnvBRDFApprox(F0, perceptual_roughness, NdotV);
-
-        output_color.rgb = light_accum;
-        output_color.rgb += (diffuse_ambient + specular_ambient) * AmbientColor.rgb * occlusion;
-        output_color.rgb += emissive.rgb * output_color.a;
-
-        // tone_mapping
-        output_color.rgb = reinhard_luminance(output_color.rgb);
-        // Gamma correction.
-        // Not needed with sRGB buffer
-        // output_color.rgb = pow(output_color.rgb, vec3(1.0 / 2.2));
-    }
-
-    o_Target = output_color;
-}
diff --git a/pipelined/bevy_pbr2/src/render/pbr.vert b/pipelined/bevy_pbr2/src/render/pbr.vert
deleted file mode 100644
index acc4a0bd87ce0..0000000000000
--- a/pipelined/bevy_pbr2/src/render/pbr.vert
+++ /dev/null
@@ -1,28 +0,0 @@
-#version 450
-
-layout(location = 0) in vec3 Vertex_Position;
-layout(location = 1) in vec3 Vertex_Normal;
-layout(location = 2) in vec2 Vertex_Uv;
-
-layout(location = 0) out vec4 v_WorldPosition;
-layout(location = 1) out vec3 v_WorldNormal;
-layout(location = 2) out vec2 v_Uv;
-
-layout(set = 0, binding = 0) uniform View {
-    mat4 ViewProj;
-    vec3 ViewWorldPosition;
-};
-
-layout(set = 1, binding = 0) uniform MeshTransform {
-    mat4 Model;
-};
-
-void main() {
-    v_Uv = Vertex_Uv;
-    vec4 world_position = Model * vec4(Vertex_Position, 1.0);
-    v_WorldPosition = world_position;
-    // FIXME: The inverse transpose of the model matrix should be used to correctly handle scaling
-    // of normals
-    v_WorldNormal = mat3(Model) * Vertex_Normal;
-    gl_Position = ViewProj * world_position;
-}
diff --git a/pipelined/bevy_pbr2/src/render/pbr.wgsl b/pipelined/bevy_pbr2/src/render/pbr.wgsl
index a6cceee762f42..3bc711fb06a3a 100644
--- a/pipelined/bevy_pbr2/src/render/pbr.wgsl
+++ b/pipelined/bevy_pbr2/src/render/pbr.wgsl
@@ -40,7 +40,7 @@ fn vertex(vertex: Vertex) -> VertexOutput {
     // of normals
     out.world_normal = mat3x3<f32>(mesh.transform.x.xyz, mesh.transform.y.xyz, mesh.transform.z.xyz) * vertex.normal;
     return out;
-} 
+}
 
 // From the Filament design doc
 // https://google.github.io/filament/Filament.html#table_symbols
@@ -87,12 +87,14 @@ struct StandardMaterial {
     flags: u32;
 };
 
-struct OmniLight {
-    view_projection: mat4x4<f32>;
+struct PointLight {
     color: vec4<f32>;
+    // projection: mat4x4<f32>;
     position: vec3<f32>;
-    range: f32;
+    inverse_square_range: f32;
     radius: f32;
+    near: f32;
+    far: f32;
     shadow_bias_min: f32;
     shadow_bias_max: f32;
 };
@@ -109,10 +111,10 @@ struct DirectionalLight {
 struct Lights {
     // NOTE: this array size must be kept in sync with the constants defined bevy_pbr2/src/render/light.rs
     // TODO: this can be removed if we move to storage buffers for light arrays
-    omni_lights: array<OmniLight, 10>;
+    point_lights: array<PointLight, 10>;
     directional_lights: array<DirectionalLight, 1>;
     ambient_color: vec4<f32>;
-    n_omni_lights: u32;
+    n_point_lights: u32;
     n_directional_lights: u32;
 };
 
@@ -127,9 +129,13 @@ let FLAGS_UNLIT_BIT: u32                      = 32u;
 [[group(0), binding(1)]]
 var lights: Lights;
 [[group(0), binding(2)]]
-var shadow_textures: texture_depth_2d_array;
+var point_shadow_textures: texture_depth_cube_array;
 [[group(0), binding(3)]]
-var shadow_textures_sampler: sampler_comparison;
+var point_shadow_textures_sampler: sampler_comparison;
+[[group(0), binding(4)]]
+var directional_shadow_textures: texture_depth_2d_array;
+[[group(0), binding(5)]]
+var directional_shadow_textures_sampler: sampler_comparison;
 
 [[group(2), binding(0)]]
 var material: StandardMaterial;
@@ -306,14 +312,14 @@ fn reinhard_extended_luminance(color: vec3<f32>, max_white_l: f32) -> vec3<f32>
     return change_luminance(color, l_new);
 }
 
-fn omni_light(
-    world_position: vec3<f32>, light: OmniLight, roughness: f32, NdotV: f32, N: vec3<f32>, V: vec3<f32>,
+fn point_light(
+    world_position: vec3<f32>, light: PointLight, roughness: f32, NdotV: f32, N: vec3<f32>, V: vec3<f32>,
     R: vec3<f32>, F0: vec3<f32>, diffuseColor: vec3<f32>
 ) -> vec3<f32> {
     let light_to_frag = light.position.xyz - world_position.xyz;
     let distance_square = dot(light_to_frag, light_to_frag);
     let rangeAttenuation =
-        getDistanceAttenuation(distance_square, light.range);
+        getDistanceAttenuation(distance_square, light.inverse_square_range);
 
     // Specular.
     // Representative Point Area Lights.
@@ -373,7 +379,44 @@ fn directional_light(light: DirectionalLight, roughness: f32, NdotV: f32, normal
     return (specular_light + diffuse) * light.color.rgb * NoL;
 }
 
-fn fetch_shadow(light_id: i32, homogeneous_coords: vec4<f32>, shadow_bias: f32) -> f32 {
+fn fetch_point_shadow(light_id: i32, frag_position: vec4<f32>, shadow_bias: f32) -> f32 {
+    let light = lights.point_lights[light_id];
+
+    // because the shadow maps align with the axes and the frustum planes are at 45 degrees
+    // we can get the worldspace depth by taking the largest absolute axis
+    let frag_ls = light.position.xyz - frag_position.xyz;
+    let abs_position_ls = abs(frag_ls);
+    let major_axis_magnitude = max(abs_position_ls.x, max(abs_position_ls.y, abs_position_ls.z));
+
+    // do a full projection
+    // vec4 clip = light.projection * vec4(0.0, 0.0, -major_axis_magnitude, 1.0);
+    // float depth = (clip.z / clip.w);
+
+    // alternatively do only the necessary multiplications using near/far
+    let proj_r = light.far / (light.near - light.far);
+    let z = -major_axis_magnitude * proj_r + light.near * proj_r;
+    let w = major_axis_magnitude;
+    let depth = z / w;
+
+    // let shadow = texture(samplerCubeArrayShadow(t_Shadow, s_Shadow), vec4(frag_ls, i), depth - bias);
+
+    // manual depth testing
+    // float shadow = texture(samplerCubeArray(t_Shadow, s_Shadow), vec4(-frag_ls, 6 * i)).r;
+    // shadow = depth > shadow ? 0.0 : 1.0;
+    // o_Target = vec4(vec3(shadow * 20 - 19, depth * 20 - 19, 0.0), 1.0);
+    // o_Target = vec4(vec3(shadow * 20 - 19), 1.0);
+
+    // do the lookup, using HW PCF and comparison
+    // NOTE: Due to the non-uniform control flow above, we must use the Level variant of
+    //       textureSampleCompare to avoid undefined behaviour due to some of the fragments in
+    //       a quad (2x2 fragments) being processed not being sampled, and this messing with
+    //       mip-mapping functionality. The shadow maps have no mipmaps so Level just samples
+    //       from LOD 0.
+    let bias = 0.0001;
+    return textureSampleCompareLevel(point_shadow_textures, point_shadow_textures_sampler, frag_ls, i32(light_id), depth - shadow_bias);
+}
+
+fn fetch_directional_shadow(light_id: i32, homogeneous_coords: vec4<f32>, shadow_bias: f32) -> f32 {
     if (homogeneous_coords.w <= 0.0) {
         return 1.0;
     }
@@ -385,7 +428,7 @@ fn fetch_shadow(light_id: i32, homogeneous_coords: vec4<f32>, shadow_bias: f32)
     // do the lookup, using HW PCF and comparison
     // NOTE: Due to non-uniform control flow above, we must use the level variant of the texture
     //       sampler to avoid use of implicit derivatives causing possible undefined behavior.
-    return textureSampleCompareLevel(shadow_textures, shadow_textures_sampler, light_local, i32(light_id), homogeneous_coords.z * proj_correction - shadow_bias);
+    return textureSampleCompareLevel(directional_shadow_textures, directional_shadow_textures_sampler, light_local, i32(light_id), homogeneous_coords.z * proj_correction - shadow_bias);
 }
 
 struct FragmentInput {
@@ -451,7 +494,7 @@ fn fragment(in: FragmentInput) -> [[location(0)]] vec4<f32> {
         // #    endif
 
         var V: vec3<f32>;
-        if (view.view_proj.z.z != 1.0) { // If the projection is not orthographic
+        if (view.view_proj.w.w != 1.0) { // If the projection is not orthographic
             // Only valid for a perpective projection
             V = normalize(view.world_position.xyz - in.world_position.xyz);
         } else {
@@ -474,17 +517,17 @@ fn fragment(in: FragmentInput) -> [[location(0)]] vec4<f32> {
 
         // accumulate color
         var light_accum: vec3<f32> = vec3<f32>(0.0);
-        let n_omni_lights = i32(lights.n_omni_lights);
+        let n_point_lights = i32(lights.n_point_lights);
         let n_directional_lights = i32(lights.n_directional_lights);
-        for (var i: i32 = 0; i < n_omni_lights; i = i + 1) {
-            let light = lights.omni_lights[i];
-            let light_contrib = omni_light(in.world_position.xyz, light, roughness, NdotV, N, V, R, F0, diffuse_color);
+        for (var i: i32 = 0; i < n_point_lights; i = i + 1) {
+            let light = lights.point_lights[i];
+            let light_contrib = point_light(in.world_position.xyz, light, roughness, NdotV, N, V, R, F0, diffuse_color);
             let dir_to_light = normalize(light.position.xyz - in.world_position.xyz);
             let shadow_bias = max(
                 light.shadow_bias_max * (1.0 - dot(in.world_normal, dir_to_light)),
                 light.shadow_bias_min
             );
-            let shadow = fetch_shadow(i, light.view_projection * in.world_position, shadow_bias);
+            let shadow = fetch_point_shadow(i, in.world_position, shadow_bias);
             light_accum = light_accum + light_contrib * shadow;
         }
         for (var i: i32 = 0; i < n_directional_lights; i = i + 1) {
@@ -494,7 +537,7 @@ fn fragment(in: FragmentInput) -> [[location(0)]] vec4<f32> {
                 light.shadow_bias_max * (1.0 - dot(in.world_normal, light.direction_to_light.xyz)),
                 light.shadow_bias_min
             );
-            let shadow = fetch_shadow(n_omni_lights + i, light.view_projection * in.world_position, shadow_bias);
+            let shadow = fetch_directional_shadow(i, light.view_projection * in.world_position, shadow_bias);
             light_accum = light_accum + light_contrib * shadow;
         }
 
@@ -515,4 +558,4 @@ fn fragment(in: FragmentInput) -> [[location(0)]] vec4<f32> {
     }
 
     return output_color;
-}
\ No newline at end of file
+}
diff --git a/pipelined/bevy_render2/Cargo.toml b/pipelined/bevy_render2/Cargo.toml
index b8366c3100701..00d17d27c945f 100644
--- a/pipelined/bevy_render2/Cargo.toml
+++ b/pipelined/bevy_render2/Cargo.toml
@@ -29,7 +29,7 @@ bevy_utils = { path = "../../crates/bevy_utils", version = "0.5.0" }
 image = { version = "0.23.12", default-features = false }
 
 # misc
-wgpu = "0.8"
+wgpu = "0.9"
 naga = { git = "https://github.com/gfx-rs/naga", rev = "0cf5484bba530f1134badbd2a1c1a8e9daf2e9c3", features = ["glsl-in", "spv-out", "spv-in", "wgsl-in"] }
 serde = { version = "1", features = ["derive"] }
 bitflags = "1.2.1"
diff --git a/pipelined/bevy_render2/src/camera/mod.rs b/pipelined/bevy_render2/src/camera/mod.rs
index 73bf01ca82b9d..23b31691d96e5 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 fdcfbb6e588ee..0000000000000
--- 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 cba45f1b7ebab..0a6ab6e3a8820 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 7dbc355c238f9..36769ec92e243 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 9f1946b668827..4f04b66a50413 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 b15db6b67440c..26f784b8ea22e 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 19f70e8084c43..daf5d37be9ff8 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 9d948452e4e03..c179be09da9ee 100644
--- a/pipelined/bevy_render2/src/render_resource/uniform_vec.rs
+++ b/pipelined/bevy_render2/src/render_resource/uniform_vec.rs
@@ -43,6 +43,16 @@ impl<T: AsStd140> UniformVec<T> {
         })
     }
 
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.values.len()
+    }
+
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.values.is_empty()
+    }
+
     #[inline]
     pub fn capacity(&self) -> usize {
         self.capacity
@@ -144,6 +154,16 @@ impl<T: AsStd140> DynamicUniformVec<T> {
         self.uniform_vec.binding()
     }
 
+    #[inline]
+    pub fn len(&self) -> usize {
+        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/renderer/render_device.rs b/pipelined/bevy_render2/src/renderer/render_device.rs
index 2063a95ead12e..2cb437c1222ee 100644
--- a/pipelined/bevy_render2/src/renderer/render_device.rs
+++ b/pipelined/bevy_render2/src/renderer/render_device.rs
@@ -36,7 +36,10 @@ impl RenderDevice {
 
     /// Creates a shader module from either SPIR-V or WGSL source code.
     #[inline]
-    pub fn create_shader_module<'a>(&self, desc: impl Into<wgpu::ShaderModuleDescriptor<'a>>) -> wgpu::ShaderModule {
+    pub fn create_shader_module<'a>(
+        &self,
+        desc: impl Into<wgpu::ShaderModuleDescriptor<'a>>,
+    ) -> wgpu::ShaderModule {
         self.device.create_shader_module(&desc.into())
     }
 
diff --git a/pipelined/bevy_render2/src/texture/image.rs b/pipelined/bevy_render2/src/texture/image.rs
index 026095a0883c7..d0294ab265746 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_render2/src/view/window.rs b/pipelined/bevy_render2/src/view/window.rs
index 3173da919cc2d..ddae464da516c 100644
--- a/pipelined/bevy_render2/src/view/window.rs
+++ b/pipelined/bevy_render2/src/view/window.rs
@@ -117,19 +117,20 @@ pub fn prepare_windows(
             .entry(window.id)
             .or_insert_with(|| render_device.create_swap_chain(surface, &swap_chain_descriptor));
 
-        let frame = if let Ok(swap_chain_frame) = swap_chain.get_current_frame() {
-            swap_chain_frame
-        } else {
-            let swap_chain = window_surfaces
-                .swap_chains
-                .entry(window.id)
-                .or_insert_with(|| {
-                    render_device.create_swap_chain(surface, &swap_chain_descriptor)
-                });
-
-            swap_chain
-                .get_current_frame()
-                .expect("Failed to acquire next swap chain texture!")
+        let frame = match swap_chain.get_current_frame() {
+            Ok(swap_chain_frame) => swap_chain_frame,
+            Err(wgpu::SwapChainError::Outdated) => {
+                let new_swap_chain =
+                    render_device.create_swap_chain(surface, &swap_chain_descriptor);
+                let frame = new_swap_chain
+                    .get_current_frame()
+                    .expect("Error recreating swap chain");
+                window_surfaces
+                    .swap_chains
+                    .insert(window.id, new_swap_chain);
+                frame
+            }
+            err => err.expect("Failed to acquire next swap chain texture!"),
         };
 
         window.swap_chain_frame = Some(TextureView::from(frame));
diff --git a/pipelined/bevy_sprite2/src/render/mod.rs b/pipelined/bevy_sprite2/src/render/mod.rs
index 3e1de274f7878..9f55cca8afa27 100644
--- a/pipelined/bevy_sprite2/src/render/mod.rs
+++ b/pipelined/bevy_sprite2/src/render/mod.rs
@@ -2,7 +2,18 @@ use crate::Sprite;
 use bevy_asset::{Assets, Handle};
 use bevy_ecs::{prelude::*, system::SystemState};
 use bevy_math::{Mat4, Vec2, Vec3, Vec4Swizzles};
-use bevy_render2::{core_pipeline::Transparent2dPhase, mesh::{shape::Quad, Indices, Mesh, VertexAttributeValues}, render_asset::RenderAssets, render_graph::{Node, NodeRunError, RenderGraphContext}, render_phase::{Draw, DrawFunctions, Drawable, RenderPhase, TrackedRenderPass}, render_resource::*, renderer::{RenderContext, RenderDevice}, shader::Shader, texture::{BevyDefault, Image}, view::{ViewMeta, ViewUniform, ViewUniformOffset}};
+use bevy_render2::{
+    core_pipeline::Transparent2dPhase,
+    mesh::{shape::Quad, Indices, Mesh, VertexAttributeValues},
+    render_asset::RenderAssets,
+    render_graph::{Node, NodeRunError, RenderGraphContext},
+    render_phase::{Draw, DrawFunctions, Drawable, RenderPhase, TrackedRenderPass},
+    render_resource::*,
+    renderer::{RenderContext, RenderDevice},
+    shader::Shader,
+    texture::{BevyDefault, Image},
+    view::{ViewMeta, ViewUniform, ViewUniformOffset},
+};
 use bevy_transform::components::GlobalTransform;
 use bevy_utils::slab::{FrameSlabMap, FrameSlabMapKey};
 use bytemuck::{Pod, Zeroable};
@@ -201,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;
     }
 
@@ -266,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>,
@@ -276,6 +288,10 @@ pub fn queue_sprites(
     gpu_images: Res<RenderAssets<Image>>,
     mut views: Query<&mut RenderPhase<Transparent2dPhase>>,
 ) {
+    if view_meta.uniforms.is_empty() {
+        return;
+    }
+
     // TODO: define this without needing to check every frame
     sprite_meta.view_bind_group.get_or_insert_with(|| {
         render_device.create_bind_group(&BindGroupDescriptor {
diff --git a/src/lib.rs b/src/lib.rs
index 4338bfa21f070..cf314d3e200ca 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,3 +1,5 @@
+#![allow(clippy::single_component_path_imports)]
+
 //! [![](https://bevyengine.org/assets/bevy_logo_docs.svg)](https://bevyengine.org)
 //!
 //! Bevy is an open-source modular game engine built in Rust, with a focus on developer productivity
@@ -45,5 +47,4 @@ pub use bevy_internal::*;
 
 #[cfg(feature = "dynamic")]
 #[allow(unused_imports)]
-#[allow(clippy::single_component_path_imports)]
 use bevy_dylib;